CCF-GESP8级考试—图论算法及综合应用（最小生成树）

🍉1 最小生成树的概念 

1.1 连通图 🎈

        连通图用于描述图中顶点之间是否存在路径相连。一个无向图中，如果从图中的任意一个顶点出发，都可以通过边的连接到达图中的任意其他顶点，则该图被称为连通图。

连通图的性质：

• 连通图中的任意两个顶点之间都存在一条路径。
• 连通图中的最小生成树是唯一的。
• 连通图中的边数至少为顶点数减一，否则无法保证所有顶点之间都连通。

1.2 生成树🎈

1.3 最⼩⽣成树（最⼩代价树）🎈

        对于一个带权连通无向图G=(V,E)，生成树不同，每棵树的权(即树中所有边上的权值之和)也可能不同。

• 最小生成树可能有多个，但边的权值之和总是唯一且最小的。
• 最小生成树的边数 =顶点数 -1。砍掉一条则不连通，增加一条边则会出现回路。
• 如果一个连通图本身就是一棵树，则其最小生成树就是它本身。（①所有顶点之间都是连通的，且没有孤立的顶点。②没有形成环路的边，即不存在回路。③满足上一条）

• 只有连通图才有生成树，非连通图只有生成森林。

1.4 求最小生成树的两种方法🎈

在讨论prime算法和kruskal算法在不同边密度情况下的适用性之前，让我们先了解一下稠密图和稀疏图的概念：

• 稠密图：稠密图是指图中边的数量接近于顶点数量的平方级别的图。在稠密图中，边的数量相对较多，顶点之间的连接比较密集。
• 稀疏图：稀疏图是指图中边的数量远小于顶点数量的平方级别的图。在稀疏图中，边的数量相对较少，顶点之间的连接比较稀疏。

两种具体的算法——prime算法和kruskal算的适用范围↓

• Prim算法

• Kruskal算法 

1.5 为什么最小生成树必须要求无向图?🎈

        最小生成树（Minimum Spanning Tree）是一个①连通②无向图中的一棵包含图中所有顶点的③树，并且具有④最小总权值。

      最小生成树要求树是无向的，因为在无向图中，边是双向的，可以在两个顶点之间双向移动，这样可以确保生成树的连通性和权重最小化。在有向图中，边是单向的，可能会导致生成树不连通或权重计算错误。

🍉 2 Prim算法

prim 算法干的事情是：给定一个无向图，在图中选择若干条边把图的所有节点连起来。要求边长之和最小。

prim 算法采用的是一种贪心的策略。

每次将离连通部分的最近的点和点对应的边加入的连通部分，连通部分逐渐扩大，最后将整个图连通起来，并且边长之和最小。

我们将图中各个节点用数字 1 ~ n 编号。

要将所有景点连通起来，并且边长之和最小，步骤如下：

1.         用一个 state 数组表示节点是否已经连通。state[i] 为真，表示已经连通，state[i] 为假，表示还没有连通。初始时，state 各个元素为假。即所有点还没有连通。
2.         用一个 dist 数组保存各个点到连通部分的最短距离，dist[i] 表示 i 节点到连通部分的最短距离。初始时，dist 数组的各个元素为无穷大。
3.         用一个 pre 数组保存节点的是和谁连通的。pre[i] = k 表示节点 i 和节点 k 之间需要有一条边。初始时，pre 的各个元素置为 -1。

 从 1 号节点开始扩充连通的部分，所以 1 号节点与连通部分的最短距离为 0，即disti[1] 置为 0。

1.         遍历 dist 数组，找到一个还没有连通起来，但是距离连通部分最近的点，假设该节点的编号是 i。i节点就是下一个应该加入连通部分的节点，stata[i] 置为 1。
2.         用青色点表示还没有连通起来的点，红色点表示连通起来的点。
3.         这里青色点中距离最小的是 dist[1]，因此 state[1] 置为 1。

1.         遍历所有与 i 相连但没有加入到连通部分的点 j，如果 j 距离连通部分的距离大于 i j 之间的距离，即 dist[j] > w[i][j]（w[i][j] 为 i j 节点之间的距离），则更新 dist[j] 为 w[i][j]。这时候表示，j 到连通部分的最短方式是和 i 相连，因此，更新pre[j] = i。
2.         与节点 1 相连的有 2， 3， 4 号节点。1->2 的距离为 100，小于 dist[2]，dist[2] 更新为 100，pre[2] 更新为1。1->4 的距离为 140，小于 dist[4]，dist[4] 更新为 140，pre[2] 更新为1。1->3 的距离为 150，小于 dist[3]，dist[3] 更新为 150，pre[3] 更新为1。

重复 上面2步骤，直到所有节点的状态都被置为 1.
这里青色点中距离最小的是 dist[2]，因此 state[2] 置为 1 

 与节点 2 相连的有 5， 4号节点。2->5 的距离为 80，小于 dist[5]，dist[5] 更新为 80，pre[5] 更新为 2。2->4 的距离为 80，小于 dist[4]，dist[4] 更新为 80，pre[4] 更新为2。

选dist[4]，更新dist[3]，dist[5]，pre[3]，pre[5]。 

 

选dist[5]，没有可更新的。 

选dist[3]，没有可更新的。
 

此时 dist 数组中保存了各个节点需要修的路长，加起来就是。pre 数组中保存了需要选择的边。 

2.1 伪代码🎈

int dist[n],state[n],pre[n];
dist[1] = 0;
for(i : 1 ~ n)
{
    t <- 没有连通起来，但是距离连通部分最近的点;
    state[t] = 1;
    更新 dist 和 pre;
}

2.2 代码🎈

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510;
int g[N][N];//存储图
int dt[N];//存储各个节点到生成树的距离
int st[N];//节点是否被加入到生成树中
int pre[N];//节点的前去节点
int n, m;//n 个节点，m 条边

void prim()
{
    memset(dt,0x3f, sizeof(dt));//初始化距离数组为一个很大的数（10亿左右）
    int res= 0;
    dt[1] = 0;//从 1 号节点开始生成 
    for(int i = 0; i < n; i++)//每次循环选出一个点加入到生成树
    {
        int t = -1;
        for(int j = 1; j <= n; j++)//每个节点一次判断
        {
            if(!st[j] && (t == -1 || dt[j] < dt[t]))//如果没有在树中，且到树的距离最短，则选择该点
                t = j;
        }

        //2022.6.1 发现测试用例加强后，需要判断孤立点了
        //如果孤立点，直返输出不能，然后退出
        if(dt[t] == 0x3f3f3f3f) {
            cout << "impossible";
            return;
        }


        st[t] = 1;// 选择该点
        res += dt[t];
        for(int i = 1; i <= n; i++)//更新生成树外的点到生成树的距离
        {
            if(dt[i] > g[t][i] && !st[i])//从 t 到节点 i 的距离小于原来距离，则更新。
            {
                dt[i] = g[t][i];//更新距离
                pre[i] = t;//从 t 到 i 的距离更短，i 的前驱变为 t.
            }
        }
    }

    cout << res;

}

void getPath()//输出各个边
{
    for(int i = n; i > 1; i--)//n 个节点，所以有 n-1 条边。

    {
        cout << i <<" " << pre[i] << " "<< endl;// i 是节点编号，pre[i] 是 i 节点的前驱节点。他们构成一条边。
    }
}

int main()
{
    memset(g, 0x3f, sizeof(g));//各个点之间的距离初始化成很大的数
    cin >> n >> m;//输入节点数和边数
    while(m --)
    {
        int a, b, w;
        cin >> a >> b >> w;//输出边的两个顶点和权重
        g[a][b] = g[b][a] = min(g[a][b],w);//存储权重
    }

    prim();//求最下生成树
    //getPath();//输出路径
    return 0;
}

上面代码的时间复杂度为 O(n^2)。

与Dijkstra类似，Prim算法也可以用堆优化，优先队列代替堆，优化的Prim算法时间复杂度O(mlogn)。适用于稀疏图，但是稀疏图的时候求最小生成树，Kruskal 算法更加实用。

🍉 3 Kruskal算法

算法思路：

1. 将所有边按照权值的大小进行升序排序，然后从小到大一一判断。
2. 如果这个边与之前选择的所有边不会组成回路，就选择这条边分；反之，舍去。
3. 直到具有 n 个顶点的连通网筛选出来 n-1 条边为止。
4. 筛选出来的边和所有的顶点构成此连通网的最小生成树。

判断是否会产生回路的方法为：使用并查集。

1. 在初始状态下给各个个顶点在不同的集合中。、
2. 遍历过程的每条边，判断这两个顶点的是否在一个集合中。
3. 如果边上的这两个顶点在一个集合中，说明两个顶点已经连通，这条边不要。如果不在一个集合中，则要这条边。

举个例子，下图一个连通网，克鲁斯卡尔算法查找图 1 对应的最小生成树，需要经历以下几个步骤：

将连通网中的所有边按照权值大小做升序排序：

从 B-D 边开始挑选，由于尚未选择任何边组成最小生成树，且 B-D 自身不会构成环路，所以 B-D 边可以组成最小生成树。 

D-T 边不会和已选 B-D 边构成环路，可以组成最小生成树： 

A-C 边不会和已选 B-D、D-T 边构成环路，可以组成最小生成树： 

C-D 边不会和已选 A-C、B-D、D-T 边构成环路，可以组成最小生成树： 

C-B 边会和已选 C-D、B-D 边构成环路，因此不能组成最小生成树： 

B-T 、A-B、S-A 三条边都会和已选 A-C、C-D、B-D、D-T 构成环路，都不能组成最小生成树。而 S-A 不会和已选边构成环路，可以组成最小生成树。 

如图下图 所示，对于一个包含 6 个顶点的连通网，我们已经选择了 5 条边，这些边组成的生成树就是最小生成树。 

3.1 代码🎈

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 100010;
int p[N];//保存并查集

struct E{
    int a;
    int b;
    int w;
    bool operator < (const E& rhs){//通过边长进行排序
        return this->w < rhs.w;
    }

}edg[N * 2];
int res = 0;

int n, m;
int cnt = 0;
int find(int a){//并查集找祖宗
    if(p[a] != a) p[a] = find(p[a]);
    return p[a];
}
void klskr(){
    for(int i = 1; i <= m; i++)//依次尝试加入每条边
    {
        int pa = find(edg[i].a);// a 点所在的集合
        int pb = find(edg[i].b);// b 点所在的集合
        if(pa != pb){//如果 a b 不在一个集合中
            res += edg[i].w;//a b 之间这条边要
            p[pa] = pb;// 合并a b
            cnt ++; // 保留的边数量+1
        }
    }
}
int main()
{

    cin >> n >> m;
    for(int i = 1; i <= n; i++) p[i] = i;//初始化并查集
    for(int i = 1; i <= m; i++){//读入每条边
        int a, b , c;
        cin >> a >> b >>c;
        edg[i] = {a, b, c};
    }
    sort(edg + 1, edg + m + 1);//按边长排序
    klskr();
    //如果保留的边小于点数-1，则不能连通
    if(cnt < n - 1) {
        cout<< "impossible";
        return 0;
    }
    cout << res;
    return 0;
}