51nod 1212 无向图最小生成树(prim算法和kruska算法) 新手小结

 

N个点M条边的无向连通图，每条边有一个权值，求该图的最小生成树。

Input

第1行：2个数N,M中间用空格分隔，N为点的数量，M为边的数量。（2 <= N <= 1000, 1 <= M <= 50000)
第2 - M + 1行：每行3个数S E W，分别表示M条边的2个顶点及权值。(1 <= S, E <= N，1 <= W <= 10000)

Output

输出最小生成树的所有边的权值之和。

Input示例

9 14
1 2 4
2 3 8
3 4 7
4 5 9
5 6 10
6 7 2
7 8 1
8 9 7
2 8 11
3 9 2
7 9 6
3 6 4
4 6 14
1 8 8

Output示例

37

 

最小生成树的模板题，直接套模板就能做出来。第一次做这种图论的题，收获不错，小结以下，适合刚入门新手看。

首先说说prim算法。

1:  从某个点开始，将该点加入图中

2:  判断与图中点相连的最短边，将该边连接的点加入图

3：循环直至所有点加入

大概思路如上说述，代码的实现要点有几个：

1：用一个一维数组作标志，标记第i个点是否已加入图

2：用一个二维数组保存两点间的距离

3：用一个一维数组保存第i个点与图中点的最短距离，这个要细说一下，每一轮循环加入一个点，那么这个数组就要进行更新的，因为之前没这个点，那么这个点的边就没有进行比较，在加入这个点后就要更新这个数组。

4：上面3的意思具体如何实现呢，记录一个最新加入图的点，然后循环将这个点与所有点的距离与最小距离数组作比较，有个细节是最小边可能是刚入的点连接的，也可能是之前就有的边，在更新数组的同时比较最小边，方便下次加入新的点。

代码献上：

 

#include <stdio.h>
    int ans=0,numd,numb,i,j,t1,t2,t3,zuida=100005;
    int isIn[1005],mi[1005],tu[1005][1005];
int main(){

    scanf("%d%d",&numd,&numb);//输入边，点的个数
    for(i=1;i<=numd;i++)         //初始化
    {
        isIn[i]=0;
        mi[i]=zuida;
        for(j=1;j<=numd;j++)
        tu[i][j]=zuida;
    }
    while(numb--)             //输入边
    {
        scanf("%d%d%d",&t1,&t2,&t3);
        if(tu[t1][t2]>t3)
            tu[t1][t2]=tu[t2][t1]=t3;
    }
    isIn[1]=1;
    int lastInput=1,min,mindian;
    for(t1=1;t1<numd;t1++)
    {
        min=zuida;
        for(i=1;i<=numd;i++)
            if(isIn[i]!=1)
            {
                if(tu[lastInput][i]<mi[i])
               mi[i]=tu[lastInput][i];
               if(tu[lastInput][i]<min)
               {
                   min=tu[lastInput][i];
                   mindian=i;
               }
               if(mi[i]<min)
               {
                   mindian=i;
                   min=mi[i];
               }
            }
        isIn[mindian]=1;
        //if(min!=zuida)
        ans+=min;
        lastInput=mindian;
    }
    printf("%d",ans);
    return 0;
}

 

 

接下来说说kruska算法

       在学习这个算法的时候补了一波并查集，那时候想这算法这么麻烦还不如直接用Prim算法好了，后来硬啃完发现，这个算法更加精妙，感觉更巧妙，不像prim那么麻烦，不断更新。这个算法在边数少的时候用比较好，毕竟kruska算法是以边为对象，而prim以点，两个方法建议都要学会，不要有我之前想着会一个就算了的不好想法。

好了切入正题：

       首先它是以边为主，先排序，从短到长考察边，如果考察的边连接的两个点不是一个连通分量，注意是连通分量，就是其中一个点不能根据已经选中的点走到另外一个点，就不是一个连通分量，直到所有点都连接，那接下来就说说如何实现。

     1: 用结构点保存边，方便排序，两点一长度(该算法以边为主)，自定义比较函数用sort快排即可。

     2：并查集，这个说难不难，说简单不了解思路也不行，主要以数组实现，保存每个点的父节点（可以理解为这个点和哪个点相连）

     3：并查集，何谓查，就是通过数组找到这个点的根节点（树结构），可以通过递归或者循环实现，建议使用循环，递归存在爆的可能。

     4：何谓并，就是我找到最短边是连接两个连通分量，我就将其中一个的根节点连接到另外一个连通分量，这里可以使用路径压缩（看需不需要中间数据决定是否使用）

     5：何谓路径压缩，一个单独点和一个连通分量连接（树），我选择连接这个数的根节点而不是某一个子节点（通过递归找到根节点）。

    代码献上：

 

#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#include <mem.h>
using namespace std;
 int n,numb,i,j,ans=0,numd=0,dian[1005],gen1,gen2; //dian数组保存父节点
struct bi
{
    int from,to,leng;
}bian[50005];
int cmp(bi a,bi b)
{
    if(a.leng<b.leng)
    return 1;
    return 0;
}
int findFu(int i)   //返回i点所在图的根节点
{
    int a,b;
    a=i;    //保存，后面需要
    while(dian[i]!=i)//不是根节点
          i=dian[i];   //找到要找的根结点为止
    while(dian[a]!=i)
    {
        b=a;//a需要改到图的根节点，保存原本的父节点
        a=dian[a];
        dian[b]=i;
    }
    return i;
}

int main()
{
    scanf("%d%d",&n,&numb);
     for(i=1;i<=n;i++)
        dian[i]=i;
    for(i=0;i<numb;i++)
        scanf("%d%d%d",&bian[i].from,&bian[i].to,&bian[i].leng);
        sort(bian,bian+numb,cmp);
        for(i=0;i<numb;i++) //遍历边
        {
            gen1=findFu(dian[bian[i].from]);
            gen2=findFu(dian[bian[i].to]);
            if(gen1!=gen2)
            {
                ans+=bian[i].leng;
                numd++;
                dian[gen1]=gen2;
            }
            if(numd==n)
                break;
        }
       // for(i=1;i<=n;i++)
         //   cout<<dian[i]<<"  ";
    cout<<ans;
    return 0;
}