Floyed算法——最短路径问题

弗洛伊德算法（Floyed）
 Floyd算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。

Floydl算法的时间复杂度为O(N3)，空间复杂度为O(N2)。

 Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力

图演示: 

题解：

样例输入

4 8
1 2 2
1 3 6
1 4 4
2 3 3
3 1 7
3 4 1
4 1 5
4 3 12

样例输出

0 2 5 4
9 0 3 4
6 8 0 1
5 7 10 0

代码如下 ：

#include<bits/stdc++.h>
/*
Floyed算法（求最短路径）：
求点a到点b的最短路径，需要将所有的点位置设置为中转点，从而求最小值
如果：e[a][b]>e[i][k]+e[k][j] e[i][j]=e[i][k]+e[k][j]
*/
int e[11][11];//邻接矩阵存储图
int n,m;
int p,q,t;
using namespace std;
int main(){
	cin>>n>>m;
	//初始化邻接矩阵
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(i==j) e[i][j]=0;
			else e[i][j]=1000000;
		}
	}
	for(int i=1;i<=m;i++){
		cin>>p>>q>>t;
		e[p][q]=t;
	}
	//Floyed
	//把第k个城市作为中间值考虑
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(e[i][j]>e[i][k]+e[k][j]){
					e[i][j]=e[i][k]+e[k][j];
				}
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(e[i][j]!=1000000){
				cout<<e[i][j]<<" ";
			}else{
				cout<<-1<<" ";
			}
		}
		cout<<endl;
	}
	return 0;
}
/*
1~1:0
1~2:
	1中转:1~1 1~2 0+2=2
	2中转:1~2 2~2 2+0=2
	3中转:1~3 3~2 最大
	4中转:1~4 4~2 最大
1~3:
	1中转:1~1 1~3 6
	2中转:1~2 2~3 2+3=5
	3中转:1~3 3~3 5
	4中转:1~4 4~3 16
1~4：
	1中转:1~1 1~4 0+4=4
	2中转:1~2 2~4 最大
	3中转:1~3 3~4 6
	4中转:1~4 4~4 4
*/