最小生成树基础算法(Prim + Krustal)

最小生成树问题的引入：

　　对于一个无向图G(V, E)，需要用图中的n - 1条边连接图中的n个顶点并且不产生回路所产生的树就叫做生成树，其中权值总和最小的就是最小生成树。

如何求解最小生成树问题：

　　譬如给定一个无向图G(V, E)，要如何求出这个图的一个最小生成树呢？

　　下面我们先给出这个问题的一个总的解决方法：

　　　　我们先假设集合A为满足A为图G的最小生成树的边的集合。

　　　　　　条件P：A为G的最小生成树的子集。

　　　　　　起初 ： 我们设定A为空集，显然此时集合A满足条件P。

　　　　　　添加边：每次我们找到一条边(u, v)，使得A U { (u, v) } 这个集合依然满足条件P，我们找到的这条边(u, v)被称为集合A的安全边。

　　以上就是最小生成树的求解过程，我们可以很容易看出这个求解操作中的关键部分就是如何找出符合条件的安全边。那么下面我们先给出求解最小生成树问题的伪代码。

GENERIC-MST(G, w)
    A <- NULL Set
    while(A does not form a spanning tree)
        find an edge(u, v) that is safe for A
        A = A U {(u, v)}
    return A

　　

Kruskal：

　　Kruskal算法思想：任意时刻的中间结果是一个森林。初始n个点的集合，每次选择权重最小且不会产生圈的边加入集合A，合并两个森林。为了方便检测环和加边，需要借助并查集。

　　Kruskal加边操作：贪心思想，每次择最优，保证不成环即可。

　　Kruskal具体操作：

　　　　初始化：每个顶点独立成为一个森林。

　　　　加边：在所有边中选择一条权重最小的边用来连接两个森林，所选择的这条边需要保证合并森林不会生成环。

　　下面给出Kruskal算法的伪代码：

MST-KRUSKAL(G, w)
    A <- NULL Set
    for each vertex v
        Make_Set(v)
    sort the edges of G.E into nondecreasing order by weight w
    for each edge(u, v) taken in nondecreasing order by weight
        if(Find(u) != Find(v))
            A = A U {(u, v)}
            Union(u, v)
    return A

　　Kruskal算法参考代码：

 typedef pair<int, int> pii;
 const int maxn =  + , maxe =  + ;
 int n, e;//全局变量，图中的点和边的数目
 struct Edge {
     int x, y, cost;
 } edge[maxe];//全局变量，edge[i]表示第i条边的信息
 int ans = ;//表示为最小生成树的边权和
 int num = ;//表示所求出的边的数量
 pii spanning[maxn];//存储最小生成树的每条边
 int head[maxn], Rank[maxn];

 void Make_Set(int n) {
     for(int i = ; i <= n; i ++) {
         Rank[i] = ;
         head[i] = i;
     }
 }

 int Find(int u) {
     if(u == head[u]) return u;
     else return head[u] = Find(head[u]);
 }

 void Union(int u, int v) {
     int hu = Find(u), hv = Find(v);
     if(Rank[hu] > Rank[hv])
         head[hv] = hu;
     else {
         head[hu] = hv;
         if(Rank[hu] == Rank[hv]) Rank[hv] += ;
     }
 }

 bool Is_same(int u, int v) {
     return Find(u) == Find(v);
 }

 bool cmp(Edge a, Edge b) {
     return a.cost < b.cost;
 }

 int Kruskal() {
     sort(edge + , edge + e + , cmp);
     int cnt = n;
     Make_Set(n);
     for(int i = ; i <= e; i ++) {
         if(!Is_same(edge[i].x, edge[i].y)) {
             Union(edge[i].x, edge[i].y);
             ans += edge[i].cost;
             spanning[++num].first = edge[i].x;
             spanning[num].second = edge[i].y;
             if(cnt == ) break;//若只剩下一个连通块即最小生成树已经生成，则退出
         }
     }
     return ans;
 }

Prim:

　　Prim算法思想：任意时刻的中间结果都是一颗最小生成树的子树。从指定的一个点开始，每次都花最少的代价，用一条边把一个不在树中的结点加进来。为了方便选择离树最近的点，需要借助堆。

　　Prim加边操作：贪心策略，每次选择一条边(u, v)保证u已经是最小生成树子树内的结点，v是最小生成树子树内的所有结点u出发的边的tail结点，每次选择保证边(u, v)的权重最小。

　　Prim算法具体操作：

　　　　初始化：将初始点标记。

　　　　加边：每次找一条最短的两端分别为标记和未标记的边加入最小生成树子树并把未标记的点标记上。即每次加入一条安全边，每次扩展一个点由未标记为变已标记，

直至扩展至n个点。

　　下面给出Prim算法的伪代码：

MST-PRIM(G, w, source)
    for each vertex u
        u:key <- Infinite //表示距离结点u最近的结点到u的距离
        u.head <- NULL//表示距离结点u最近的结点的编号
    source:key <-
    Q <- G.Vertex // the source vertex
    while(Q != NULLSet)
        u <- EXTRACT-MIN(Q)//Find and Delete
        for each v belong to G.Adj[u]
        　　if(v belong to Q and w(u, v) < v.key)
            　　v.head <- u;
            　　v.key <- w(u, v);
　　　　　　　　　Q <- v

　　Prim算法实现代码：

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <map>
 #include <vector>
 using namespace std;

 typedef pair<int, int> pii;
 const int maxn =  + , maxe =  + , INF = 0x3f3f3f3f;
 struct Edge {
     int to, cost;
     friend bool operator < (const Edge &a, const Edge&b) {
         return a.cost > b.cost;
     }
 };
 vector<Edge> edge[maxe];
 int n, e, ans, dist[maxn];
 bool vis[maxn];

 void addedge(int u, int v, int w) {
     edge[u].push_back({v, w});
 }

 void MST_Prim(int source) {
     memset(vis, false, sizeof vis);
     for(int i = ; i <= n; i ++) dist[i] = INF;
     dist[source] = ans = ;
     priority_queue <Edge> Q;
     Q.push({source, dist[source]});
     while(!Q.empty()) {
         Edge u = Q.top();
         Q.pop();
         if(vis[u.to]) continue;
         vis[u.to] = true;
         ans += dist[u.to];
         for(int i = ; i < edge[u.to].size(); i ++) {
             Edge e = edge[u.to][i];
             if(dist[e.to] > e.cost) {
                 dist[e.to] = e.cost;
                 Q.push({e.to, dist[e.to]});
             }
         }
     }
 }

 int main() {
     int x, y, w;
     scanf("%d", &n);
     for(int i = ; i <= n; i ++) {
         scanf("%d %d %d", &x, &y, &w);
         addedge(x, y, w);
         addedge(y, x, w);
     }
     MST_Prim();
     for(int i = ; i <= n; i++) edge[i].clear();//被这个坑了一天，一定要记住全局变量要清空
     return ;
 }