Floyd

//Floyd算法
//图：
/************************************************************************/
/*            
0 1 1
0 2 5
1 2 3
1 3 7
1 4 5
2 4 1
2 5 7
3 4 2
4 5 3
3 6 3
4 6 6
4 7 9
5 7 5
6 7 2
6 8 7
7 8 4                                                         */
/************************************************************************/
#include<iostream>
#include<cstdlib>
#include<vector>
using namespace std;

const int inf = 1e9+7;					//最大值  
const int MAXV = 9;						//点的数量
int mat[MAXV][MAXV];					//邻接矩阵图
int dis[MAXV][MAXV];					//记录各顶点至各定点的值
int from[MAXV][MAXV];					//from[v][w]=k 表示v点到w点的最短路径经过k

void Floyd(){

	//为数组赋初值
	for( int v = 0 ; v < MAXV ; v ++ ){
		for( int w = 0 ; w < MAXV ; w ++ ){
			dis[v][w] = mat[v][w];
			from[v][w] = w;
		}
	}
	//三重循环  找出路径最短的
	for( int k = 0 ; k < MAXV ; k ++ ){
		for( int v = 0 ; v < MAXV ; v ++ ){
			for( int w = 0 ; w < MAXV ; w ++ ){

				if( dis[v][k] + dis[k][w] < dis[v][w] ){
					dis[v][w] = dis[v][k] + dis[k][w];
					from[v][w] = from[v][k];
				}
					
			}
		}
	}
	//主对角线 即自身到自身路径为0
	for( int v = 0 ; v < MAXV ; v ++ )
		dis[v][v] = 0;
}
void pintlnPath(){
	for( int v = 0 ; v < MAXV ; v ++ ){
		for( int w = v+1 ; w < MAXV ; w ++ ){
			cout << v << "->" << w << " weight: " << dis[v][w];
			int k = from[v][w];
			cout << "   Path: " << v;
			while( k != w ){
				cout << " -> " << k;
				k = from[k][w];
			}
			cout << " -> " << w << endl;
		}
		cout << endl;
	}
}
int main()
{
	//将所有边初始化为inf
	for( int i = 0 ; i < MAXV ; i ++ ){
		for( int j = 0 ; j < MAXV ; j ++ )
			mat[i][j] = inf;
	}
	int m;	//边的数量
	cin >> m;
	//  start->end 权值为weight  有向无向都适用  唯一不同 的是无向图需要对称赋值
	for( int i = 0 ; i < m ; i ++ ){
		int start,end,weight;
		cin >> start >> end >> weight;
		mat[start][end] = mat[end][start] = weight;
	}
	
	Floyd();
	pintlnPath();
	for( int i = 0 ; i < MAXV ; i ++ ){
		for( int j = 0 ; j < MAXV ; j ++ )
			cout << dis[i][j] << " ";
		cout << endl;
	}
	cout << endl;
	return 0;
}