HDOJ---1599 find the mincost route[floyd 判最小环]

find the mincost route

Time Limit: 1000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 886    Accepted Submission(s): 355

Problem Description

杭州有N个景区，景区之间有一些双向的路来连接，现在8600想找一条旅游路线，这个路线从A点出发并且最后回到A点，假设经过的路线为V1,V2,....VK,V1,那么必须满足K>2,就是说至除了出发点以外至少要经过2个其他不同的景区，而且不能重复经过同一个景区。现在8600需要你帮他找一条这样的路线，并且花费越少越好。

 

 

Input

第一行是2个整数N和M（N <= 100, M <= 1000)，代表景区的个数和道路的条数。
接下来的M行里，每行包括3个整数a,b,c.代表a和b之间有一条通路，并且需要花费c元(c <= 100)。

 

 

Output

对于每个测试实例，如果能找到这样一条路线的话，输出花费的最小值。如果找不到的话，输出"It's impossible.".

 

 

Sample Input

3 3 1 2 1 2 3 1 1 3 1 3 3 1 2 1 1 2 3 2 3 1

 

 

Sample Output

3 It's impossible.

 

 

Author

8600

 

 

Source

HDU 2007-Spring Programming Contest - Warm Up （1）

 

 

Recommend

8600

 

 

 

转自： http://hi.baidu.com/faithyzy/item/872254cdb31cff3798b498ee

题目大意：在一个无向图里面求一个除起始点和终点外没有重复经过的点的最小环

Floyd-最小环

朴素算法：

枚举删除每一条边，求一次单源最短路径，将边还原即有可能出现一个环，取最小即可。

利用Floyd算法：

设 g[i][j] 为 i 与 j 间边长， d[i][j] 为 i 与 j 间临时最短路。

for (k=1;k<=n;k++)
   {
    for (i=1;i<k;i++)
     for (j=i+1;j<k;j++)
      ans=min(ans,d[i][j]+g[i][k]+g[k][j]);
    for (i=1;i<=n;i++)
     for (j=1;j<=n;j++)
      if (d[i][j]>d[i][k]+d[k][j])
       d[i][j]=d[i][k]+d[k][j];
   }

算法解释：

根据Floyd算法原理，在最外层循环到k时，在d[i][j]的路径里所有节点的编号是小于k的。所以可以通过 d[i][j]+g[i][k]+g[k][j] 求得最小环。

 

 

code:

 1 #include<iostream>

 2 using namespace std;

 3 

 4 #define MAXN 110

 5 #define intmax 9999999

 6 

 7 int n,m;

 8 int map[MAXN][MAXN];

 9 int dis[MAXN][MAXN];

10 int mincost;

11 

12 void init()

13 {

14     int i,j;

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

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

17         {

18             map[i][j]=intmax;

19             dis[i][j]=intmax;

20         }

21 }

22 

23 void floyd()

24 {

25     int i,j,k;

26     for(k=1;k<=n;k++)

27     {

28         for(i=1;i<k;i++)

29             for(j=i+1;j<k;j++)

30                 mincost=min(mincost,dis[i][j]+map[k][j]+map[k][i]);

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

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

33                 dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);

34     }

35 }

36 

37 int main()

38 {

39     int i;

40     int a,b,c;

41     while(~scanf("%d%d",&n,&m))

42     {

43         init();

44         for(i=0;i<m;i++)

45         {

46             scanf("%d%d%d",&a,&b,&c);

47             if(c<map[a][b])

48             {

49                 map[a][b]=map[b][a]=c;

50                 dis[a][b]=dis[b][a]=c;

51             }

52         }

53         mincost=intmax;

54         floyd();

55         if(mincost<intmax)

56             printf("%d\n",mincost);

57         else

58             printf("It's impossible.\n");

59     }

60     return 0;

61 }