全连通图求最小生成树边权之积（邻接矩阵/prim/kruskal）

Description

大家都知道最小生成树一般求的是构成最小生成树的边的权值之和。
现在请求构成最小生成树的边的权值之积 S，最终结果请输出 （S % 100003）。
P.S. 点之间的边为无向边，矩阵保证符合无向图的对称性。

Input

多组数据。

第一行，整数N，表示N个点。(0 < N <= 100)

接下来为一个N＊N 保证合法的邻接矩阵，矩阵内均为自然数。

Output

每组数据输出一行整数结果。

Sample Input

3
0 1 2
1 0 3
2 3 0
2
0 5
5 0

Prim

#include<iostream>
#include<cstring>
using namespace std;

#define MAX 105
#define INF 0x7FFFFFFF
int map[MAX][MAX];  // adjacency matrix
bool vis[MAX];  // is the node i visited
int dis[MAX];  // distance between current node and other node i

void prim(int n) {
    memset(vis, false, sizeof(vis));

    // current node is 0
    int cur = 0;
    for (int i = 0; i < n; ++i)
        dis[i] = map[cur][i];  // dis[] store distance between other nodes and 0
    vis[cur] = true;

    unsigned long long s = 1;
    for (int i = 0; i < n - 1; ++i) {
        // find the shortest edge between cur and other unvisited nodes
        int min = INF;
        for(int j = 0; j < n; ++j)
            if (!vis[j] && dis[j] < min)
                min = dis[cur = j];  // update to next shortest edge and potential cur

        // the other end is visited and is now current node
        s *= min;
        s %= 100003;
        vis[cur] = true;

        // update dis[] to store distance between other nodes and cur
        // if the node is visited, leave it
        for (int j = 0; j < n; ++j)
            if (!vis[j] && map[cur][j] < dis[j])
                dis[j] = map[cur][j];
    }
    cout << (s % 100003) << endl;
}

int main() {
    int n;

    while(scanf("%d", &n) != EOF) {
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                scanf("%d", &map[i][j]);
        prim(n);
    }

    return 0;
}

Kruskal，其实改装成了边表，加了并查集，有做路径压缩，可以水过就懒得写带rank的优化了……

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

#define MAX 105
#define INF 0x7FFFFFFF

int root[MAX];
int map[MAX][MAX];

struct Edge {
    int u, v;
    int d;
} e[MAX*MAX];

bool cmp(Edge a, Edge b) {
    return a.d < b.d;
}

int find(int x) {
    while(x != root[x]) {
         root[x] = root[root[x]];  // compress
        x = root[x];
    }
    return x;
}

unsigned long long kruskal(int vn, int en) {
    unsigned long long p = 1;

    // connect to itself
    for (int i = 0; i < vn; ++i)
        root[i] = i;

    // sort edges by length
    std::sort(e, e+en, cmp);

    for(int i = 0; i < en; ++i) {
        int ru = find(e[i].u);
        int rv = find(e[i].v);
        if(ru != rv) {  // the ends of e[i] are not in the same spanning tree
            root[ru] = rv;  // merge
            p *= e[i].d;
            p %= 100003;
        }
    }

    return p;
}

int main() {
    int vn;
    while(cin >> vn) {
        memset(map, 0, sizeof(map));
        for(int i = 0; i < vn; ++i)
            for(int j = 0; j < vn; ++j)
                cin >> map[i][j];

        int en = 0;
        for(int i = 0; i < vn; ++i)  // use upper-right corner
            for(int j = i + 1; j < vn; ++j) {
                // transform to adjacency list
                e[en].u = i;
                e[en].v = j;
                e[en].d = map[i][j];
                ++en;
            }
           cout << kruskal(vn, en) % 100003 << '
';
    }
    return 0;
}

因为数据太大所以每次乘完都要取模，不然会溢出。

因为本来就给的是邻接矩阵，kruskal要多做一步处理转换成边表，速度大约是prim的一半