网络楼楼通·最小生成树kruskal 克鲁斯卡尔算法

题目信息

现有学校宿舍区之间要铺设光纤建设网络，在施工预算的统计数据表中，列出了有可能建设光缆的若干条管线的成本，求使每栋楼都能够接入校园网且使管网建设费用成本最低。

输入

第一行数据包括楼宇的数目正整数N(≤1000)和候选管网数目M(≤3N)；
随后的M行对应M条线路，每行给出3个正整数，分别是该条线路直接连通的两个楼宇的编号以及预算成本（为简单起见，城镇从1到N编号）。

输出

输出建设楼楼通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多的通路。

测试样例

测试样例1

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

12

测试样例2

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 10
3 6 1
4 5 10
4 6 8
5 6 3

14

测试样例3

7 9
1 2 10
1 3 30
2 3 50
1 4 30
1 5 100
3 5 10
3 4 20
4 5 60
6 7 10

-1

解答

#include<iostream>
#include<algorithm>

using namespace std;

struct node
{
    
    
    int x;
    int y;
    int cost;
};

node road[5005];

struct Rule
{
    
    
    bool operator()(const node &A, const node &B) const
    {
    
    
        return A.cost < B.cost;
    }
};

int tree[1010];
int n, m;

void init()
{
    
    //每个人的开头都是自己
    for (int i = 0; i <= n; i++)
        tree[i] = i;
}

int find(int t)
{
    
    //来查找每个点的开头节点
    if (tree[t] == t)
    {
    
    //自己就是自己的开头说明还没有用过
        return t;
    }
    else
    {
    
    //如果不想等的话就不断递归下去去找开头的节点
        return tree[t] = find(tree[t]);
    }
}

int judge(int x, int y)
{
    
    //判断是否成环，不成环则返回1
    int a = find(x);
    int b = find(y);
    if (a != b)
    {
    
    //ab点的开头节点不在一起
        tree[a] = b;//那么将a的开头设置为b
        return 1;
    }
    else
    {
    
    
        return 0;
    }
}

void kruskal()
{
    
    
    int side = 0;//选出的边数
    int sum = 0;//总的开销
    init();//初始化
    sort(road, road + m, Rule());//排序
    for (int i = 0; i < m; i++)
    {
    
    
        if (judge(road[i].x, road[i].y))
        {
    
    
            side++;
            sum += road[i].cost;
        }
        if (side == n - 1)
        {
    
    //已经选够了
            break;
        }
    }
    if (side != n - 1)
    {
    
    //选不出n-1条边，则无法构成最小生成树
        cout << "-1" << endl;
    }
    else
    {
    
    
        cout << sum << endl;
    }
}

int main()
{
    
    
    //freopen("/Users/zhj/Downloads/test.txt", "r", stdin);
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
    
    
        cin >> road[i].x >> road[i].y >> road[i].cost;
    }

    kruskal();
    return 0;
}

想法

本题的核心考察点是最小生成树
整体思路：采用全局贪心的 kruskal 克鲁斯卡尔算法。先对所有的成本从小到大进行排序，每次从中选一条未被选取且成本最小的边，若此条边与之前选择的边不构成环，则将此边加入图中并计算开销，否则舍弃这条边而选择下一条成本最小的边。判断这条边与之前加入的边是否成环，借助并查集来进行判断。

最小生成树

在含有n个顶点的连通图中选择n-1条边，构成一棵极小连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树。

例如，对于如上图G4所示的连通网可以有多棵权值总和不相同的生成树。

kruskal克鲁斯卡尔算法

是用来求加权连通图的最小生成树的算法

基本思想

按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路。

具体做法

首先构造一个只含n个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止。
以上图为例，对克鲁斯卡尔演示

• 第1步：将边(E,F)加入R中。
  边(E,F)的权值最小，因此将它加入到最小生成树结果R中。
• 第2步：将边(C,D)加入R中。
  上一步操作之后，边(C,D)的权值最小，因此将它加入到最小生成树结果R中。
• 第3步：将边(D,E)加入R中。
  上一步操作之后，边(D,E)的权值最小，因此将它加入到最小生成树结果R中。
• 第4步：将边(B,F)加入R中。
  上一步操作之后，边(C,E)的权值最小，但(C,E)会和已有的边构成回路；因此，跳过边(C,E)。同理，跳过边(C,F)。将边(B,F)加入到最小生成树结果R中。
• 第5步：将边(E,G)加入R中。
  上一步操作之后，边(E,G)的权值最小，因此将它加入到最小生成树结果R中。
• 第6步：将边(A,B)加入R中。
  上一步操作之后，边(F,G)的权值最小，但(F,G)会和已有的边构成回路；因此，跳过边(F,G)。同理，跳过边(B,C)。将边(A,B)加入到最小生成树结果R中。
• 此时，最小生成树构造完成！它包括的边依次是：(E,F) (C,D) (D,E) (B,F) (E,G) (A,B)。

判断连通

根据前面介绍的克鲁斯卡尔算法的基本思想和做法，我们能够了解到，克鲁斯卡尔算法重点需要解决的以下问题：
将边添加到最小生成树中时，怎么样判断是否形成了回路。
处理方式是：记录顶点在"最小生成树"中的终点，顶点的终点是"在最小生成树中与它连通的最大顶点"(关于这一点，后面会通过图片给出说明)。然后每次需要将一条边添加到最小生存树时，判断该边的两个顶点的终点是否重合，重合的话则会构成回路。 以下图来进行说明：

在将(E,F) (C,D) (D,E)加入到最小生成树R中之后，这几条边的顶点就都有了终点：

• C的终点是F
• D的终点是F
• E的终点是F
• F的终点是F

关于终点，就是将所有顶点按照从小到大的顺序排列好之后；某个顶点的终点就是"与它连通的最大顶点"。 因此，接下来，虽然(C,E)是权值最小的边。但是C和E的重点都是F，即它们的终点相同，因此，将(C,E)加入最小生成树的话，会形成回路。这就是判断回路的方式。