Prim和Kruskal算法

对于一个边带有权值的图，我们可以求它的最小生成树(Minimum Spanning Tree)。通常有两种算法，Prim和Kruskal。

Prim算法的思路是每次找到距离当前生成树最近的一个结点，并将它连到当前的生成树。

代码如下：

//Prim 
#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
using std::cin;
using std::cout;
using std::endl;
using std::vector;

const int INF = 0x3f3f3f3f;

struct Edge {
    int vertex, weight;
};

class Graph {
private:
    int n;
    bool *visited;
    vector<Edge> *edges;
public:
    //dist stores the min distance of a node to the tree
    int *dist;
    Graph (int input_n) {
        n = input_n;
        edges = new vector<Edge>[n];
        dist = new int[n];
        visited = new bool[n];
        memset(visited, false, n * sizeof(bool));
        memset(dist, 0x3f, n * sizeof(int));
    }
    ~Graph() {
        delete[] dist;
        delete[] visited;
        delete[] edges;
    }
    void insert(int x, int y, int weight) {
        edges[x].push_back(Edge{y, weight});
        edges[y].push_back(Edge{x, weight});
    }
    int prim(int v) {
        int total_weight=0;
        //v is the starting node
        dist[v]=0;
        //loop for n times, each time settle one node
        for(int i=0;i<n;i++){
            int min_dist=INF,min_vertex;
            for(int j=0;j<n;j++){
                //choose the node with min dist to the tree
                if(!visited[j]&&dist[j]<min_dist){
                    min_dist=dist[j];
                    min_vertex=j;
                }
            }
            total_weight+=min_dist;
            visited[min_vertex]=1;
            //update the nodes connected to the min_vertex
            //dist will store the min dist to the tree
            for(Edge &j: edges[min_vertex]){
                if(!visited[j.vertex]&&j.weight<dist[j.vertex]){
                    dist[j.vertex]=j.weight;
                }
            }
        }
        return total_weight;
    }
};

Kruskal的思路是每次找到剩余的权值最小的边，如果这条边与当前MST不构成环，则将这条边加入MST。利用并查集，我们可以很轻松地判断边是否会与MST构成环，因为如果边的两个顶点在并查集中属于同一棵树，那么这条边一定会形成环。

代码如下：

//kruskal
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
using namespace std;

//father of nodes
int *father;
struct Edge{
   int ver1,ver2,weight;
   bool operator< (const Edge &e) const{
       return weight<=e.weight;
   }
};
vector<Edge> MST;

void initialize(int size){
   father=new int[size];
   for(int i=0;i<size;i++){
       father[i]=i;
   }
}

int find_root(int node){
   if(father[node]!=node){
       father[node]=find_root(father[node]);
   }
   return father[node];
}

bool merge(int node1, int node2){
   int ancestor1=find_root(node1);
   int ancestor2=find_root(node2);
   if(ancestor1!=ancestor2){
       father[ancestor2]=ancestor1;
       return true;
   }
   return false;
}

int kruskal(int num_of_N, int num_of_E){
   int ans=0;
   initialize(num_of_N);
   //边按权值从小到大排序
   set<Edge> edges;
   int v1,v2,weight;
   //输入
   for(int i=0;i<num_of_E;i++){
       cin>>v1>>v2>>weight;
       edges.insert({v1-1,v2-1,weight});
   }
   set<Edge>::iterator iter=edges.begin();
   while(iter!=edges.end()){
        //merge成功说明这两个结点原本不在一棵树上,不构成环
        //因此将这条边加入MST
       if(merge(iter->ver1, iter->ver2)){
           MST.push_back(*iter);
           ans+=iter->weight;
       }
       ++iter;
   }
   return ans;
}

int main(){
   int n,m;
   cin>>n>>m;
   int t=kruskal(n, m);
   cout<<t<<endl;
   vector<Edge>::iterator ite=MST.begin();
   while(ite!=MST.end()){
       cout<<ite->ver1<<"  "<<ite->ver2<<"   "<<ite->weight<<endl;
       ite++;
   }
   delete[] father;
}