[bzoj 1016] [JSOI2008]最小生成树计数：Kruskal，枚举

题意：求给定无向加权图不同最小生成树的棵数，点不超过100个，边不超过1000条，权值相等的边不超过10条，无自环、重边。只要两棵最小生成树有一条边不同，那么它们就不一样。

我猜想这道题一定和Kruskal有关，考察对算法的理解。就像 NOI 2014 动物园 考察对KMP的理解。

为什么会产生不同的最小生成树呢？Kruskal中的不确定因素是什么？排序。只要求按边权升序排列，没对相等的边权作要求。

是不是合并过程中，每个时刻图的连通情况都相同，无论权值相等的边怎么摆？如果这样，那么只用检查权值相等且连接相同的两个连通块的边。

其实这样样例都过不了，而且反例很容易举。没有深入思考就开始码……

说起来，今天物理课讲逻辑电路，老师问我们班两个搞OI的同学偏软还是偏硬：“你们是敲字母？”然后老师让我去讲一道题，可是当时没搞出来……

然而，如果把权值相等的边看作一整段，每段结束后，连通情况必然是相同的。只需求出有多少种方式能到达相同的局面即可。枚举？怎么判断两种局面是否相同呢？时间复杂度会爆炸吗？跑矩阵树？这道题听人讲过（但是没明白），没说要用这个啊，而且我目前不会……

---

UPDATE 2016.11.15
为什么每段结束后连通情况相同呢？给一个直观的解释。不可能合并更多连通块。如果没合并本可以合并的连通块，要么永远不连通，要么由其他更大边权的边完成这件事，从而与最小性相悖。

---

看了题解。我离正解很近了……但是没能更进一步。既然不管怎么合并，连通情况是相同的，那么只需判断合并的次数。经过估算，“权值相等的边不超过10条”保证了枚举的可行性。现在想来，按照之前的一点点思路，扫描一遍用最小表示法编号来判断也是可以的，这样这道题基本上就是我自己做出来的了；但是马后炮谁都会……

WA了几次，复制、还原数组没搞清楚，而且没判断无解的情况……我的脑海里是闪过这个念头的，但是重新瞟了一眼题面，错误地认为数据保证有解（出题人：我可没说）。看了神犇的代码才发现这个问题……

据说矩阵树也是可以的。

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAX_N = 100, MAX_M = 1000, MOD = 31011;
int n, m, buf[3][MAX_N+1], *root = buf[0], *t = buf[1], *t1 = buf[2], op[10], size; // t～初态，t1～末态
struct Edge {
    int u, v, c;
    bool operator<(const Edge& rhs) const
    {
        return c < rhs.c;
    }
} E[MAX_M];

int get_root(int x)
{
    return x == root[x] ? x : root[x] = get_root(root[x]);
}

// 填充第i位，一共j位，值域[k, l)
int cal(int i, int j, int k, int l)
{
    if (i == j) {
        int cnt = 0;
        memcpy(root, t, size);
        for (int p = 0; p < j; ++p) {
            int e = op[p], rx = get_root(E[e].u), ry = get_root(E[e].v);
            if (rx != ry) {
                ++cnt;
                root[ry] = rx;
            }
        }
        return cnt == j;
    }
    int ans = 0;
    for (int x = k; x < l; ++x) {
        op[i] = x;
        ans += cal(i+1, j, x+1, l);
    }
    return ans;
}

int main()
{
    scanf("%d %d", &n, &m);
    size = sizeof(int)*(n+1);
    for (int i = 1; i <= n; ++i)
        root[i] = i;
    for (int i = 0; i < m; ++i)
        scanf("%d %d %d", &E[i].u, &E[i].v, &E[i].c);
    sort(E, E+m);

    int ans = 1, tot = 0;

    for (int i = 0, j; i < m; i = j) {
        memcpy(t, root, size);
        int cnt = 0;
        for (j = i; j < m && E[i].c == E[j].c; ++j) {
            int rx = get_root(E[j].u), ry = get_root(E[j].v);
            if (rx != ry) {
                root[ry] = rx;
                ++cnt;
            }
        }
        if (cnt) {
            memcpy(t1, root, size);
            ans = (ans * cal(0, cnt, i, j)) % MOD;
            swap(root, t1);
        }
        tot += cnt;
    }
    printf("%d\n", tot < n-1 ? 0 : ans);
    return 0;
}