最小生成树

1、最小生成树

对应的图都是无向图，有向图一般不会考

一般稠密图直接朴素版Prim算法，因为短。

稀疏图就直接Kruskal算法。

堆优化版本的Prim算法一般不常用。

最下生成树有什么用：如我们有n个城市，在不同城市之间修路，让这些城市可以相互连通，则修路的最小总长度是多少。

1.1 朴素Prim算法

和Dijkstra算法很像，堆优化也是同样的原理。

1. dist[i] = \(+\infty\)；把所有距离初始化成无穷

2. s表示当前已经在连通块中的所有点

3. for(i = o; i < n; i++)

   {

   ​ \(t \gets\)找到集合外距离最近的点;

   ​ 用t更新其他点到集合的距离；

   ​ st[t] = true; 把t加到集合中去。

   }

1.2 练手：Prim算法求最小生成树

1.3 解答：Prim算法

题目给的图如下所示：

初始时让所有点到集合的距离都是\(+\infty\)，然后进行多次迭代。

比如我们初始选中①，然后用①更新其他点到集合的距离。就是看其他点有没有一条边能连接到集合内部，能连接到集合内部的长度最小的边就是该点到集合的距离。比如结合A有3条边a,b,c连接到点k，那么这三条边中距离最短的就是点k到集合的距离。更新之后如下图所示：

然后进行第二次迭代：从剩下的点中选出一个距离最近的点即②，然后用它来更新其他每个点到集合的距离。没有任何变化。

再进行第三次迭代，选中了③，也没有变化。

最后再把④加进来。

生成树就是我们每次选中的点t，他的距离对应的边就是生成树里面的一条边。

初始我们选中了点①，点①没有边，之后选中了点②，它和点①之间有一条边。

之后我们选中了点③，它有两条距离为2的边，任选一条即可。假设我们选了\(1\to3\)这条边。

最后我们选了点④，它的最短距离是3这条边，所以我们选了\(1\to4\)这条边。

最后的生成树如下图所示：

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

using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];
int dist[N];
bool st[N];


int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        
        // 如果不是第一个点且距离为正无穷说明最近点都是正无穷，图不连通
        // 不存在最小生成树
        if (i && dist[t] == INF) return INF;

        // 需要先累加在将点更新到集合内
        // 先更新如果有自环如-10，会将环加进去使自身变小
        // 但最小生成树没有环，所以先累加
        if (i) res += dist[t];
        st[t] = true;

        // 更新其他点到集合距离
        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}


int main()
{
    scanf("%d%d", &n, &m);

    memset(g, 0x3f, sizeof g);

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = g[b][a] = min(g[a][b], c); // 无向图，所以是a，b和b，a
    }

    int t = prim();

    if (t == INF) puts("impossible");
    else printf("%d\n", t);

    return 0;
}

1.4 Kruskal算法

1. 将所有边按照权重从小到大排序O(m\(log^m\))。

2. 枚举每一条边a，b，权重为w，

   if a，b不连通

   ​ 将这条边加入集合中(参考并查集)

1.5 练手

1.6 解答

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

using namespace std;

const int N = 100010, M = 200010, INF = 0x3f3f3f3f;

int n, m;
int p[N];

struct Edge
{
    int a, b, w;
    
    // 重载，方便排序
    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges, edges + m);

    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集

    int res = 0, cnt = 0;
    
    // 从小到大枚举所有边
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        // 让a，b=a，b的祖宗节点
        cout << "precious a = " << a << " " << b << " ";
        a = find(a), b = find(b);
        cout << "after a = " << a << " " << b << endl;
        // 判断a,b是否连通即他们的祖宗节点是否一样
        // 不连通的话就把这条边加进来
        if (a != b)
        {
            p[a] = b; // 把两个点所在集合合并
            res += w; // 存储最小生成树中所有边的权重之和
            cnt ++ ; // 存储当前加了多少条边
        }
    }

    // 如果加的边数<n-1,说明不连通
    if (cnt < n - 1) return INF;
    return res;
}

int main()
{
    scanf("%d%d", &n, &m);

    for (int i = 0; i < m; i ++ )
    {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edges[i] = {a, b, w};
    }

    int t = kruskal();

    if (t == INF) puts("impossible");
    else printf("%d\n", t);

    return 0;
}