Prim算法、Kruskal算法

主要内容：

Prim算法

最小生成树对应的问题一般都是无向图，最小生成树所构成的图总边权之和最小，但不能是环，否则不能称之为"最小"。

Prim算法是求解最小生成树的算法之一，适用于稠密图，Prim算法和Dijkstra算法步骤很相似，不同的是Dijkstra需要更新所有邻居到起点的距离，也就是"松弛操作"，但Prim不需要，只需要把距离集合最近的点加入集合中去。

prim算法步骤：

设最小生成树中点的集合为U.
① 任取一点，加入集合，例如点1

② 找距离集合U中的点最近的邻居，也就是1的邻居，很明显是2，把2加入集合

③ 继续找距离U最近的点，是5

④ 由于1 ~ 5这条边是集合内部两个点连接而成，没有扩展新的点（形成了环），操作不会执行。

⑤那最近的就是4号点了，距离集合最近的点是4，加入。

⑥ 加入3，得到最终的集合，组成的就是最小生成树。

代码思路:

1. 初始化距离为无穷大
2. 找到集合外距离最近的点赋给 t
3. 用 t 更新其它点到集合的距离
4. st[t] = true（把t加到集合中去）

代码模板：

//稠密图用邻接矩阵存储
int prim()
{
    memset(dist, 0x3f, sizeof dist);
    
    int res = 0;  //权重之和
    
    for(int i = 0; i < n; i ++ )//n次迭代
    {
        int t = -1;
        
        for(int j = 1; j <= n;j ++ )
        {
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;//t存储当前距离最小的点
                
        }
        
        if(i && dist[t] == INF) return INF;//图不连通
        else if(i) res += dist[t];  //先累加再更新
        
        st[t] = true;
        
        for(int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
       //与Dijkstra的不同之处
    }
    return res;
}

例题：

#include<iostream>
#include<cstring>
#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;
        else 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()
{
    cin >> n >> m;
    
    memset(g, 0x3f, sizeof g);
    
    while(m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    
    int t = prim();
    
    if(t == INF) cout << "impossible" << endl;
    else cout << t << endl;
    
    return 0;
}

对于稀疏图，可以使用堆优化版的prim算法，但这种算法不常用，用kruskal算法效率就很高。

---

Kruskal算法

kruskal算法的两个关键：

1. 对边进行排序。使用sort()排序,依次把最短边加入最小生成树中，这就是为什么适用于稀疏图的原因。
2. 判断环，也就是处理连通性问题，使用并查集简单高效，是kruskal的、算法的绝配。

关于并查集查看：并查集

kruskal过程分析：
①初始最小生成树为空

②加入第一个最短边，把2并入集合1中，构成以点1为根结点的树

③继续找最短边，这时候把4并入集合3中

④继续查找，5并入集合1，继续查找，发现5已经在集合1中，也就是形成一个环，放弃合并。

⑤ 将4并入集合1，但4已经并入集合3，所以将集3并入集1，形成最小生成树。

代码：

int kru()
{
    sort(e, e + m);//将边升序排序
    
    for(int i = 1; i <= n; i ++) p[i] = i;//初始化并查集
    
    int res = 0, cnt = 0;//res边权和，cnt为加入最小生成树的边数
    
    for(int i = 0; i < m ; i++ )//遍历边
    {
        int a = e[i].a, b = e[i].b, w = e[i].w;
        
        a = find(a), b = find(b);
        
        if(a != b)//a,b不在同一集合内
        {
            p[a] = b;//合并
            res += w;//累加
            cnt ++ ;
        }
    }
    
    if(cnt < n - 1) return INF;//加入边数小于n - 1说明不连通
    
    return res;
}

例题：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N  = 100010, M = 200010, INF = 0x3f3f3f3f;
int p[N];
int n, m;
struct Edge{
    int a, b, w;
    //结构体内嵌比较函数
    bool operator < (const Edge &W) const 
    {
        return w < W.w;
    }
}e[M];

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

int kru()
{
    sort(e, e + 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 = e[i].a, b = e[i].b, w = e[i].w;
        
        a = find(a), b = find(b);
        
        if(a != b)
        {
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }
    
    if(cnt < n - 1) return INF;


    return res;
    
}
int main()
{
    cin >> n >> m;

    for(int i = 0; i < m; i ++ )    
    {
        int a, b, c;
        cin >> a >> b >> c;
        
        e[i] = {a, b ,c};
    }
    int t = kru();
    
    if(t == INF) puts("impossible");
    else cout << t << endl;
    
    return 0;
}

复杂度分析：
遍历边时是O(m)
对边排序时复杂度O(mlogm)，整个算法中用时最长的一步。复杂度不超过O(mlogm).