prum算法介绍

 

Hd1301 Jungle Roads

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1660    Accepted Submission(s): 1204

Problem Description

The Head Elder of the tropical island of Lagrishan has a problem. A burst of foreign aid money was spent on extra roads between villages some years ago. But the jungle overtakes roads relentlessly, so the large road network is too expensive to maintain. The Council of Elders must choose to stop maintaining some roads. The map above on the left shows all the roads in use now and the cost in aacms per month to maintain them. Of course there needs to be some way to get between all the villages on maintained roads, even if the route is not as short as before. The Chief Elder would like to tell the Council of Elders what would be the smallest amount they could spend in aacms per month to maintain roads that would connect all the villages. The villages are labeled A through I in the maps above. The map on the right shows the roads that could be maintained most cheaply, for 216 aacms per month. Your task is to write a program that will solve such problems.

The input consists of one to 100 data sets, foldisted by a final line containing only 0. Each data set starts with a line containing only a number n, which is the number of villages, 1 < n < 27, and the villages are labeled with the first n letters of the alphabet, capitalized. Each data set is completed with n-1 lines that start with village labels in alphabetical order. There is no line for the last village. Each line for a village starts with the village label foldisted by a number, k, of roads from this village to villages with labels later in the alphabet. If k is greater than 0, the line continues with data for each of the k roads. The data for each road is the village label for the other end of the road foldisted by the monthly maintenance cost in aacms for the road. Maintenance costs will be positive integers less than 100. All data fields in the row are separated by single blanks. The road network will always aldist travel between all the villages. The network will never have more than 75 roads. No village will have more than 15 roads going to other villages (before or after in the alphabet). In the sample input bedist, the first data set goes with the map above.

The output is one integer per line for each data set: the minimum cost in aacms per month to maintain a road system that connect all the villages. Caution: A brute force solution that examines every possible set of roads will not finish within the one minute time limit.

 

 

Sample Input

9

A 2 B 12 I 25

B 3 C 10 H 40 I 8

C 2 D 18 G 55

D 1 E 44

E 2 F 60 G 38

F 0

G 1 H 35

H 1 I 35

3

A 2 B 10 C 40

B 1 C 20

0

 

 

Sample Output

216

30

 

 

Source

Mid-Central USA 2002

 

 

Recommend

Eddy

 

 

题目分析：求有关的最小生成树

 

 

关于prim算法

先把有的点放于一个集合（或者数组）里，这个集合里存放的是所有走过的点。初始值为0或者false表示还没有点

声明一个一维数组用于记录各点的权值[可理解为起始点到目标点的距离]，

声明一个二维数组用于记录某点到某一点的权值，如果这两点不可达到，则设置为无穷大

 

具体执行过程：

先从某一点开始，把这一个开始的点放于声明的一个数组或者集合里，表明这一点已经被访问过。然后再从余下的n-1个点里去找那个权值最小的点并记录该点的位置然后再加上这一点的权值，同时将该点放于集合里表明该点已初访问。再更新权值

再看下图，从下图分析：

1、

先选取一个点作起始点，然后选择它邻近的权值最小的点（如果有多个与其相连的相同最小权值的点，随便选取一个）。如1作为起点。

isvisited[1]=1;      //表明把1加进来说明是已经访问过

pos=1;  //记录该位置

//用dist[]数组不断刷新最小权值，dist[i](0<i<=点数)的值为：i点到邻近点（未被标记）的最小距离。

dist[1]=0;  //起始点i到邻近点的最小距离为0

dist[2]=map[pos][2]=4;

dist[3]=map[pos][3]=2;

dist[4]==map[pos][4]=3;

dist[5]=map[pos][5]=MaxInt;  //无法直达

dist[6]=map[pos][6]=MaxInt;

 

2、

再在伸延的点找与它邻近的两者权值最小的点。

//dist[]以3作当前位置进行更新

isvisited[3]=1;

pos=3;

dist[1]=0;   //已标记，不更新

dist[2]=map[pos][2]=4;  //比5小，不更新

dist[3]=2;  //已标记，不更新

dist[4]=map[pos][4]=3;   //比1大，更新

dist[5]=map[pos][5]=MaxInt;

dist[6]=map[pos][6]=MaxInt;

 

3、最后的结果:

 

当所有点都连同后，结果最生成树如上图所示。

所有权值相加就是最小生成树，其值为2+1+2+4+3=12。

 

 

HDOJ1301的代码实现

 

 

//HDOJ1301

#include<iostream>

using namespace std;

#define MAX 99999

#define LEN 30

int dist[LEN];//某点的权值  起始点到目标点的权值

int map[LEN][LEN];//某点到某点两点之间的权值

bool isvisitd[LEN];//表示某点是否访问过

 

//初始化map数组  设置为无穷大

void  init(int n){

    for(int  i = 0;i<=n;i++) {

         for(int  j = 0;j<=n;j++)

            map[i][j] = MAX;

     }

}

 

//prim最小生成树的算法

int prim(int n){

         int i,j,min,pos,sum;

         sum = 0;   //最小生成树的权值

 

         //初始化，表示没有一点走过

         memset(isvisitd,false,sizeof(isvisitd));

        

         //初始化给dist数组赋值

         for(i = 1;i<=n;i++){

                   dist[i] = map[1][i];

         }

 

         isvisitd[1] = true;//标记1已被访问  从1开始

 

         //找到权值最小点并记下位置

         for(i = 1;i<n;i++){

                            min = MAX;

                            for(j = 1;j<=n;j++){

                            if(!isvisitd[j]&&dist[j]<min){

                                     min = dist[j];

                                     pos = j;//记录下该位置

                            }

                   }

 

                   sum+=min;

                   isvisitd[pos] = true;

 

                   //更新权值

                   for(j = 1;j<=n;j++)    {

                            if(!isvisitd[j]&&dist[j]>map[pos][j]){

                                     dist[j] = map[pos][j];

                            }

                   }

 

         }

         return sum;

}

int main(){

         int i,j,n,m,len;

         char start,end;

         while(scanf("%d",&n)!=EOF){

                   if(n==0){

                            break;

                   }

 

                   init(n);//初始化

 

                   for(i=0;i<n-1;i++){

                            cin>>start>>m;

                            for( j = 0;j<m;j++){

                                     cin>>end>>len;

                                      map[i+1][end-'A'+1] = len;

                                     map[end-'A'+1][i+1] = len;

                            }

                   }

                   cout<<prim(n)<<endl;

         }

         return 0;

}