floyd离散，最小环

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.

 

对于找最小环，而且要经过至少两个节点，权值和最小，算法是floyd，但该注意和理解的地方实在很多

   .定义和理解：转自http://leon.cc.blogbus.com/logs/3629782.html
    在图论中经常会遇到这样的问题，在一个有向图里，求出任意两个节点之间的最短距离。我们在离散数学、数据结构课上都遇到过这个问题，在计算机网络里介绍网络层的时候好像也遇到过这个问题，记不请了... 但是书本上一律采取的是Dijkstra算法，通过Dijkstra算法可以求出单源最短路径，然后逐个节点利用Dijkstra算法就可以了。不过在这里想换换口味，采取Robert Floyd提出的算法来解决这个问题。下面让我们先把问题稍微的形式化一下：
     如果有一个矩阵D=[d(ij)]，其中d(ij)>0表示i城市到j城市的距离。若i与j之间无路可通，那么d(ij)就是无穷大。又有d(ii)=。编写一个程序，通过这个距离矩阵D，把任意两个城市之间的最短与其行径的路径找出来。
     我们可以将问题分解，先找出最短的距离，然后在考虑如何找出对应的行进路线。如何找出最短路径呢，这里还是用到动态规划的知识，对于任何一个城市而言，i到j的最短距离不外乎存在经过i与j之间的k和不经过k两种可能，所以可以令k=，，，...，n(n是城市的数目)，在检查d(ij)与d(ik)+d(kj)的值；在此d(ik)与d(kj)分别是目前为止所知道的i到k与k到j的最短距离，因此d(ik)+d(kj)就是i到j经过k的最短距离。所以，若有d(ij)>d(ik)+d(kj)，就表示从i出发经过k再到j的距离要比原来的i到j距离短，自然把i到j的d(ij)重写为d(ik)+d(kj)，每当一个k查完了，d(ij)就是目前的i到j的最短距离。重复这一过程，最后当查完所有的k时，d(ij)里面存放的就是i到j之间的最短距离了。所以我们就可以用三个for循环把问题搞定了，但是有一个问题需要注意，那就是for循环的嵌套的顺序：我们可能随手就会写出这样的程序，但是仔细考虑的话，会发现是有问题的。
                     for(int i=; i<n; i++)
                           for(int j=; j<n; j++)
                                for(int k=; k<n; k++)   

     问题出在我们太早的把i-k-j的距离确定下来了，假设一旦找到了i-p-j最短的距离后，i到j就相当处理完了，以后不会在改变了，一旦以后有使i到j的更短的距离时也不能再去更新了，所以结果一定是不对的。所以应当象下面一样来写程序：
                   for(int k=; k<n; k++)
                         for(int i=; i<n; i++)
                              for(int j=; j<n; j++)
    这样作的意义在于固定了k，把所有i到j而经过k的距离找出来，然后象开头所提到的那样进行比较和重写，因为k是在最外层的，所以会把所有的i到j都处理完后，才会移动到下一个k，这样就不会有问题了，看来多层循环的时候，我们一定要当心，否则很容易就弄错了。
     接下来就要看一看如何找出最短路径所行经的城市了，这里要用到另一个矩阵P，它的定义是这样的：p(ij)的值如果为p，就表示i到j的最短行经为i->...->p->j，也就是说p是i到j的最短行径中的j之前的最后一个城市。P矩阵的初值为p(ij)=i。有了这个矩阵之后，要找最短路径就轻而易举了。对于i到j而言找出p(ij)，令为p，就知道了路径i->...->p->j；再去找p(ip)，如果值为q，i到p的最短路径为i->...->q->p；再去找p(iq)，如果值为r，i到q的最短路径为i->...->r->q；所以一再反复，到了某个p(it)的值为i时，就表示i到t的最短路径为i->t，就会的到答案了，i到j的最短行径为i->t->...->q->p->j。因为上述的算法是从终点到起点的顺序找出来的，所以输出的时候要把它倒过来。
     但是，如何动态的回填P矩阵的值呢？回想一下，当d(ij)>d(ik)+d(kj)时，就要让i到j的最短路径改为走i->...->k->...->j这一条路，但是d(kj)的值是已知的，换句话说，就是k->...->j这条路是已知的，所以k->...->j这条路上j的上一个城市(即p(kj))也是已知的，当然，因为要改走i->...->k->...->j这一条路，j的上一个城市正好是p(kj)。所以一旦发现d(ij)>d(ik)+d(kj)，就把p(kj)存入p(ij)。

  对于代码的理解：

[cpp] view plaincopyprint?
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define data 100000000
#define N 110
#define min(x,y) ((x)>(y)?(y):(x))
int map[N][N],dis[N][N];
int n,m;
void floyd()
{
    int i,j,k,mina=data;
    for(k=;k<=n;k++)
    {
    //因为路径i到j的情况只有经过k和不经过k，而要求从一个点至少经过两个节点返回原点，k每次更新都会使dis[i][j]得到更新，而只有在更新了一次k之后才可以找min，min即是在dis[i][i]最短的情况下的求至少经过两个点又回到该点的最小距离，所以i和j的值都应该小于k，i的值从1到k-1，而j的值却跟i的值相关，即i!=j，因为当i=j时，dis[i][j]不是无穷大，而是从i->j->i的值，这就会出现自环，这里我定义自环为经过一个节点就返回原节点的节点，比如像1->2->1这样min的值会不准确，这不是经过了两个节点,所以下面第一个两层循环可以有三种写法，具体看代码  

//当要扩充第k个节点时，前k-1个节点已经用过，并且是用于更新最短路径dis[i][j]这就是第二个两层for循环，所以在更新k之前已经有一条最短路径从i到达j，此时再来寻找另外一个从i到j的路径，map[j][k]+map[k][i]，如果有的话则一定形成了从i回到i的环，比如 1->2值为1，2->3值为2,3->4值为3,4->1值为4，则第一次存在从1到3的最短路，再寻找时找到了1到4,4到3的路径，则形成了环，而且是最小的，注意第一个循环中加上的值是map[j][k]和map[k][i]的值，map的是值都是初始值，不会变化，而dis在不断更新
        for(i=;i<k;i++)
        {
            for(j=i+;j<k;j++)
            {
                mina=min(dis[i][j]+map[j][k]+map[k][i],mina);
            }
        }
        for(i=;i<=n;i++)
        {
            for(j=;j<=n;j++)
            {
               if(dis[i][j]>(dis[i][k]+dis[k][j]))
                dis[i][j]=dis[i][k]+dis[k][j];
            }
        }
    }
    if(mina<data)
    printf("%d\n",mina);
    else
    printf("It's impossible.\n");
}
int main()
{
    int a,b,c,i,j;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=;i<=n;i++)
         for(j=;j<=n;j++)
         {
             map[i][j]=data;
             dis[i][j]=data;
         }
        for(i=;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]>c)
            {
                 map[a][b]=map[b][a]=c;
                 dis[a][b]=dis[b][a]=c;
            }
        }
        floyd();
    }
    return ;
}  

这是第二种：
[cpp] view plaincopyprint?
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define data 100000000
#define N 110
#define min(x,y) ((x)>(y)?(y):(x))
int map[N][N],dis[N][N];
int n,m;
void floyd()
{
    int i,j,k,mina=data;
    for(k=;k<=n;k++)
    {
        for(i=;i<k;i++)
        {
            for(j=;j<i;j++)
            {
                mina=min(dis[i][j]+map[j][k]+map[k][i],mina);
            }
        }
        for(i=;i<=n;i++)
        {
            for(j=;j<=n;j++)
            {
               if(dis[i][j]>(dis[i][k]+dis[k][j]))
                dis[i][j]=dis[i][k]+dis[k][j];
            }
        }
    }
    if(mina<data)
    printf("%d\n",mina);
    else
    printf("It's impossible.\n");
}
int main()
{
    int a,b,c,i,j;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=;i<=n;i++)
         for(j=;j<=n;j++)
         {
             map[i][j]=data;
             dis[i][j]=data;
         }
        for(i=;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]>c)
            {
                 map[a][b]=map[b][a]=c;
                 dis[a][b]=dis[b][a]=c;
            }
        }
        floyd();
    }
    return ;
}  

这是第三种：
[cpp] view plaincopyprint?
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define data 100000000
#define N 110
#define min(x,y) ((x)>(y)?(y):(x))
int map[N][N],dis[N][N];
int n,m;
void floyd()
{
    int i,j,k,mina=data;
    for(k=;k<=n;k++)
    {
        for(i=;i<k;i++)
        {
            for(j=;j<k;j++)
            {
                mina=min(dis[i][j]+map[j][k]+map[k][i],mina);
            }
        }
        for(i=;i<=n;i++)
        {
            for(j=;j<=n;j++)
            {
             //注意这里i!=j
               if(i!=j&&dis[i][j]>(dis[i][k]+dis[k][j]))
                dis[i][j]=dis[i][k]+dis[k][j];
            }
        }
    }
    if(mina<data)
    printf("%d\n",mina);
    else
    printf("It's impossible.\n");
}
int main()
{
    int a,b,c,i,j;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=;i<=n;i++)
         for(j=;j<=n;j++)
         {
             map[i][j]=data;
             dis[i][j]=data;
         }
        for(i=;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]>c)
            {
                 map[a][b]=map[b][a]=c;
                 dis[a][b]=dis[b][a]=c;
            }
        }
        floyd();
    }
    return ;
}