3.2.5 最短路径 floyd算法

Floyd算法

Floyd算法的实现思路是通过动态规划不断迭代来更新最短路径

适用情形：

• 多源最短路径问题

算法实现

• 创建邻接矩阵d，存储图，动态规划更新任意两点之间的最短路径
• 存图时将边权值赋给d [ i ] [ j ]，表示 i -> j 这条边
• 三重循环，分别遍历每一个顶点k，将顶点k作为中间节点，**min( i -> j , i -> k -> j )**更新 i -> j的最短路径（i->k->j表示含义可看下面代码实现中的解释）
• 三重循环过后，d [ i ] [ j ] 存储的为 i -> j 的最短路径

void floyd()
{
    //外循环表示将1-n作为中间节点
	for(int k=1;k<=n;k++){
        
        //内循环为使用k作为中间节点更新整个d[][]邻接矩阵的值
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
                //min( i -> j , i -> k -> j )更新 i -> j的最短路径
				d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
                
                //i->a->b-j比i->b->j短的话
                //d[i][b]就会更新为i->a->b
                //d[i][b]+d[b][j] 就会表示为i->a->b->j

			}
		}
	}
}

例题 AcWing 854. Floyd求最短路

题目大意：

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。数据保证图中不存在负权回路。

思路：

多源最短路径问题，floyd算法实现，三重循环，分别遍历每一个顶点k，将顶点k作为中间节点，**min( i -> j , i -> k -> j )**更新 i -> j的最短路径，三重循环过后，d [ i ] [ j ] 存储的为 i -> j 的最短路径

#include <bits/stdc++.h>
#define int long long

using namespace std;
const int N=510,INF=0x3f3f3f3f;

//邻接矩阵
int d[N][N];

int n,m,q;

void floyd()
{
    //外循环表示将1-n作为中间节点
	for(int k=1;k<=n;k++){
        
        //内循环为使用k作为中间节点更新整个d[][]邻接矩阵的值
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
			}
		}
	}
}

signed main()
{
	cin>>n>>m>>q;

	//初始化
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if( i == j ){
				d[i][j]=0;
			}else{
				d[i][j]=INF;
			}
		}
	}
	while(m--){
		int a,b,c;
		cin>>a>>b>>c;
		d[a][b]=min(d[a][b],c);
	}

	floyd();

	while(q--){
		int x,y;
		cin>>x>>y;
		//可能有负权边
		if(d[x][y]>INF/2){
			cout<<"impossble"<<endl;
		}else{
			cout<<d[x][y]<<endl;
		}
	}
	return 0;
}
/*
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3

impossible
1
*/