全连通图求最小生成树边权之积（邻接矩阵/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 = ;
     for (int i = ; i < n; ++i)
         dis[i] = map[cur][i];  // dis[] store distance between other nodes and 0
     vis[cur] = true;

     unsigned long long s = ;
     for (int i = ; i < n - ; ++i) {
         // find the shortest edge between cur and other unvisited nodes
         int min = INF;
         for(int j = ; 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 %= ;
         vis[cur] = true;

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

 int main() {
     int n;

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

     return ;
 }

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 = ;

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

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

     for(int i = ; 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 %= ;
         }
     }

     return p;
 }

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

         int en = ;
         for(int i = ; i < vn; ++i)  // use upper-right corner
             for(int j = i + ; 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) %  << '\n';
     }
     return ;
 }

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

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