最短路径算法之一： Floyd 总结

多源点最短路径经典算法

参考几个最短路径的算法

• 算法思路：动态规格
• 时间复杂度：O(n^3)
• 主要考点：最短路径、可删除边、最小环

核心算法：最少只有4行

	//查找从 i 到 j 顶点之间的最短路径
	for(int k = 1; k <= n; k++)			//控制中间顶点
		for(int i = 1; i <= n; i++)		
			for(int j = 1; j <= n; j++)	
				//将顶点之间的最短路径保存
				//最短路径只有两种可能，从 i 到 j 或者从 i 到 k 到 j;
				map[i][j] = min(map[i][j],map[i][k]+map[k][j]);

最小环问题算法模板

主要思路是连接点 i j k找到最小的权重和 （具体方法看后面题目）

 //Floyd核心 
		 for(int k = 1; k <= N; k++)
		 {
		 	//在更新 K 值之前枚举 ijk组成的环
		 	 for(int i = 1; i < k; i++)
			  	for(int j = i+1; j < k; j++)
				  {
				  		//ans为现最小环大小，dis[i][j]为 i 到 j 的最短路径，map[][]为点之间的权值
						ans = min(dis[i][j]+map[i][k]+map[k][j],ans); 
				   } 
		 	 //更新K之后更新各源点最短路径 
		 	for(int i = 1; i <= N; i++)
		 		for(int j = 1; j <= N; j++)
		 		{
		 			dis[i][j] = dis[j][i] = min(dis[i][j],dis[i][k]+dis[k][j]);
				 }
		 }

完整的代码

#include
#include
using namespace std;
#define inf 0x3f3f3f;	//定义一个常数，表示点对之间没有连接
int map[100][100];		//存放图中各顶点的关系

//多源点最短路径经典算法
void floyd()
{
	int n;		//图中的顶点数
	int m;		//图中的边关系数
	cin >> n >> m;
	//对图进行初始化
	for(int i = 1; i <= n; i++ )
		for(int j = 1; j <= n; j++)
			if (i == j)	map[i][j] = 0;		//同一个顶点间的距离为 0
			else map[i][j] = inf;			//点对之间没有连接

	//输入点对之间的关系
	int a,b,c;
	for (int i = 1; i <= m; i++)
	{
		cin >> a >> b >> c;
		map[a][b] = c;		//将点对关系存进map数组
	}
	//floyd经典算法的核心部分
	for(int k = 1; k <= n; k++)
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= n; j++)
				//将顶点之间的最短路径保存
				//最短路径只有两种可能，从 i 到 j 或者从 i 到 k 到 j;
				map[i][j] = min(map[i][j],map[i][k]+map[k][j]);

	//输出最终结果
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			cout << map[i][j] << "   ";
		}
		cout << endl;
	}
}

int main()
{
	floyd();
	system("pause");
	return 0;
}

问题1：六度分离（求最短路径）

Problem Description
1967年，美国著名的社会学家斯坦利·米尔格兰姆提出了一个名为“小世界现象(small world phenomenon)”
的著名假说，大意是说，任何2个素不相识的人中间最多只隔着6个人，
即只用6个人就可以将他们联系在一起，因此他的理论也被称为“六度分离”理论(six degrees of separation)。
虽然米尔格兰姆的理论屡屡应验，一直也有很多社会学家对其兴趣浓厚，但是在30多年的时间里，
它从来就没有得到过严谨的证明，只是一种带有传奇色彩的假说而已。

Lele对这个理论相当有兴趣，于是，他在HDU里对N个人展开了调查。
他已经得到了他们之间的相识关系，现在就请你帮他验证一下“六度分离”是否成立吧。

Input
本题目包含多组测试，请处理到文件结束。
对于每组测试，第一行包含两个整数N,M(0 分别代表HDU里的人数（这些人分别编成0~N-1号)，以及他们之间的关系。
接下来有M行，每行两个整数A,B(0<=A,B 除了这M组关系，其他任意两人之间均不相识。

Output
对于每组测试，如果数据符合“六度分离”理论就在一行里输出"Yes"，否则输出"No"。

Sample Input
8 7 0 1 1 2 2 3 3 4 4 5 5 6 6 7 8 8 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 0

Sample Output
Yes Yes

Floyd算法最基本的内容，求各顶点之间的最短距离

#include 
#include 
using namespace std;
#define inf 0x3f3f3f;
int map[100][100];
int n,m;	//控制输入 
int main(int argc, char** argv) {
	while(cin >>n>>m)
	{
		//初始化map 
	 	for(int i = 0; i < n; i++)
		{
			for(int j = 0; j < n; j++)
			{
				if(i == j)	map[i][j] = 0;
				else map[i][j] = map[j][i] = inf;
			}
		 } 
		int a,b;	//关系
		//输入关系 
		for(int i = 0;i < m; i++)
		{
			cin >>a>>b;
			map[a][b] = map[b][a] = 1;
		 } 
		//Floyd的核心算法
		for(int k = 0; k < n; k++)
			for(int i = 0; i < n; i++)
				for(int j = 0; j < n; j++)
					 map[i][j] = map[j][i] = min(map[i][j] ,map[i][k]+map[k][j]);
			
		for(int i = 0; i < n;i++)
		{
			for(int j = 0; j < n; j++)
			{
				cout << map[i][j] << "    ";
			 } 
			 cout << endl;
		} 
		bool isyes = true;
		for(int i = 0;i < n;i++)
		{
			for(int j = 0;j < n;j++)
			{
				if(map[i][j] > 7)
				{
					cout << map[i][j] << endl; 
					isyes = false;
					break;
				}
			}
			if(!(isyes)) break;
		}
		if(isyes)
		{
			cout << "yes" << endl;
		}else{
			cout << "no" << endl;
		} 
	 } 
	return 0;
}

问题2：最短路程不变，关闭最大路径问题

题目：FNU2271
华师有N幢教学楼，每幢教学楼之间有多条线路连接，
由于维护每条路都需要花费不菲的金额。机智的华师男想要为学校省钱，
关闭几条线路，但是又不想增加自己从一个教学楼去另一个教学楼的路程。

请问最多可以关闭多少路，使得任何两幢教学楼之间的路程不会被改变。
请注意，教学楼A和B之间的路程是指需要从A到B最短路的长度。

Input
输入的第一行是一个整数T（1 <= T <= 50），代表案例的个数。

然后T个案例，每个案例以两个数字 N, M (1 <= N <= 100, 1 <= M <= 40000) 开始，
其中描述了国家X的城市数量和道路数量。每个案例每行由三行整数 x, y, s
(1 <= x, y <= N, 1 <= s <= 10, x，y保证不相等),
这意味着有一条路在城市x和城市y之间，它的长度是s。请注意，两个城市之间可能有不止一条道路。

Output
对于每种情况，首先输出案例编号，然后输出可能关闭的道路编号。这个数字应该尽可能的大。

Sample Input
2
2 3
1 2 1
1 2 1
1 2 2
3 3
1 2 1
2 3 1
1 3 1
Sample Output
Case 1: 2 Case 2: 0
代码

//求多源点最短路径，在不影响最短路径的情况下删边 
//删除： 重边（取两次输入一样的城市最短路径） 
//		 如果两个城市之间直连距离比经过中间城市的距离还大则删除去最短 
//		 如果如果两个城市之间没有直接连接  continue 
#include 
#include 
using namespace std; 
int inf = 8888888;
int T;
int N,M;
int x,y,s;
int ans = 0;
int map[100][100];
int main(int argc, char** argv) {
	 cin >>T;
	 int q = 0;
	 while(q++<T)
	 {
	 	cin >>N>>M;
	 	//初始化
	 	ans = 0;
		  for(int i = 1;i <= N; i++)
		  {
		  	for(int j = 1;j <= N; j++)
		  	{
		  		if(i == j) map[i][j] = 0;
				  else{
				  	map[i][j] = map[j][i] = inf;
				  } 
			}
		  }
		for(int i = 1; i <= M; i++)
		{
			cin >> x >> y >> s;
			//去重边 
			if(map[x][y] != inf)
			{
				map[x][y]=map[y][x] = min(s,map[x][y]);
				ans++;
			}else{
				map[x][y]=map[y][x] = s;
			}	
		}
		//Floyd核心
		for(int k = 1; k <= N; k++)
			for(int i = 1; i <= N; i++)
				for(int j = i; j <=N; j++)
				{
					if(map[i][j] > map[i][k]+map[k][j])
					{
						map[i][j] = map[j][i] = map[i][k]+map[k][j];
						ans++;
					}
				 } 
		cout << q << ":  " << ans <<endl;  	  
	 }
	 system("pause");
	return 0;
}

问题3：最小环问题

题目：可作为求最小环模板
Problem Description
杭州有N个景区，景区之间有一些双向的路来连接，现在8600想找一条旅游路线，
这个路线从A点出发并且最后回到A点，假设经过的路线为V1,V2,…VK,V1,
那么必须满足K>2,就是说至除了出发点以外至少要经过2个其他不同的景区，
而且不能重复经过同一个景区。现在8600需要你帮他找一条这样的路线，并且花费越少越好。

Input
第一行是2个整数N和M（N <= 100, M <= 1000)，代表景区的个数和道路的条数。
接下来的M行里，每行包括3个整数a,b,c.代表a和b之间有一条通路，并且需要花费c元(c <= 100)。

Output
对于每个测试实例，如果能找到这样一条路线的话，输出花费的最小值。
如果找不到的话，输出"It’s impossible.".

Sample Input
3 3 1 2 1 2 3 1 1 3 1 3 3 1 2 1 1 2 3 2 3 1

Sample Output
3 It’s impossible.
代码

#include 
#include 
using namespace std; 
int inf = 8888888;
int N,M;	
int a,b,c;
int map[100][100];	//图各点之间的权值 
int dis[100][100];	//各顶点之间的最短路径 
int ans = inf;		//最小环大小 
int main(int argc, char** argv) {
	while(cin >> N >> M)
	{
		//初始化
		ans = inf;
		for(int i = 1; i <= N; i++)
			for(int j = 1; j <= N; j++)
			{
				if(i == j) map[i][j] = dis[i][j] = 0;
				else	map[i][j] = dis[i][j] = inf;
			 } 
			 
		//输入
		for(int i = 1; i <= M; i++)
		{
			cin >> a >> b >> c;
			map[a][b] = map[b][a] = c;
			dis[a][b] = dis[b][a] = c;
		 } 
		 
		 //Floyd核心 
		 for(int k = 1; k <= N; k++)
		 {
		 	 for(int i = 1; i < k; i++)
			  	for(int j = i+1; j < k; j++)
				  {
						ans = min(dis[i][j]+map[i][k]+map[k][j],ans); 
				   } 
		 	 //更新K之后更新各源点最短路径 
		 	for(int i = 1; i <= N; i++)
		 		for(int j = 1; j <= N; j++)
		 		{
		 			dis[i][j] = dis[j][i] = min(dis[i][j],dis[i][k]+dis[k][j]);
				 }
		 }
		 
		 if(ans != inf)
		 cout << ans << endl;
		 else
		 cout << "It's impossible." << endl;
		 
	}
	return 0;
}