URAL1004 Sightseeing Trip(floyd+路径输出)

1004. Sightseeing Trip

Time limit: 0.5 second
Memory limit: 64 MB

There is a travel agency in Adelton town on Zanzibar island. It has decided to offer its clients, besides many other attractions, sightseeing the town. To earn as much as possible from this attraction, the agency has accepted a shrewd decision: it is necessary to find the shortest route which begins and ends at the same place.

Your task is to write a program which finds such a route. In the town there are  N crossing points numbered from 1 to  N and  M two-way roads numbered from 1 to  M. Two crossing points can be connected by multiple roads, but no road connects a crossing point with itself. Each sightseeing route is a sequence of road numbers  y 1, …,  yk,  k > 2. The road  yi  (1 ≤  i ≤  k − 1)  connects crossing points  xi and  x i+1, the road  yk connects crossing points  xk and  x 1. All the numbers  x 1, …,  xk should be different. The length of the sightseeing route is the sum of the lengths of all roads on the sightseeing route, i.e. L( y 1) + L( y 2) + … + L( yk) where L( yi) is the length of the road  yi (1 ≤  i ≤  k). Your program has to find such a sightseeing route, the length of which is minimal, or to specify that it is not possible, because there is no sightseeing route in the town.

Input

Input contains  T tests (1 ≤  T ≤ 5). The first line of each test contains two integers: the number of crossing points  N and the number of roads  M (3 ≤  N ≤ 100; 3 ≤  M ≤  N · ( N − 1)). Each of the next  Mlines describes one road. It contains 3 integers: the number of its first crossing point  a, the number of the second one  b, and the length of the road  l (1 ≤  a,  b ≤  N;  a ≠  b;  1 ≤  l ≤ 300 ). Input is ended with a “−1” line.

Output

Each line of output is an answer. It contains either a string “No solution.” in case there isn't any sightseeing route, or it contains the numbers of all crossing points on the shortest sightseeing route in the order how to pass them (i.e. the numbers  x 1 to  xk from our definition of a sightseeing route), separated by single spaces. If there are multiple sightseeing routes of the minimal length, you can output any one of them.

Sample

input	output
5 7 1 4 1 1 3 300 3 1 10 1 2 16 2 3 100 2 5 15 5 3 20 4 3 1 2 10 1 3 20 1 4 30 -1	1 3 5 2 No solution.

真的是一道很有意思的题，题意：给出n个点，m条双向边，求最小的环，并打印路径，如果有多个结果，输出任意一个

刚开始，我想的使用floyd跑一遍所有点，然后找到自己本身最小的点，输出路径，但由于是双向路，会出现直接去一个点就回来的情况，题意中给出这样是不满足的

随后就开始考虑如何不去一个点就回来，于是我就把floyd中的松弛加个判断(起点不能和终点相同)，但这样就不能松弛自己本身了，还要再跑一次floyd算松弛自己本身的情况

问题又出现了，由于前面跑过了一次floyd，有些不能一次性到达的点，变成了可以一次性到达，此时松弛自身又出现了这种情况 k->i->k->j->k(k为要松弛的本身，由于i->j用到了k松弛，就等价于k->i->k的情况)

看题解把。。。

题解：标记一个k点作为自环点，每次求i->j的最小距离，然后k->i->j->k即为自环路径，然后再以k点松弛，此时就保证了每次松弛k自环的时候，k都没被用于松弛，也就排除了上面说到的情况，如果可以刷新最小值记录此时k自环的答案，注意松弛k自环点的时候不能用别的自环点松弛，因为别的自环点也可能用一点松弛，而且别的自环点已经计算过的话，你以它松弛得到的点一定比它长，何必呢。。。此时得到的k自环最小值就不满足条件了，还有要注意每次k没跑floyd的时候刷新最小值和记录路径

#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
const int N=105;
const int inf=0x3f3f3f;
int n,m,minn,num;
int e[N][N],pre[N][N],dis[N][N],path[N];
void floyd()
{
    for(int k=1; k<=n; k++)
    {
        //此时k还没用来更新最短路，更新最小环
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(j==i)continue;//不用自环点松弛，因为下面floyd松弛可能是用的i->j->i的这种松弛
                int ans=dis[i][j]+e[k][i]+e[j][k];
                if(ans<minn)
                {
                    minn=ans;
                    num=0;
                    int p=j;
                    while(p!=i)
                    {
                        path[num++]=p;
                        p=pre[i][p];
                    }
                    path[num++]=i;
                    path[num++]=k;
                }
            }
        }
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(dis[i][j]>dis[i][k]+dis[k][j])
                {
                    dis[i][j]=dis[i][k]+dis[k][j];
                    pre[i][j]=pre[k][j];
                }
            }
        }
    }
}
int main()
{
    int u,v,w;
    while(~scanf("%d",&n)&&n!=-1)
    {
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                dis[i][j]=e[i][j]=inf;
                pre[i][j]=i;
            }
        }
        scanf("%d",&m);
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(w<e[u][v])
                e[u][v]=e[v][u]=dis[u][v]=dis[v][u]=w;
        }
        minn=inf;
        floyd();
        if(minn==inf)
            printf("No solution.\n");
        else
        {
            printf("%d\n",minn);
            printf("%d",path[0]);
            for(int i=1; i<num; i++)
                printf(" %d",path[i]);
            puts("");
        }
    }
}