最小生成树模板(prim+kruskal+prim的优化)

最小生成树：解决极小连通子图连接所有点使得花费最小问题

1.prim算法 

思想：随机选择一个点，作为初始集合，并保存所有点到这个集合的最短距离，然后找与这个集合距离最短的点，也将其加入这个集合，由于新加入了一个点，所以要更新所有未加入集合点到这个集合的最短距离，不断重复，直到连通整个图。

1）邻接矩阵建图朴素法（无向图）复杂度o(v^2) 

#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 111
#define inf 1<<31-1
using namespace std;
int n,m,ans;
int vis[maxn],mapp[maxn][maxn],dis[maxn];//dis记录未被加入集合的点到集合的最短距离
void init()//初始将所有边权值赋为正无穷大
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++) mapp[i][j]=inf;
}
void prim()
{
    fill(vis,vis+maxn,0);
    for(int i=1;i<=n;i++) dis[i]=mapp[1][i];//随便选择一个点，这里选择第一个点，dis记录所有点到这个点的距离
    dis[1]=0;//自己到自己距离为0
    vis[1]=1;//标记为访问过
    for(int i=1;i<n;i++)//第一个点已经加入集合，还有m-1个点
    {
        int Min=inf,k;
        for(int j=1;j<=n;j++) if(!vis[j]&&Min>dis[j]) Min=dis[j],k=j;//选择到集合距离最短的点，更新最短距离并记录该点
        if(Min==inf) {ans=-1;return;}//Min为无穷大表明没有与该图连通的点，也就是说这个图不是完全图
        ans+=Min;
        vis[k]=1;//将与该集合距离最短的点标记为访问过
        for(int j=1;j<=n;j++) if(!vis[j]&&dis[j]>mapp[k][j]) dis[j]=mapp[k][j];//更新所有与该集合的最近距离
    }
 }

2）prim+邻接矩阵建图+堆优化

#include<iostream>
#include<cstdio>
#include<queue>
#define maxn 111
#define inf 1<<29
using namespace std;
int vis[maxn],mapp[maxn][maxn],n,m,dis[maxn];
struct node
{
    int v,len;//v表示当前节点，len表示该点到已经连通集合的最短距离
    friend bool operator <(node a,node b)
    {
        return a.len>b.len;
    }
};
int prim()
{
    node cur;
    int ans = 0;
    priority_queue<node>q;
    fill(dis,dis+maxn,inf);
    fill(vis,vis+maxn,0);
    cur.v=1;
    cur.len=0;
    q.push(cur);
    while(q.size())
    {
        cur=q.top();
        q.pop();
        if(vis[cur.v]) continue;
        vis[cur.v]=1;
        ans+=cur.len;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i]&&dis[i]>mapp[i][cur.v])
            {
                node next;
                next.v=i;
                next.len=mapp[i][cur.v];
                dis[i]=mapp[i][cur.v];
                q.push(next);
            }
        }
    }
    return ans;
}

2.kruskal  复杂度o(eloge)

kruskal的思想就是先记录两点和这两个点的权值，然后对所有边进行排序。这里还用到了了并查集，若这两点不属于同一个集合，说明这两个点之间没有路，因为已经是从小到大排了序，所以直接把他们连通，让他们属于同一个集合，不断判断，直到所有边都进行了判断，然后再根据是否只有一个节点的父亲是他本身，若是，则说明最小生成树已经求出，否则不存在这样的树.

以hdu 1863为例

#include<iostream>
#include<algorithm>
#include<cstdio>
#define maxn 111
using namespace std;
int father[maxn];
struct node
{
    int l,r;
    int value;
};
int Find(int x)//并查集查找是否属于同一个集合
{
   if(father[x]!=x)
      father[x]=Find(father[x]);
   return father[x];
}
int Merge(int x,int y)//若不是同一集合，则加入集合
{
    x=Find(x);
    y=Find(y);
    if(x!=y) father[x]=y;
}
bool same(int x,int y)//判断是否是同一集合
{
    return Find(x)==Find(y) ? 1:0;
}
bool rule(node x,node y)
{
    return x.value<y.value;
}
int main()
{
    int n,m;
    node a[maxn];
    while(cin>>m>>n&&m)
    {
        for(int i=1;i<=n;i++) father[i]=i;//并查集初始化
        for(int i=1;i<=m;i++) cin>>a[i].l>>a[i].r>>a[i].value;
        sort(a+1,a+n+1,rule);//排序
        int ans=0;
        for(int i=1;i<=m;i++)
        {
            if(!same(a[i].l,a[i].r))//若两点之间没有路径，连接这条路，即加入同一个集合
            {
                 Merge(a[i].l,a[i].r);
                 ans+=a[i].value;
            }
        }
        int sum = 0;
        for(int i=1;i<=n;i++) if(father[i]==i) sum++;//看是否所有点都连通，若只有一个点的父亲是它本身，则表明所有点已经连通
        if(sum==1) cout<<ans<<endl;
        else cout<<'?'<<endl;
    }
    return 0;
}