HDU 4408 - Minimum Spanning Tree

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <vector>
  5 #include <algorithm>
  6 using namespace std;
  7 #define LL long long
  8 const int MAXN = 105;
  9 const int MAXM = 1005;
 10 struct Matrix {
 11     LL mat[MAXN][MAXN];
 12     void init() {
 13         memset(mat, 0, sizeof(mat));
 14     }
 15     LL det(int n, LL MOD) 
 16     {
 17         for (int i = 0; i < n; i++)
 18             for (int j = 0; j < n; j++)
 19                 mat[i][j] = (mat[i][j] % MOD + MOD) % MOD;
 20         LL res = 1;
 21         for (int i = 0; i < n; i++)
 22         {
 23             for (int j = i+1; j < n; j++)
 24             {
 25                 while (mat[j][i])
 26                 {
 27                     LL t = mat[i][i] / mat[j][i];
 28                     for (int k = i; k < n; k++)
 29                     {
 30                         mat[i][k] = (mat[i][k] - t*mat[j][k]) % MOD;
 31                         swap(mat[i][k], mat[j][k]);
 32                     }
 33                     res = -res;
 34                 }
 35             }
 36             res = res * mat[i][i] % MOD;            
 37         }
 38         return (res+MOD) % MOD;
 39     }
 40 }ret;
 41 int g[MAXN][MAXN];
 42 struct Edge {
 43     int u, v, w;
 44     Edge() {}
 45     Edge(int a, int b): u(a), v(b) {}
 46     friend bool operator < (Edge a, Edge b) {
 47         return a.w < b.w;
 48     }
 49 }edge[MAXM];
 50 int f[MAXN];
 51 int sf(int x){
 52     return x == f[x] ? x : f[x] = sf(f[x]);
 53 }
 54 int Belong[MAXN], tot;
 55 namespace SV //处理单层 
 56 {
 57     vector<Edge> edge;
 58     vector<int> node;
 59     int f[MAXN];//寻找连通分量     
 60     int sf(int x) {
 61         return x == f[x] ? x : f[x] = sf(f[x]);
 62     }
 63     int id[MAXN];
 64     LL solve(int n, LL MOD)
 65     {
 66         for (int i = 0; i < n; i++) f[i] = i;
 67         LL res = 1;
 68         for (int i = 0; i < edge.size(); i++)
 69         {
 70             f[sf(edge[i].u)] = sf(edge[i].v);
 71         }
 72         for (int i = 0; i < n; i++)
 73         {
 74             if (sf(i) == i)//处理同一连通分量 
 75             {
 76                 node.clear();
 77                 memset(g, 0, sizeof(g));
 78                 memset(id, -1, sizeof(id));
 79                 ret.init();
 80                 for (int j = 0; j < n; j++)
 81                     if (sf(j) == i) node.push_back(j);
 82                 for (int j = 0; j < node.size(); j++)
 83                     id[node[j]] = j;
 84                 for (int j = 0; j < edge.size(); j++)
 85                 {
 86                     if (id[edge[j].u] == -1 || id[edge[j].v] == -1) continue;
 87                     int u = id[edge[j].u], v = id[edge[j].v];
 88                     g[u][v]++, g[v][u]++;
 89                 }
 90                 int cnt = node.size();//点数 
 91                 for (int j = 0; j < cnt; j++)
 92                     for (int k = 0; k < cnt; k++)
 93                         if (j != k && g[j][k] > 0) 
 94                             ret.mat[j][j] += g[j][k], ret.mat[j][k] = -g[j][k];
 95                 res = res*ret.det(cnt-1, MOD) % MOD;
 96             }
 97         }
 98         return res%MOD;
 99     }
100 }
101 int n, m;
102 LL MOD;
103 LL ans;
104 int main()
105 {
106     while (~scanf("%d%d%lld", &n, &m, &MOD) && (n+m+MOD))
107     {
108         for (int i = 1; i <= n; i++) f[i] = i;
109         for (int i = 1; i <= m; i++)
110         {
111             scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
112         }
113         sort(edge+1, edge+m+1);
114         ans = 1;
115         for (int st = 1; st <= m;)
116         {
117             int ed = st;
118             while (ed <= m && edge[ed].w == edge[st].w) ed++;
119             tot = 0;
120             for (int i = 1; i <= n; i++)
121                 if (sf(i) == i) Belong[i] = tot++;//计数连通块 
122             for (int i = 1; i <= n; i++)
123                 Belong[i] = Belong[sf(i)];
124             SV::edge.clear();
125             for (int i = st; i < ed; i++)
126             {
127                 int u = edge[i].u, v = edge[i].v;
128                 if (sf(u) == sf(v)) continue;
129                 SV::edge.push_back(Edge(Belong[u], Belong[v]));//子问题存边 
130             }
131             ans = ans * SV::solve(tot, MOD) % MOD;
132             for (int i = st; i < ed; i++)
133             {
134                 int u = edge[i].u, v = edge[i].v;
135                 f[sf(u)] = sf(v);
136             }
137             st = ed;
138         }
139         int cnt = 0;
140         for (int i = 1; i <= n; i++)
141             if (sf(i) == i) cnt++;
142         if (cnt > 1) puts("0");
143         else printf("%lld\n", ans%MOD);
144     }
145 }