2021.02.26学习总结（最小生成树之Kruskal算法）

上次学了一个最小生成树的Prim算法，这次看了看Kruskal算法。
假设我们有一个点的集合G。
两点之间都有一条边，所有边为集合E，这个我们可以用二叉堆实现
最小生成树为T。

Kruskal算法：

刚开始T里面没有任何点。
whie:
我们每次从E里面取出最小的边v，假设a,b是v的两个端点。
如果a和b不是同一个集合，我们就可以把a所在的集合 和 b所在的集合 合并（可以利用并查集），相当于把a,b两点加入进T里面。
end
就这样一直循环，直到所有的点都加入进T，或者剩下的点无法加入，就结束循环。
如果所有的点都加入了T，所给的点是一个最小生成树，否则不是。

例题：百岛湖的故事

相信大家都听说一个“百岛湖”的地方吧，百岛湖的居民生活在不同的小岛中，当他们想去其他的小岛时都要通过划小船来实现。现在政府决定大力发展百岛湖，发展首先要解决的问题当然是交通问题，政府决定实现百岛湖的全畅通！经过考察小组RPRush对百岛湖的情况充分了解后，决定在符合条件的小岛间建上桥，所谓符合条件，就是2个小岛之间的距离不能小于10米，也不能大于1000米。当然，为了节省资金，只要求实现任意2个小岛之间有路通即可。其中桥的价格为 100元/米。
Input
输入包括多组数据。输入首先包括一个整数T(T <= 200)，代表有T组数据。
每组数据首先是一个整数C(C <= 100),代表小岛的个数，接下来是C组坐标，代表每个小岛的坐标，这些坐标都是 0 <= x, y <= 1000的整数。
Output
每组输入数据输出一行，代表建桥的最小花费，结果保留一位小数。如果无法实现工程以达到全部畅通，输出”oh!”.
Sample Input
2
2
10 10
20 20
3
1 1
2 2
1000 1000
Sample Output
1414.2
oh!
这个题昨天用Prim算法写过，今天又用Kruskal算法又写了一遍。
AC代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
const int INF = (unsigned)(-1) >> 1;
int c;
int root[maxn];   //节点之间的附属关系
int height[maxn]; //节点树的高度
int getroot(int x)
{
    while (x != root[x])
        x = root[x] = root[root[x]];
    return x;
}
void unionset(int a, int b)
{
    int roota = getroot(a), rootb = getroot(b);
    if (roota == rootb)
        return;
    if (height[roota] < height[rootb]) //把低的树连接到高的树上，能够降低合并后的高度，提高查找速度
        root[roota] = rootb;
    else
    {
        if (height[rootb] == height[roota]) //如果b树和a树高度相等，那么b树连接到a树的时候，a树的高度要+1
            height[roota]++;
        root[rootb] = roota; //把b树连接到a树上面
    }
}
void init()
{
    for (int i = 0; i < maxn; i++)
    {
        root[i] = i;
        height[i] = 1;
    }
}
struct Pos
{
    int x, y, index;
};
class Edge //边
{
public:
    static const int times = 100;
    Pos a, b;
    double cost;
    double setup(Pos a, Pos b) //计算两个小岛之间搭桥的花费
    {
        double x = (a.x - b.x) * times, y = (a.y - b.y) * times;
        double dist = sqrt(x * x + y * y);
        if (dist >= 10 * times && dist <= 1000 * times)
            return dist;
        return INF;
    }
    Edge(Pos a, Pos b)
    {
        this->a = a, this->b = b;
        this->cost = setup(a, b);
    }
    friend bool operator<(const Edge &a, const Edge &b)
    {
        return a.cost > b.cost;
    }
};
Pos island[maxn]; //小岛的位置
bool used[maxn];
double solove(priority_queue<Edge> &es)
{
    init();//初始化并查集
    for (int i = 0; i < c; i++)
        used[i] = false;
    double res = 0;
    while (es.size())
    {
        Edge e = es.top();
        es.pop();
        if (e.cost == INF)
            break;
        if (getroot(e.a.index) != getroot(e.b.index))
        {
            used[e.a.index] = used[e.b.index] = true;
            unionset(e.a.index, e.b.index);
            res += e.cost;
        }
    }
    int sum = 0;
    for (int i = 0; i < c; i++)
        sum += used[i];
    if (sum != c)//如果所有的点都加入到最小生成树
        return -1;
    return res;
}
int main(void)
{
    int t;
    cin >> t;
    while (t--)
    {
        cin >> c;
        for (int i = 0; i < c; i++)
        {
            cin >> island[i].x >> island[i].y;
            island[i].index = i;
        }
        priority_queue<Edge> es;
        for (int i = 0; i < c - 1; i++)
            for (int j = i + 1; j < c; j++)
                es.push(Edge(island[i], island[j]));
        double ans = solove(es);
        if (ans == -1)
            cout << "oh!" << endl;
        else
            printf("%.1lf\n", ans);
    }
    return 0;
}