HDU 4408

题解：

Kruskal 算法的基本思想是，按照边长排序，然后不断将短边加入集合，最终一步如果能成功把 n-1 条边都加入同一个集合，则找到了最小生成树。在维护集合时，可以使用并查集来快速处理。

如果把 Kruskal 的过程按照边长划分成多个阶段，实际上是处理了所有短边的连通性之后继续处理下一个长度的边的连通性，并依次继续处理剩下边的连通性。

然后我们可以发现，不同长度的边之间的连通性互不影响。

假设存在 n1 条长度为 c1 的边，n2 条长度为 c2 的边… 则 Kruskal 首先处理 c1 边的连通性，然后处理 c2 边的连通性。

对于 c1 边的连通性的处理可能有多种方案，即从 n1 条边中取出一定数量的边构成最大连通图，但是最终处理完之后的结果对于 c2 来说是完全一样的。

因此算法就出来了，在 Kruskal 的基础上，使用 Matrix-Tree 定理处理每个阶段生成树的种数，最后将所有阶段的结果相乘即可。

以上转自http://jcf94.com/2014/11/03/2014-11-03-HDU-4408/

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
#define LL long long
const int MAXN = 105;
const int MAXM = 1005;
struct Matrix {
    LL mat[MAXN][MAXN];
    void init() {
        memset(mat, 0, sizeof(mat));
    }
    LL det(int n, LL MOD) 
    {
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                mat[i][j] = (mat[i][j] % MOD + MOD) % MOD;
        LL res = 1;
        for (int i = 0; i < n; i++)
        {
            for (int j = i+1; j < n; j++)
            {
                while (mat[j][i])
                {
                    LL t = mat[i][i] / mat[j][i];
                    for (int k = i; k < n; k++)
                    {
                        mat[i][k] = (mat[i][k] - t*mat[j][k]) % MOD;
                        swap(mat[i][k], mat[j][k]);
                    }
                    res = -res;
                }
            }
            res = res * mat[i][i] % MOD;            
        }
        return (res+MOD) % MOD;
    }
}ret;
int g[MAXN][MAXN];
struct Edge {
    int u, v, w;
    Edge() {}
    Edge(int a, int b): u(a), v(b) {}
    friend bool operator < (Edge a, Edge b) {
        return a.w < b.w;
    }
}edge[MAXM];
int f[MAXN];
int sf(int x){
    return x == f[x] ? x : f[x] = sf(f[x]);
}
int Belong[MAXN], tot;
namespace SV //处理单层 
{
    vector<Edge> edge;
    vector<int> node;
    int f[MAXN];//寻找连通分量     
    int sf(int x) {
        return x == f[x] ? x : f[x] = sf(f[x]);
    }
    int id[MAXN];
    LL solve(int n, LL MOD)
    {
        for (int i = 0; i < n; i++) f[i] = i;
        LL res = 1;
        for (int i = 0; i < edge.size(); i++)
        {
            f[sf(edge[i].u)] = sf(edge[i].v);
        }
        for (int i = 0; i < n; i++)
        {
            if (sf(i) == i)//处理同一连通分量 
            {
                node.clear();
                memset(g, 0, sizeof(g));
                memset(id, -1, sizeof(id));
                ret.init();
                for (int j = 0; j < n; j++)
                    if (sf(j) == i) node.push_back(j);
                for (int j = 0; j < node.size(); j++)
                    id[node[j]] = j;
                for (int j = 0; j < edge.size(); j++)
                {
                    if (id[edge[j].u] == -1 || id[edge[j].v] == -1) continue;
                    int u = id[edge[j].u], v = id[edge[j].v];
                    g[u][v]++, g[v][u]++;
                }
                int cnt = node.size();//点数 
                for (int j = 0; j < cnt; j++)
                    for (int k = 0; k < cnt; k++)
                        if (j != k && g[j][k] > 0) 
                            ret.mat[j][j] += g[j][k], ret.mat[j][k] = -g[j][k];
                res = res*ret.det(cnt-1, MOD) % MOD;
            }
        }
        return res%MOD;
    }
}
int n, m;
LL MOD;
LL ans;
int main()
{
    while (~scanf("%d%d%lld", &n, &m, &MOD) && (n+m+MOD))
    {
        for (int i = 1; i <= n; i++) f[i] = i;
        for (int i = 1; i <= m; i++)
        {
            scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
        }
        sort(edge+1, edge+m+1);
        ans = 1;
        for (int st = 1; st <= m;)
        {
            int ed = st;
            while (ed <= m && edge[ed].w == edge[st].w) ed++;
            tot = 0;
            for (int i = 1; i <= n; i++)
                if (sf(i) == i) Belong[i] = tot++;//计数连通块 
            for (int i = 1; i <= n; i++)
                Belong[i] = Belong[sf(i)];
            SV::edge.clear();
            for (int i = st; i < ed; i++)
            {
                int u = edge[i].u, v = edge[i].v;
                if (sf(u) == sf(v)) continue;
                SV::edge.push_back(Edge(Belong[u], Belong[v]));//子问题存边 
            }
            ans = ans * SV::solve(tot, MOD) % MOD;
            for (int i = st; i < ed; i++)
            {
                int u = edge[i].u, v = edge[i].v;
                f[sf(u)] = sf(v);
            }
            st = ed;
        }
        int cnt = 0;
        for (int i = 1; i <= n; i++)
            if (sf(i) == i) cnt++;
        if (cnt > 1) puts("0");
        else printf("%lld
", ans%MOD);
    }
}