BZOJ 1016 生成树计数

　　现在给出了一个简单无向加权图。你不满足于求出这个图的最小生成树，而希望知道这个图中有多少个不同的
最小生成树。（如果两颗最小生成树中至少有一条边不同，则这两个最小生成树就是不同的）。由于不同的最小生
成树可能很多，所以你只需要输出方案数对31011的模

　　生成树的两个特点:

　　1.可能有多个生成树,但是每种权值边出现的次数在每个树中是相同的。

　　2.每一种生成树的每种权值边连接完成后形成的联通块状态相同。

　　解法1:保证了权值相同的边不超过10条 所以我们可以先得出每种权值边的个数，再暴力dfs枚举每种可能性得出这种权值的所有情况，答案就是所有情况数的累乘。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define mod 31011
using namespace std;
int n, m, cnt, tot, ans = , sum;
int fa[];
struct edge {
    int x, y, v;
} e[];
struct data {
    int l, r, v;
} a[];
inline int read()
{
    int x = ;
    char ch = getchar();
    while (ch < '' || ch > '') {
        ch = getchar();
    }
    while (ch >= '' && ch <= '') {
        x = x *  + ch - '';
        ch = getchar();
    }
    return x;
}
bool cmp(edge a, edge b)
{
    return a.v < b.v;
}
int find(int x)
{
    return x == fa[x] ? x : find(fa[x]);
}
void dfs(int x, int now, int k)
{
    if (now == a[x].r + ) {
        if (k == a[x].v) {
            sum++;
        }
        return;
    }
    int p = find(e[now].x), q = find(e[now].y);
    if (p != q) {
        fa[p] = q;
        dfs(x, now + , k + );
        fa[p] = p;
        fa[q] = q;
    }
    dfs(x, now + , k);
}
int main()
{
    n = read();
    m = read();
    for (int i = ; i <= n; i++) {
        fa[i] = i;
    }
    for (int i = ; i <= m; i++) {
        e[i].x = read(), e[i].y = read(), e[i].v = read();
    }
    sort(e + , e + m + , cmp);
    for (int i = ; i <= m; i++) {
        if (e[i].v != e[i - ].v) {
            a[++cnt].l = i;
            a[cnt - ].r = i - ;
        }
        int p = find(e[i].x), q = find(e[i].y);
        if (p != q) {
            fa[p] = q;
            a[cnt].v++;
            tot++;
        }
    }
    a[cnt].r = m;
    if (tot != n - ) {
        printf("");
        return ;
    }
    for (int i = ; i <= n; i++) {
        fa[i] = i;
    }
    for (int i = ; i <= cnt; i++) {
        sum = ;
        dfs(i, a[i].l, );
        ans = (ans * sum) % mod;
        for (int j = a[i].l; j <= a[i].r; j++) {
            int p = find(e[j].x), q = find(e[j].y);
            if (p != q && a[i].v) {
                fa[p] = q;
                a[i].v--;
            }
        }
    }
    printf("%d", ans);
    return ;
}

　　解法2:矩阵树

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cstdio>
#define p 31011
#define N 1003
using namespace std;
int a[][],c[N][N],n,m,vis[N],fa[N],U[N];
vector<int> V[N];
struct data{
    int x,y,c;
    bool operator<(const data &a)const{
      return c<a.c;
    }
}e[N];
int gauss(int n)
{
    for (int i=;i<=n;i++)
     for (int j=;j<=n;j++) a[i][j]%=p;
    //for (int i=1;i<=n;i++,cout<<endl)
     // for (int j=1;j<=n;j++) cout<<a[i][j]<<" ";
    int ret=;
    for (int i=;i<=n;i++) {
        int num=i;
        for (int j=i+;j<=n;j++)
         if (abs(a[j][i])) num=j;
        for (int j=;j<=n;j++) swap(a[num][j],a[i][j]);
        if (num!=i) ret=-ret;
        for (int j=i+;j<=n;j++)
         while (a[j][i]) {
            int t=a[j][i]/a[i][i];
            for (int k=;k<=n;k++)
             a[j][k]=(a[j][k]-t*a[i][k])%p;
            if (!a[j][i]) break;
            ret=-ret;
            for (int k=;k<=n;k++) swap(a[i][k],a[j][k]);
         }
        ret=(ret*a[i][i])%p;
    }
    //cout<<ret<<endl;
    return (ret%p+p)%p;
}
int find(int x,int f[N])
{
    if (x==f[x]) return x;
    else return find(f[x],f);
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=;i<=m;i++) scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].c);
    sort(e+,e+m+);
    for (int i=;i<=n;i++) vis[i]=,fa[i]=i;
    int ans=; int last=-;
    for (int i=;i<=m+;i++) {
        if (e[i].c!=last||i==m+) {
            for (int j=;j<=n;j++)
             if (vis[j]) {
                int r1=find(j,U);
                V[r1].push_back(j);
                vis[j]=;
             }
            for (int j=;j<=n;j++)
             if (V[j].size()>) {
                memset(a,,sizeof(a));
                int len=V[j].size();
                for (int k=;k<len;k++)
                 for (int l=k+;l<len;l++) {
                    int x=V[j][k]; int y=V[j][l]; int t=c[x][y];
                    a[k+][l+]-=t; a[l+][k+]-=t;
                    a[k+][k+]+=t; a[l+][l+]+=t;
                 }
                ans=ans*gauss(len-)%p;
                for (int k=;k<len;k++) fa[V[j][k]]=j;
             }
            for (int j=;j<=n;j++) {
                U[j]=fa[j]=find(j,fa);
                V[j].clear();
            }
            last=e[i].c;
            if(i==m+) break;
        }
        int x=e[i].x; int y=e[i].y;
        int r1=find(x,fa); int r2=find(y,fa);
        if (r1==r2) continue;
        U[find(r1,U)]=find(r2,U); vis[r1]=; vis[r2]=;
        c[r1][r2]++; c[r2][r1]++;
    }
    int flag=;
    for (int i=;i<=n;i++)
     if (find(i,U)!=find(i-,U)) flag=;
    ans=(ans*flag%p+p)%p;
    printf("%d\n",ans);
}