SDUT 3362 数据结构实验之图论六：村村通公路

数据结构实验之图论六：村村通公路

Time Limit: 1000MS Memory Limit: 65536KB

Submit Statistic

Problem Description

当前农村公路建设正如火如荼的展开，某乡镇政府决定实现村村通公路，工程师现有各个村落之间的原始道路统计数据表，表中列出了各村之间可以建设公路的若干条道路的成本，你的任务是根据给出的数据表，求使得每个村都有公路连通所需要的最低成本。

Input

连续多组数据输入，每组数据包括村落数目N(N <= 1000)和可供选择的道路数目M(M <= 3000)，随后M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个村庄的编号和修建该道路的预算成本，村庄从1～N编号。 

Output

输出使每个村庄都有公路连通所需要的最低成本，如果输入数据不能使所有村庄畅通，则输出-1，表示有些村庄之间没有路连通。 

Example Input

5 8
1 2 12
1 3 9
1 4 11
1 5 3
2 3 6
2 4 9
3 4 4
4 5 6

Example Output

19

DQE:

解法一（推荐）：普里姆算法。

 

 #include <iostream>
 #include <cstdio>
 #include <climits>

 using namespace std;

 #define MVN 1010

 typedef struct AdjMatrix
 {
     int w;
     char *info;
 }AM;

 typedef struct MGraph
 {
     int vex[MVN];
     AM arc[MVN][MVN];
     int vexn,arcn;
 }MG;

 void creat(MG &G)
 {
     int i,j,w,k;
     for(i=;i<=G.vexn;i++)
         for(j=;j<=G.vexn;j++)
             G.arc[i][j].w=INT_MAX;
     for(k=;k<=G.arcn;k++)
     {
         scanf("%d %d %d",&i,&j,&w);
         G.arc[i][j].w=G.arc[j][i].w=w;
     }
 }

 struct{int i,w;}C[MVN];        //辅助数组{树上最近顶点编号，到该顶点距离}
 int Mini(MG &G,int &sum)
 {
     int count=;    //统计树上顶点
     int i,j,k,min;
     //初始化辅助数组
     for(i=;i<=G.vexn;i++)
     {
         C[i].i=;
         C[i].w=G.arc[][i].w;
     }
     C[].w=;
     count++;
     //将最近的顶点加入树
     for(k=;k<=G.vexn;k++)
     {
         min=INT_MAX;
         i=-;
         for(j=;j<=G.vexn;j++)
             if(C[j].w>)
                 if(C[j].w<min)
                 {
                     i=j;
                     min=C[j].w;
                 }
         if(i==-)    //没有可加顶点时返回至调用处
             return count;
         sum+=C[i].w;
         C[i].w=;
         count++;
         //新顶点入树后更新辅助数组
         for(j=;j<=G.vexn;j++)
             if(G.arc[i][j].w<C[j].w)
             {
                 C[j].i=i;
                 C[j].w=G.arc[i][j].w;
             }
     }
     return count;
 }

 int main()
 {
     MG G;
     while(scanf("%d %d",&G.vexn,&G.arcn)!=EOF)
     {
         creat(G);
         int sum=;    //距离之和
         if(Mini(G,sum)==G.vexn)
             printf("%d\n",sum);
         else
             printf("-1\n");
     }
     return ;
 }

 /***************************************************
 User name: ***
 Result: Accepted
 Take time: 0ms
 Take Memory: 184KB
 Submit time: 2016-11-17 19:14:49
 ****************************************************/

解法二（不推荐）：最小生成树问题，学会使用countw数组连接下一个顶点，配合深度优先搜索判断公路是否连通，效率低下难懂，改用循环更佳。

 

 #include <iostream>
 #include <cstdio>
 #include <climits>    //INT_MAX

 using namespace std;

 #define MVN 101

 typedef struct AdjMatrix
 {
     int w;
     char *info;
 }AM;

 typedef struct MGraph
 {
     int vex[MVN];
     AM arc[MVN][MVN];
     int vexnum,arcnum;
 }MG;

 struct ue
 {
     int pr;
     int w;
 }countw[MVN],mi;

 void creat(MG &G)
 {
     int i,j,w,k;
     for(k=;k<=G.vexnum;k++)
         G.vex[k]=k;
     for(k=;k<=G.arcnum;k++)
     {
         scanf("%d %d %d",&i,&j,&w);
         G.arc[i][j].w=w;
         G.arc[j][i].w=w;
     }
 }

 int count,sum;
 void DFS(MG &G,bool *visited,int i)
 {
     count++;
     visited[i]=true;
     int k;
     mi.w=INT_MAX;
     mi.pr=;
     for(k=;k<=G.vexnum;k++)
     {
         if(countw[k].w<mi.w && visited[k]==false)
         {
             mi.pr=k;
             mi.w=countw[k].w;
         }
     }
     if(mi.pr!=)
     {
         for(k=;k<=G.vexnum;k++)
         {
             if(countw[k].w>G.arc[k][mi.pr].w)
             {
                 countw[k].pr=mi.pr;
                 countw[k].w=G.arc[k][mi.pr].w;
             }
         }//更新countw
         sum+=G.arc[countw[mi.pr].pr][mi.pr].w;
         DFS(G,visited,mi.pr);
     }
 }

 int main()
 {
     MG G;
     while(scanf("%d %d",&G.vexnum,&G.arcnum)!=EOF)
     {
         int k,o;
         for(k=;k<=G.vexnum;k++)
         {
             for(o=;o<=G.vexnum;o++)
             {
                 G.arc[k][o].w=INT_MAX;
             }
         }//邻接矩阵初始化
         creat(G);
         bool visited[MVN]={false};
         for(k=;k<=G.vexnum;k++)
         {
             if(G.arc[][k].w<INT_MAX)
             {
                 countw[k].pr=;
                 countw[k].w=G.arc[][k].w;
             }
             else
                 countw[k].w=INT_MAX;
         }
         count=;
         sum=;
         DFS(G,visited,);
         if(count==G.vexnum)
             printf("%d\n",sum);
         else
             printf("-1\n");
     }
     return ;
 }

 /***************************************************
 User name: ***
 Result: Accepted
 Take time: 0ms
 Take Memory: 172KB
 Submit time: 2016-11-09 21:00:48
 ****************************************************/