最小生成树 prim & kruskal

给定一个无向图，如果他的某个子图中，任意两个顶点都能互相连通并且是一棵树，那么这棵树就叫做生成树（spanning tree）.

如果边上有权值，那么使得边权和最小的生成树叫做最小生成树（MST，Minimum Spanning Tree）


1. prim算法：
　　使用临界矩阵存储边，适用于两点之间只有一条边，或只需要保存最短或最长的一条边的情况。
　　通过“加点”搜索最短路径；

附代码，这里假设为无向图：

#include<iostream>
#include<cstring>
using namespace std;

#define INF 1e9
const int N = 100+5;    //number of dots
int n,m;
int dis[N], vis[N], edge[N][N];

void init()
{
    memset(vis, 0, sizeof(0));
    vis[0]=1, dis[0]=0;     //start from 0
    
    for(int i=0; i<n; i++)
        for(int j=0; j<N; j++)
            edge[i][j]=INF;
}

int prim()
{
    int mini, minx, count=0, cost=0;
    while(count<n) {
        mini = -1;
        minx = INF;
        for(int i=1; i<n; i++) {
            if(!vis[i] && dis[i]<minx) {
                mini = i;
                minx = dis[i];
            }
        }
        if(mini == -1) return -1;
        
        vis[mini] = 1;
        cost += minx;
        count++;
        
        for(int i=1; i<n; i++) {
            if(!vis[i] && edge[mini][i]<dis[i])
                dis[i] = edge[mini][i];
        }
    }
    return cost;
}

int main()
{
    cin>>n>>m;
    init();
    for(int a,b,v,i=0; i<m; i++) {
        cin>>a>>b>>v;
        edge[a][b] = edge[b][a] = v;    //undirected graph
    }
    
    prim();
    
    return 0;
} 

2. kruskal算法

　　通过“加边”搜索最短路径；

　　按照边的权值从小到大排序，再全部访问一遍，如果将该边加入当前生成树内不会产生环，那么就把这条边加入到生成树中，逐步扩大生成树的大小。

　　接下来我们介绍如何判断是否产生重边。假设现在要把连接顶点u和顶点v的边e（u—>v，v—>u）加入到生成树中去，如果加入操作之前，u和v不在同一个连通分量内（两块不连接的图），那么加入e也不会产生圈。反之，如果u和v在同一个连通分量里，那么一定会产生圈。可以使用并查集判断是否属于同一个连通分量。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

#define INF 1e9
const int N = 100+5;    //number of dots
const int M = 1000+5;
int n,m;
struct Edge {
    int from, to, value;
    bool operator<(const Edge &a) {
        return value<a.value;
    }
}edge[M];
int vis[N], f[N];

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

void init()
{
    for(int i=0; i<n; i++)
        vis[i]=0, f[i] = i;
    sort(edge, edge+m);
}

int kruskal()
{
    int cost=0;
    for(int i=0; i<m; i++) {
        int x = find(edge[i].from);
        int y = find(edge[i].to);
        if(x != y) {
            f[x] = y;
            cost += edge[i].value;
            vis[edge[i].from] = vis[edge[i].to] = 1;
        }
    }
}

int main()
{
    cin>>n>>m;
    for(int i=0; i<m; i++)
        cin>>edge[i].from>>edge[i].to>>edge[i].value;
    
    init();
    kruskal();
    
    return 0;
}