最小生成树算法

顾名思义，这是用来解决联通图中，遍历所有的点，花费权值之和最小的算法

解决问题有两种方法，第一个是遍历所有的边，第二个是遍历所有的点

1. Kruscal算法

总的思想其实很容易理解，对于连通图来说，最小的边一定属于最小生成树，这里就不给证明了，是用反证法求证。
所以得到了所有的边之后，对结构体数组进行排序，将边由小到大进行排序，然后不断的遍历，只要一条边上两端的端点不属于同一棵树，就把这条边加进来，判断同一棵树的方法则是采用并查集

模板代码如下——

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int  MAXN =1e6+10;
#define inf 0x3f3f3f3f

int m,n;
int parent[MAXN];//记录前一个节点，或者说记录根节点
struct Bian
{
    int from;
    int to;
    int value;
}bian[MAXN];//边节点结构体

bool cmp(Bian x,Bian y)//用于从小到大排序
{
    return x.value<y.value;
}

int Find(int f)  //并查集，用于判断是否两个端点在同一集合
{
   return parent[f]== f ? f : parent[f]=Find(parent[f]);
}

void kruscal()
{
    int ans=0;
    int h,t;
    for(int i=1;i<=m;i++) parent[i]=i;   //并查集数组初始化
    for(int i=1;i<=n;i++)
    {
        h=Find(bian[i].from);    //查找两个端点的根节点
        t=Find(bian[i].to);
        if(h!=t) //不形成环路则加上最小生成树中
        {
            parent[h]=t;
            ans+=bian[i].value;
            printf("v%d -> v%d :%d\n",bian[i].from,bian[i].to,bian[i].value);
        }
    }
   printf("%d\n",ans);
}

int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d",&bian[i].from,&bian[i].to,&bian[i].value);
        }
        sort(bian+1,bian+n+1,cmp);//排序
        kruscal();
    }
    return 0;
}

2. Prim算法
   既然kruscal是用了边的思想，那么显然prim算法采用点的思想——
   把已经确定是最小生成树的点用数组进行标记，对没有标记的那些点，通过看他们的邻接矩阵，来找到权值最小的点，再把它加入到已经标记的点里面去

   具体算法代码如下——

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define MAXN 1005
#define inf 0x3f3f3f3f

int a[3010][3010],n,m,ans;  //用邻接矩阵存储图
bool v[3010];               //标记节点已经加入最小生成树
int d[3010];                //各节点到最小生成树的权值


void prim()
{
    memset(d,inf,sizeof(d)); //各节点到最小生成树的权值初始化为无穷
    memset(v,0,sizeof(v));   //初始化所有节点未加入最小生成树
    d[1]=0;                  //确定1号属于最小生成树

    for(int i=1;i<n;i++)     //遍历所有的节点
    {
        int x=0;             //存储距离最小生成树权值最小的节点

        for(int j=1;j<=n;j++)
            if(!v[j] && (x==0 || d[j]<d[x])) x=j;  //搜索不在最小生成树集合中且距离最小生成树权值最小的节点，存在X中

        v[x]=1;              //将不在最小生成树集合中且距离最小生成树权值最小的节点加入

        for(int j=1;j<=n;j++)
            if(!v[j]) d[j]=min(d[j],a[x][j]);     //更新不在最小生成树集合中的节点距离最小生成树的权值
    }
}

int main()
{
    cin >> n >>m;
    memset(a,inf,sizeof(a));
    for(int i=1;i<=n;i++) a[i][i]=0;  //初始化自己与自己距离0
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        a[x][y]=a[y][x]=min(a[x][y],z);    //去除重边，选取重边中更小的那条
    }
    prim();
    for(int i=2;i<=n;i++)
        ans+=d[i];
    cout << ans;
}