poj 1734 (最小环)

floyd的核心思想就是动态规划从k=0->n来松弛i->j的路径，

因为floyd的外层到k时，i->j的最短路上肯定没有k。所以我们可以先找环，再更新。如果存在的话，那么肯定是i->j  然后j->k->i。这样保证了i->j这条路不经过k。

// File Name: 1734.cpp
// Author: Missa
// Created Time: 2013/2/7 星期四 16:39:58

#include<cstdio>
#include<cstring>
using namespace std;

const int inf = 100000000;
const int maxn = 110;
int n,m,num;
int dis[maxn][maxn];
int path[maxn][maxn];
int g[maxn][maxn];
int res[maxn];

void dfs(int i,int j)
{
    int k=path[i][j];
    if(k==0)
    {
        res[num++]=j;
        return ;
    }
    dfs(i,k);
    dfs(k,j);
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
                g[i][j]=g[j][i]=dis[i][j]=dis[j][i]=inf;
            g[i][i]=dis[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(z<g[x][y])
            {
                dis[x][y]=dis[y][x]=z;
                g[x][y]=g[y][x]=z;
            }
        }
        int ans=inf;
        memset(path,0,sizeof(path));
        for(int k=1;k<=n;k++)
        {
            for(int i=1;i<k;i++)
                for(int j=i+1;j<k;j++)//求环
                    if(dis[i][j] +g[i][k]+g[k][j] <ans)
                    {
                        ans=dis[i][j]+g[i][k]+g[k][j];
                        num=0;
                        res[num++]=i;
                        dfs(i,j);
                        res[num++]=k;
                    }
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    if(dis[i][k]+dis[k][j]<dis[i][j])//松弛
                    {
                        dis[i][j]=dis[i][k]+dis[k][j];
                        path[i][j]=k;
                    }
        }
        if(ans==inf)
            puts("No solution.");
        else
        {
            printf("%d",res[0]);
            for(int i=1;i<num;i++)
                printf(" %d",res[i]);
            printf("\n");
        }
    }
    return 0;
}