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;
}