搜索与图论 ---- Floyd求最短路及输出路径

该博客介绍了Floyd算法用于解决含有负权重边的有向图中多源汇最短路径的问题。算法通过动态规划更新图中节点间的最短距离，并在输出路径时提供路径还原方法。代码示例展示了如何实现Floyd算法，并处理不存在路径的情况。数据范围限制了图的规模和查询数量，以及边权重的取值。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

多源汇最短路

Floyd 算法

Floyd算法思想
设D[k,i,j]为“途经若干个编号不超过k的节点”，从i到j的最短路
长度。
则：
D[k,i,j] = min( D[k-1,i,j] , D[k-1,i,k] + D[k-1,k,j] )

void Floyd()
{
for(k=1;k<=n;k++)
	for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			if(dis[i][j]>(dis[i][k]+dis[k][j]))
			{
				dis[i][j]=dis[i][k]+dis[k][j];
				path[i][j]=k;
			} 
}

输出路径

// Floyd算法输出路径
// 初始化pre[i][j]= j;
int u = st;//st是起点,end是终点
while(u != pre[u][end])
{
	cout << u << endl;
	u = pre[u][end];
}
cout << u << endl;

题目链接

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。

数据保证图中不存在负权回路。

输入格式
第一行包含三个整数 n,m,k。

接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。

输出格式
共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。

数据范围

1≤n≤200,
1≤k≤n2 1≤m≤20000,
图中涉及边长绝对值均不超过 10000。

输入样例：

输出样例：

impossible
1

代码样例

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
#include<stack>
#include<queue>
#include<sstream>
#include<map>

#define x first
#define y second

using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 210;
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;

int gcd(int a, int b){return b ? gcd(b, a % b) : a;}
int lowbit(int x) {return x & -x;}

int n, m, k;
int g[N][N];

void floyd()
{
	
	for(int k = 1; k <= n; k ++ ){
		for(int i = 1; i <= n; i ++ ){
			for(int j = 1; j <= n; j ++ ){
				g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
			}
		}
	}
	
}

int main()
{
	cin >> n >> m >> k;
	for(int i = 1; i <= n; i ++ ){
		for(int j = 1; j <= n; j ++ ){
			if(i == j) g[i][j] = 0;
			else g[i][j] = 0x3f3f3f3f;
		}
	}
	for(int i = 0; i < m; i ++ ){
		int x, y, z;
		cin >> x >> y >> z;
		g[x][y] = min(g[x][y], z);
	}
	
	floyd();
	
	for(int  i = 0; i < k; i ++ ){
		int x, y;
		cin >> x >> y;
		if(g[x][y] > 0x3f3f3f3f / 2) cout << "impossible" << endl;
		else cout << g[x][y] << endl;
	}
	
	return 0;
}