timus_1003_floyd_warshall

题目的意思：

　　一条路径的起点和终点相同，就是一只「环」。

有向图的环，可以特地称作​​「有向环」；无向图的环，可以特地称作​​「无向环」。环上每个点都恰好连着两条边。

无向环以另一种角度来看，就是两条路径，两条路径的起点相同、终点也相同。

习惯规定一个环至少三个点。

　　藉由Floyd-Warshall Algorithm 的过程，顺手穷举所有可能的最小环。代码如下：

#include <stdio.h>
#include <string.h>

int n;//交叉点的数量
int m;//路径的跳数
int edge[101][101];//记录每条边的情况,以及使用情况
int d[101][101];//记录顶点间距离
int path[101][101];//记录路径
int ans_path[101];//答案路径
int ans_len;//记录路径的长度
#define INFINITE 10000000
int min = INFINITE;//源到源的最小路径长度
//获得路径
void get_path(int i, int j)
{
    ans_path[ans_len ++] = j;
    if (i == j)    
        return;
    get_path(i, path[i][j]);
}

int main(void)
{
    int i, j, k, source, destination, distance, flag1;

    //输入数据
    while (1)    
    {
        scanf("%d", &n);    
        if (n == -1)
            break;
        scanf("%d", &m);
        //初始化edge
        for (i = 1; i <= n; i ++)
        {
            edge[i][i] = INFINITE;
            path[i][i] = INFINITE;
            for (j = i; j <= n; j ++)
                edge[i][j] = edge[j][i] = INFINITE;
        }
        for (i = 0; i < m; i ++)
        {
            scanf("%d%d%d", &source, &destination, &distance);    
            if (edge[source][destination] > distance)
            {
                edge[source][destination] = edge[destination][source] = distance;
                path[source][destination] = source;
                path[destination][source] = destination;
            }
        }
        min = INFINITE;
        memcpy(d, edge, sizeof(edge));
        for (k = 1; k <= n; k ++)
        {
            for (i =1; i < k; i ++)
                for (j = 1; j < k; j ++)
                    if (i != j)
                    {
                        if ( edge[k][i] + d[i][j] + edge[j][k] < min)        
                        {
                            min = edge[k][i] + d[i][j] + edge[j][k];    
                            ans_len = 0;
                            ans_path[ans_len ++] = k;
                            get_path(i, 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];
                        path[i][j] = path[k][j];
                    }
                    //printf("%d:%d ", d[i][j], path[i][j]);
                }
            //    printf("\n");
            }
        //    printf("\n\n");
        }
        if (min == INFINITE)
            printf("No solution.\n");
        else
        {
            while (ans_len)    
                printf("%d ", ans_path[-- ans_len]);
            printf("\n");
        }
    }
    return 0;
}