【模板】Bellman_Ford

Bellman_Ford

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

请你求出从1号点到n号点的最多经过k条边的最短距离，如果无法从1号点走到n号点，输
出impossible。

注意：图中可能 存在负权回路 。

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

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

输出格式
输出一个整数，表示从1号点到n号点的最多经过k条边的最短距离。

如果不存在满足条件的路径，则输出“impossible”。

数据范围
1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过10000。

输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3

BellmanFord

时间复杂度:O(nm)

空间复杂度:n^2

应用：有负边权的最短路问题

Bellman_Ford的原理就是通过中转点来更新最短路最后输出

模板:

void Bellman_Ford()
{
	memset(dist,0x3f,sizeof dist);//赋值
	dist[1]=0;//1->1 0步
	for(int i=0;i<k;i++)//循环k次
	{
		memcpy(last,dist,sizeof dist);//将dist cpy 到last里，为防止串联
		for(int j=0;j<m;j++)
		{
			Edge e=edges[j];//或者写成 auto e=edges[j]
			dist[e.b]=min(dist[e.b],last[e.a]+e.c);//用中转点更新
		}
	}
}

好了，最后附上完整代码:
C++ Code：

#include<bits/stdc++.h>
using namespace std;
const int N=510,M=10010;
struct Edge
{
	int a,b,c;
}edges[M];
int n,m,k;
int dist[N],last[N];
void Bellman_Ford()
{
	memset(dist,0x3f,sizeof dist);
	dist[1]=0;
	for(int i=0;i<k;i++)
	{
		memcpy(last,dist,sizeof dist);
		for(int j=0;j<m;j++)
		{
			Edge e=edges[j];
			dist[e.b]=min(dist[e.b],last[e.a]+e.c);
		}
	}
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m>>k;
	for(int i=0;i<m;i++)
	{
		int x,y,z;
		cin>>x>>y>>z;
		edges[i]={x,y,z};	
	} 
	Bellman_Ford();
	if(dist[n]>=0x3f3f3f3f/2) cout<<"impossible";
	else cout<<dist[n]; 
    return 0;
}