Uva 1664 Conquer a New Region （Kruskal化用）

該題巧妙的運用了並查集，運用了類似於最小生成樹算法的過程 ，通過該題可以對並查集有一個更深的理解 。

題目：由於i和j唯一通路上容量的最小值爲該兩點的容量，求一個點到其他所有點的容量最大值 。

顯然題目敘述與MST相似。問題是在合併集合時，中心城市的選擇。

首先，解決兩點的容量問題 ，我們將所有邊從大到小排序，然後從大到小枚舉，我們假設根結點就是要找的城市中心點，那麼當又加入一條邊時，該邊的兩個頂點所在的集合設爲A、B，集合A、B的頂點a、b，要讓誰當中心點呢？ 易知：無論誰當中心點，它與另一個集合中任一點的容量都爲該邊長度（因爲是從大到小枚舉的）。

那麼爲了求出總容量，我們要維護一些值，用空間換時間 。 維護每個頂點的總容量sum[i]，維護每個頂點與之相連的頂點數量，cnt[i]，當前答案ans 。

那麼對於a、b點，如果以a爲中心，總容量爲sum[a] + cnt[b] * e[i].c 。 反之亦然，哪個量大，則以哪個點爲城市中心，也就是並查集的根結點 。

該題的巧妙之處在於，將答案結點維護成並查集的根結點，快速的找出一個集合中的城市中心 。

並查集用了路徑壓縮之後其實已經很快了，沒有必要在改變樹的高度，因爲那樣會改變根結點，不僅寫起來麻煩，還丟掉了許多很好的特性 。

該題就是通過這些特性（根節點不變時），維護一些重要的量以達到快速求解的目的 。 請讀者細細品味 。

通過並查集進行不連續多源遍歷，最後合併成爲整體
參考：http://blog.csdn.net/weizhuwyzc000/article/details/47957359

#include<iostream>
#include<queue>
#include<cmath>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long LL;                                //int不夠，WA.....
const int maxn = 200010, INF = 10000000;  //需改

struct Edge
{
    LL from, to, dist;
    Edge(LL u, LL v, LL w) :from(u), to(v), dist(w) {}
};
bool cmp(const Edge &i, const Edge &j) //間接排序函數//注意定義順序
{
    return i.dist > j.dist;
}
struct Kruskal
{
    int n, m;
    vector<Edge> edges;
    int p[maxn];
    LL cnt[maxn];//每個頂點與之相連的頂點數(直接或間接)
    LL cap[maxn];//每個頂點的總容量


    void init(int n)
    {
        this->n = n;
        edges.clear();
        memset(p, 0, sizeof(p));//不需要？
    }
    void AddEdge(LL u, LL v, LL w)
    {
        edges.push_back(Edge(u, v, w));
        m = edges.size();
    }

    int find(int x)              //並查集的查找
    {
        return p[x] == x ? x : p[x] = find(p[x]);
    }

    LL kruskal()
    {
        LL ans = 0;
        for (int i = 0; i <= n; i++)  //注意循環中止==情況是否需要
        {
            p[i] = i;               //初始化並查集
            cnt[i] = 1;
        }
        memset(cap, 0, sizeof(cap));
        sort(edges.begin(), edges.end(), cmp);
        for (int i = 0; i < m; i++)
        {
            int x = find(edges[i].from);
            int y = find(edges[i].to);
            cap[x] += cnt[y] * edges[i].dist;  //集合之一的根節點與另一個集合中任一點的容量都爲該邊長度
            cap[y] += cnt[x] * edges[i].dist;
            if (cap[x] > cap[y])
            {
                p[y] = x;
                ans = cap[x];
                cnt[x] += cnt[y];
            }
            else
            //if (cap[y] > cap[x]) //注意不要落==情況
            {
                p[x] = y;
                ans = cap[y];
                cnt[y] += cnt[x];
            }
        }
        return ans;
    }
}K;
int main()
{
    int n;
    while (cin >> n)
    {
        int a, b, c;
        K.init(n);
        for(int i=1;i<n;i++)
        {
            cin >> a >> b >> c;
            K.AddEdge(a, b, c);
        }
        cout << K.kruskal() << endl; //別忘寫輸出.....
    }
}