BZOJ1016最小生成树计数最小生成树 + 排列组合

@[最小生成樹, 排列組合]

Discription

现在给出了一个简单无向加权图。你不满足于求出这个图的最小生成树，而希望知道这个图中有多少个不同的

最小生成树。（如果两颗最小生成树中至少有一条边不同，则这两个最小生成树就是不同的）。由于不同的最小生

成树可能很多，所以你只需要输出方案数对31011的模就可以了。

Input

第一行包含两个数，n和m，其中1<=n<=100; 1<=m<=1000; 表示该无向图的节点数和边数。每个节点用1~n的整

数编号。接下来的m行，每行包含两个整数：a, b, c，表示节点a, b之间的边的权值为c，其中1<=c<=1,000,000,0

00。数据保证不会出现自回边和重边。注意：具有相同权值的边不会超过10条。

Output

输出不同的最小生成树有多少个。你只需要输出数量对31011的模就可以了。

Sample Input

Sample Output

Solution

具體做法:

跑一遍最小生成樹, 統計最小生成樹中每一種權值的邊的出現次數\(sum\), 順便將圖中所有邊進行離散化;
查找在每一種權值的邊中選出\(sum\)條邊, 使得選出的邊滿足每一條邊所連接的都是兩個不同的并查集的組合數量;
在上一步的答案乘上這個數量(乘法原理), 並且將這種權值的所有邊所連接的并查集都連接起來;

嗯, 結束.

具體爲什麽這種做法能成立, 我也不知道QAQ

代碼比較傻, 隨便找了一個貼上

#include <bits/stdc++.h>

using namespace std;

struct edge

{

    int u, v, w, x;

    inline bool operator< (const edge &rhs) const

    {

        return x < rhs.x;

    }

}e[1005];

struct count

{

    int l, r, use;

}g[1005];

int n, m, fa[105], siz[105];

int getfa(int x)

{

    return fa[x] == x ? x : getfa(fa[x]);

}

void link(int u, int v)

{

    if(siz[u] > siz[v]) fa[v] = u, siz[u] += siz[v];

    else fa[u] = v, siz[v] += siz[u];

}

bool Kruskal()

{

    int cnt = 0, u, v;

    for(int i = 1; i <= m; ++i)

    {

        u = getfa(e[i].u), v = getfa(e[i].v);

        if(u != v)

        {

            link(u, v);

            ++g[e[i].w].use;

            if(++cnt == n - 1) return true;

        }

    }

    return false;

}

int DFS(int w, int i, int k)

{

    if(k == g[w].use) return 1;

    if(i > g[w].r) return 0;

    int ans = 0, u = getfa(e[i].u), v = getfa(e[i].v);

    if(u != v)

    {

        link(u, v);

        ans = DFS(w, i + 1, k + 1);

        fa[u] = u, fa[v] = v;

    }

    return ans + DFS(w, i + 1, k);

}

int main()

{

    int u, v, w, ans;

    cin >> n >> m;

    for(int i = 1; i <= n; ++i)

        fa[i] = i, siz[i] = 1;

    for(int i = 1; i <= m; ++i)

    {

        cin >> u >> v >> w;

        e[i] = (edge){u, v, 0, w};

    }

    sort(e + 1, e + m + 1);

    w = 0;

    for(int i = 1; i <= m; ++i)

        if(e[i].x == e[i - 1].x) e[i].w = w;

        else

        {

            g[w].r = i - 1;

            e[i].w = ++w;

            g[w].l = i;

        }

    g[w].r = m;

    ans = Kruskal();

    for(int i = 1; i <= n; ++i)

        fa[i] = i, siz[i] = 1;

    for(int i = 1; i <= w; ++i)

    {

        ans = ans * DFS(i, g[i].l, 0) % 31011;

        for(int j = g[i].l; j <= g[i].r; ++j)

        {

            u = getfa(e[j].u), v = getfa(e[j].v);

            if(u != v) link(u, v);

        }

    }

    cout << ans << endl;

    return 0;

}

最小生