洛谷4208 bzoj1016 JSOI2008 最小生成树计数 矩阵树定理

题目链接
题意：给你 n n 个点， m m 条无向边，求最小生成树个数。 n≤100 n ≤ 100 ， m≤1000 m ≤ 1000 ，其中每种权值的边不超过 10 10 条。
由于有每种权值的边不超过 10 10 条，所以有可以过的搜索算法，但是我觉得这道题作为练习题而不是比赛题的话，用搜索写实在是有点可惜。
下面我们来介绍这道题的做法。
首先，对于最小生成树，有以下性质：
1.在做最小生成树的过程中，每种边权处理完后图的连通性相同。
2.在最小生成树上，每种边权的边的数量是一定的。
这个我不会这些性质的很严谨的证明，但是根据Kruskal的过程应该不难想明白。第一个的话之前权值小的边没法连通的你肯定用当前权值的边使之连通，已经连通的地方连通性不受当前权值的边的影响。第二个的话，由第一个可得，每种边加进去后连通性一样，那么似乎很显然每种边加进去的数目也是一定的，不然连通性就不一定是一样的了。当然要是想看正确且严谨的证明还是需要去自行查找的。
然后我们来知道了这些性质后的用处。我们发现，对于在最小生成树中的每一种边，它的连法是独立的，也就是不受其他边的影响的，那么我们可以发现，如果我们对每一种权值的边分开计算的话，答案是可以用乘法原理来统计的。
那么我们就对所有的边进行升序排序，然后分别计算每一种权值的边对答案的贡献。每种权值的边对答案的贡献我们是用矩阵树定理来计算的，方法是我们把除掉当前权值的边之后的其余边连好，然后把连好的连通块缩点，这个用并查集就可以，然后再把当前权值的边连上，用矩阵树定理求解即可。
另外就是这道题的模数不是质数！所以我一开始写的求逆元的写法都错了。后来问lyf神犇这种东西怎么搞，他告诉我要质因数分解之后对每个求逆元，然后CRT合并。但是我看到的题解没有这么写的，然后研究了一下发现了一个奇妙的做法。我们考虑在高斯消元的过程中其实目标就是用当前行把其他行的当前元全消掉，但是其实我们并不在意具体是哪个方程被消没了。所以我们考虑用欧几里得算法像求gcd一样用辗转相除来把一行消掉，这样就避免了取模带来的尴尬。
我当时看题解的时候就觉得这个东西很难写，实际上代码中确实用很多细节，我基本都给了注释。

#include 
using namespace std;

int n,m,mod=31011,b[101][101],cnt;
int ans=1,sum;//sum记录连通块个数
int book[10001]; //记录出现过哪些点是当前情况下并查集里的根 
int block[10001];//记录每个连通块的根节点 
int fa[10001],f[1001];//f记录克鲁斯卡尔的连通性，fa记录矩阵的连通性 
struct node
{
    int x,y,dis;
}a[10000],ji[10001];
int cmp(node x,node y)
{
    if(x.dis!=y.dis)
    return x.diselse if(x.x!=y.x)
    return x.xelse
    return x.yint getr(int x)
{
    if(x==f[x])
    return x;
    else
    {
        f[x]=getr(f[x]);
        return f[x];
    }
}
int getfa(int x)
{
    if(x==fa[x])
    return x;
    else
    {
        fa[x]=getfa(fa[x]);
        return fa[x];
    }
}
void gauss(int p)
{
    for(int i=1;i<=p;++i)
    {
        for(int j=i+1;j<=p;++j)
        {
            while(b[j][i])//用求gcd一样的方法把b[j][i]消成0 
            {
                int t=b[i][i]/b[j][i];
                for(int k=i;k<=p;++k)
                b[i][k]=(b[i][k]-t*b[j][k])%mod;
                swap(b[i],b[j]);
                ans=-ans;//每次交换记得行列式值变为相反数 
            }
        }
        ans=(ans*b[i][i])%mod;
    }
}
void cal(int p)//ji[1]到ji[p]的边权一样 
{
    cnt=0;//记录连通块数量 
    int shu=0;
    for(int i=1;i<=p;++i)
    {
        ji[i].x=getr(ji[i].x);
        ji[i].y=getr(ji[i].y);
        if(ji[i].x!=ji[i].y)
        {
            book[++shu]=ji[i].x;
            book[++shu]=ji[i].y;
        } 
    }
    sort(book+1,book+shu+1);//将出现过的根节点离散化 
    for(int i=1;i<=shu;++i)//记录去重后每个连通块的根 
    {
        if(book[i]!=block[cnt])
        block[++cnt]=book[i];
    }
    memset(b,0,sizeof(b));
    for(int i=1;i<=cnt;++i)
    fa[i]=i;
    for(int i=1;i<=p;++i)
    {
        int x=ji[i].x,y=ji[i].y;
        if(x==y)//本来就属于同一个连通块 
        continue;
        if(getr(x)!=getr(y))//连起来之后连通块减少 
        --sum;
        f[getr(x)]=getr(y); 
        //找到离散化后对应连通块编号 
        x=lower_bound(block+1,block+cnt+1,x)-block;
        y=lower_bound(block+1,block+cnt+1,y)-block;
        ++b[x][x];
        ++b[y][y];
        --b[x][y];
        --b[y][x];
        fa[getfa(x)]=getfa(y);//修改矩阵中图的连通性 
    }   
/*
注意此时整个与当前长度的边相关的图不一定连通， 
所以为了得到正确的答案，我们可以把每个连通块
与之前某个连通块相连，新边是缩点后的图的割边
所以选法是唯一的，不选它就无法形成生成树，
所以不会影响答案。 
*/
    for(int i=2;i<=cnt;++i)
    {
        int x=getfa(i),y=getfa(i-1);
        if(x!=y)
        {
            ++b[x][x];
            ++b[y][y];
            --b[x][y];
            --b[y][x];
            fa[getfa(x)]=getfa(y);
        }
    }
    gauss(cnt-1);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;++i)
    scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].dis);
    for(int i=1;i<=n;++i)
    {
        fa[i]=i;
        f[i]=i;
    }
    sort(a+1,a+1+m,cmp);
    sum=n;//记录原图中的连通块个数 
    int j=1;
    for(int i=1;i<=m;i=j++)
    {
        while(j<=m&&a[i].dis==a[j].dis)//得到一段边权相等的边 
        ++j;
        if(j-i>1)//如果只有1的话就只需要乘1，不用去计算了 
        {
            for(int k=1;k<=j-i;++k)
            ji[k]=a[i+k-1];
            cal(j-i); 
        }
        else if(getr(a[i].x)!=getr(a[i].y))
        {
            f[getr(a[i].x)]=getr(a[i].y);
            --sum;
        }
    }
    if(sum>1)//原图不连通 
    printf("0\n");
    else
    printf("%d\n",ans);
    return 0;
}