解题报告之——hdu1233还是畅通工程（最小生成树）

还是畅通工程

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 21801    Accepted Submission(s): 9719

Problem Description

某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

 

 

Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。

 

 

Output

对每个测试用例，在1行里输出最小的公路总长度。

 

 

Sample Input

3 1 2 1 1 3 2 2 3 4 4 1 2 1 1 3 4 1 4 1 2 3 3 2 4 2 3 4 5 0

 

 

Sample Output

3 5

十分明显的最小生成树的题目。

对于计算最小生成树，主要方法有两种：kruskal算法和prim算法。

kruskal算法：

1.先对所有边进行排序。

2.取权值最小的边并判断是否在集合中，若没有则加入集合。

3.然后每次加入集合时进行累加。求得sum

kruskal算法的时间复杂度是ElogE，E为边数。

故该算法在边较少的情况下(即稀疏图下)效果较好。

prim算法：

1.判断集合外元素哪个距离集合最近，并将其加入集合。

2.更新集合外各个点到集合的最短距离。

Prim算法的时间复杂度是n^2 （n为点的个数）适合稠密图。

//kruskal算法最小生成树
#include<stdio.h>
struct road
{
    int x;
    int y;
    int d;
}r[10000];
int a[1000];
int find(int x)
{
    while(a[x]!=x)
        x=a[x];
    return x;
}
void merge(int x,int y)
{
    x=find(x);
    y=find(y);
    if(x!=y)
        a[x]=y;
}
void keep(int i,int n)
{
    int t,child;
    t=r[i].d,r[0]=r[i];
    for(;i*2<=n;i=child)
    {
        child=i*2;
        if(child!=n&&r[child].d>r[child+1].d)
            child++;
        if(r[child].d<t)
            r[i]=r[child];
        else break;
    }
    r[i]=r[0];
}
main()
{
    int n,i,j,sum,count,num;
    while(scanf("%d",&n)!=EOF&&n)
    {
        sum=(n*(n-1))/2;
        count=0;
        for(i=0;i<=n;i++)
            a[i]=i;
        for(i=1;i<=sum;i++)
        {
            scanf("%d%d%d",&r[i].x,&r[i].y,&r[i].d);
        }
        for(i=sum/2;i>=1;i--)
        {
            keep(i,sum);
        }
        for(i=sum;i>=1&&num!=n-1;i--)
        {
            if( find(r[1].x) != find(r[1].y ))
            {
                merge(r[1].x,r[1].y);
                count+=r[1].d;
                num++;
            }
            r[0]=r[i],r[i]=r[1],r[1]=r[0];
            keep(1,i-1);
        }
        printf("%d\n",count);

    }
}

下面这个是prime算法的

//prim 算法求最小生成树
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
const int MAX = 100000000;
int map[101][101], MIN, sum;
 // map[i][j] 记录从点 i 到点 j 的距离 ！
main()
{
    int n, x, y, m, v[101], flag, dis;
    while(scanf("%d", &n), n)
    {
          memset(map,0,sizeof(map));//数组清零
          m = (n*(n-1))/2;
           for (int i=0; i<m; i++)
          { //输入并处理边的信息
              scanf("%d %d %d", &x, &y, &dis);
              map[x-1][y-1] = map[y-1][x-1] = dis;
           }
           for (int i=0; i<n; i++)map[i][i] = MAX;
           //建图完成 ！
           memset(v, 0, sizeof(v));
           v[0] = 1;
           sum = 0;
           for (int i=1; i<n; i++)
           {
               MIN = 10000000;
               for (int j=0; j<n; j++)
               {
                   if (!v[j] && map[0][j] < MIN) //选择一个距离最小的加入
                   {
                      MIN = map[0][j];
                      flag = j;
                   }
               }
               sum += MIN;
               v[flag] = 1; //标记已加入的节点
                for(int j=0; j<n; j++) //更新距离
               {
                   if (!v[j] && map[0][j] > map[flag][j]) 
                   {
                      map[0][j] = map[flag][j];
                   }
                }
           }
         printf("%d\n",sum);
    }
 }