最小生成树（prim以及kruskal）

最小生成树

• 概念：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。

• 构造方法：普里姆（prim）和克鲁斯卡尔（kruskal）

普里姆(Prim)

时间复杂度(O(n²))

基本思路及过程：

1. 在一个加权连通图中，创建两个集合：顶点集V和边集E，另外还需访问标志数组visit。
2. 在所有点中任意选出一个点作为初始点，并将该点的visit标记为true，接着计算所有与该点相连接的点的距离，找到与之距离最短的点，标记visit为true，同时将该边并入集合E。
3. 在剩下的点中，计算与已将visit标记为true的点距离最小的点，标记visit为true，将边并入E。
4. 重复（3）直到所有点的visit都标记true。

注意：每次选择最小边时，可能存在多条同样权值的边可选，此时任选其一即可。

例子如图：

模板题：https://www.acwing.com/problem/content/860/
代码：

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

using namespace std;

const int N = 505,INF = 0x3f3f3f3f;

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

int prim()
{
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    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 -1; //判断是否可以形成最小生成树
            
            res += dist[t];
            st[t] = true;
            
            for(int k = 1;k <= n;k++)  //当有新的点标记为true后，要更新距离。
            dist[k] = min(dist[k],g[t][k]);
    }
        
    return res;
}

int main()
{
    cin >> n >> m;
    
    memset(g,0x3f,sizeof g);
    
    while(m--)
    {
        int a,b,w;
        cin >> a >> b >> w;
        g[a][b] = g[b][a] = min(g[a][b],w); 
    }
    
    int t = prim();
    
    if(t == -1) cout << "impossible" << endl;
    else cout << t << endl;
    
    return 0;
}

克鲁斯卡尔（kruskal）

时间复杂度(O(mlogm))

基本思路及过程：

1. 将所有边按照权重重小到大排序。
2. 枚举每条边ab，如果a和b不连通，则将这条边加入集合中。

例子如图：

模板题：https://www.acwing.com/problem/content/861/

代码：

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

using namespace std;

const int N = 100010,M = 200010;

struct Edge  //用结构体存储每条边的两端点ab以及权值w
{
    int a,b,w;
    bool operator < (const Edge & W)
    {
        return w < W.w;
    }
}edge[M];

int n,m;
int p[N];

int find(int x)  //利用并查集判断两个元素是否在同个集合中。
{
    if(p[x] != x)
     p[x] = find(p[x]);
     
     return p[x];
}

int kruskal()
{
    sort(edge,edge+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 = edge[i].a,b = edge[i].b,w = edge[i].w;
        
        a = find(a);
        b = find(b);
        
        if(a != b) //如果两个点不在一个集合中，则合并。
        {
            p[a] = b;
            res += w;
            cnt ++;
        }
    }
    
    if(cnt < n - 1) return 0x3f3f3f3f;
    else return res;
}

int main()
{
    cin >> n >> m;
    
    for(int i = 0;i < m;i++)
    {
        int a,b,w;
        cin >> a >> b >> w;
        edge[i] = {a,b,w};
    }
    
    int t = kruskal();
    
    if(t == 0x3f3f3f3f) cout << "impossible" << endl;
    else cout << t << endl;
    
    return 0;
}