图论之最小生成树

在无向图中，连通且不含圈的图称为树。给定无向图G，连接G中的所有点，且边集是E的子集的树称为G的生成树，而权值最小的生成树称为最小生成树（MST）。
构造MST的算法有很多，最常见的有两个：Kruskal算法和Prim算法。
话不多说，用题来讲吧≧▽≦
SDNU 1218认路

Description

lmh刚来到山师学习，他知道以后自己要在这里生活很长时间，所以想要尽快弄清楚学校里面各种设施的位置，方便以后找路。但是他又不希望总是走回头路，希望能够走最少的路来将所有的要了解的位置都认一遍，请已经熟知学校路的你为他规划一个路径，让他可以尽快融入山师。（出发的起点与终点不固定）

Input

第一行有两个数n和m，n表示有n个需要去探索的地点，m表示有m条道路。接下来的m行，每行形如“a b c”用来表示一条道路，意思是地点a到地点b需要走的路长度为c。（1<=n<=100,1<=m<=300，1<=a,b<=n，1<=c<=10000）

Output

输出走遍学校共走了多长的路。

Sample Input

6 9
2 4 11
3 5 13
4 6 3
5 6 4
2 3 6
4 5 7
1 2 1
3 4 9
1 3 2

Sample Output

19
题意：为了让lmh快速了解学校，要求指一条最短的路，而且不规定起点终点。
换句话说就是用最少的边让图连通（任意两点之间可以互相到达）。
其实就是将多余的边去掉。
连n个顶点也就是至少需要n-1条边。
那么这就是一棵树。
这里就是求一个图的最小生成树。

Kruskal算法：边。

首先选择最短的边，然后次短的边……直到选择了n-1条边为止。
这就需要先对所有边按照权值进行从小到大的排序。
然后从最小的开始选择。
直到选择了n-1条边让整个图连通。
选择过程如图所示：

第5步后，我们会发现2和3已经被连通了，所以这两个不用连了，不然就成环了，同理4和5之间也不用连。
最终选用3 4 9之后，已经选了n-1条边。
连通完毕。
本算法的关键是：判断两个顶点是否已连通。
可以采用DFS或者BFS的方法来解决。不过效率很低。
所以并查集派上用场啦~
将所有顶点放入一个并查集中。
判断两个顶点是否在同一个集合即可。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int f[10005];
struct edge
{
    int u,v,w;
};//存点
edge e[10005];
int cmp(edge a,edge b)
{
    return a.w<b.w;//b不用xieif，这样简洁
}
int find(int x)
{
    if(f[x]==x)
        return x;
    else
    {
        f[x]=find(f[x]);//是赋值号！！！
        return f[x];
    }
}
int join(int a,int b)
{
    int t1,t2;
    t1=find(a);
    t2=find(b);
    if(t1!=t2)
    {
        f[t2]=t1;
        return 1;
    }
    return 0;
}
int main()
{
    int a,b,c,i,n,m,cou,sum;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        sum=0;
        cou=0;//cou是连接的边数
        memset(f,0,sizeof(f));
        memset(e,0,sizeof(e));
        for(i=1;i<=m;i++)
        {
            scanf("%d %d %d",&e[i].u,&e[i].v,&e[i].w);
        }
        sort(e+1,e+m+1,cmp);
        for(i=1;i<+m;i++)
        {
            f[i]=i;
        }
        for(i=1;i<=m;i++)
        {
            if(join(e[i].u,e[i].v))//判断两个点是否在一个集合
            {
                cou++;
                sum+=e[i].w;
            }
            if(cou==n-1)break;//边数至少n-1
        }
        printf("%d\n",sum);
    }
    return 0;
}

Prim算法：点。

要用n-1条边将n个顶点连接起来，每个顶点都至少有一条边与它相连。
那么我随便选一个顶点开始。
看看这个顶点有哪些边，在它的边中找一个最短的。
然后将这两个点相连。
再以这两个点有的边搜寻一个最短的边。
再进行相连。
重复这个步骤。
换句话说，就是将所有顶点分为了两类。
一类是已选入生成树的顶点。
一类是未选入生成树的顶点。
首先任意选择一个顶点。
接下来找出一条边添加到生成树。
这需要枚举每一个树顶点到每一个非树顶点所有的边。
然后找到最短边连入生成树。
重复操作n-1次，直到将所有的顶点都加入生成树。

实现这个算法比较复杂的问题在于如何找出下一个添加到生成树的边。枚举的话耗时。
所以我们采用一个数据dis来记录生成树到各个顶点的距离，即每个顶点到任意一个树顶点的最短距离。
即如果dis[k]>e[j][k]，则更新dis[k]=e[j][k]，其实这个类似于Dijkstra的思想。
具体步骤：
1、从任意一个顶点开始构造生成树，假设从1号开始，将顶点1加入生成树中，用一个一维数组book来标记哪些顶点已经加入了生成树。
2、用数组dis记录生成树到各个顶点的距离。最初生成树中只有1号顶点，有直连边时，数组dis中存储的就是1号顶点到该顶点的边的权值，没有直连边的时候就是无穷大，即初始化dis数组。
3、从数组dis中选出离生成树最近的顶点加入到生成树中（即在数组dis中找最小值），再以j为中间点，更新生成树到每一个非树顶点的距离。
4、重复第3步，直到生成树有n个顶点为止。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int main()
{
    int d1,d2,d3;//d1d2是两个点，d3是两个点之间的距离
    int i,j,k;
    int sum,cou,minx,m,n;
    int book[105];//一维数组book来标记哪些顶点已经加入了生成树
    int dis[105];//存储生成树到各个顶点的距离
    int e[105][105];
    int inf=99999999;
    while(~scanf("%d %d",&n,&m))
    {
        memset(dis,0,sizeof(dis));
        memset(e,0,sizeof(e));
        memset(book,0,sizeof(book));
        sum=0;
        cou=0;
        for(i=1; i<=n; ++i)
        {
            for(j=1; j<=n; ++j) //这步是初始化啊！怎么能把n写成m呢！
            {
                if(i==j)
                    e[i][j]=0;
                else e[i][j]=inf;

            }
        }
        for(i=1; i<=m; ++i)
        {
            scanf("%d %d %d",&d1,&d2,&d3);
            e[d2][d1]=d3;
            e[d1][d2]=d3;//zz这都能写反，e本来是空啊赋给d3是什么鬼
        }//无向的
        for(i=1; i<=n; ++i)
        {
            dis[i]=e[1][i];//把第一个点看作1,第一轮计算1到各点的距离
        }
        book[1]=1;
        cou++;
        while(cou<n)//最终也是连n-1条边
        {
            minx=inf;//初始化很重要！在这里！连成的第一条边为minx
            for(i=1; i<=n; i++)
            {
                if(book[i]==0&&dis[i]<minx)
                {
                    minx=dis[i];
                    j=i;//j是中间点
                }
            }
            book[j]=1;
            cou++;//连通一个点就是连通一条边
            sum+=dis[j];
            for(k=1; k<=n; k++)
            {
                if(book[k]==0&&dis[k]>e[j][k])
                    dis[k]=e[j][k];//以j为中间点，更新生成树到每一个非树顶点的距离。
            }
        }
        printf("%d\n",sum);
    }
    return 0;
}

ps：写完觉得prim比krustal稍麻烦，容易写错的地方很多>_<还是不够熟练，得多做几道题 QAQ