题目描述

给定一个 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

算法求解

分析

初试化操作和dijkstra相同：1的最短距离初始化为0，其他点初试化为INF
因为限制了要走的步数，蓑衣用bellman_ford算法：迭代k次可以找到从1出发走k步到个点的最短距离
注意每轮迭代进行松弛操作的时候，更新最短距离使用的是上次的结果，防止更新每条边的时候有串联效应

具体看参考文献的文章

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 510;
const int M = 10010;
const int INF = 0x3f3f3f3f;
struct Edge
{
	int a, b, w; // a->b 的边权为w 
}edges[M];// 保存所有边

int n, m, k;
int dist[N]; //当前 从1到每个点的最短路 
int last[N]; // 上一次迭代从1到每个点的最短路

void bellman_ford()
{
	// 和dijkstra一样初始化
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	// 迭代k次 ，就是松弛k轮 
	for(int i = 0; i < k; i++) 
	{
		memcpy(last, dist, sizeof dist); // 保存上一次迭代的结果
		for(int j = 0; j < m; j++) // 对所有边进行松弛操作 
		{
			int a = edges[j].a, b = edges[j].b, w = edges[j].w;
			dist[b] = min(dist[b], last[a] + w);
		}			
	} 
	
	
}

int main()
{
	scanf("%d%d%d", &n, &m, &k);
	for(int i = 0; i < m; i++)
	{
		int a, b, w;
		scanf("%d%d%d", &a, &b, &w);
		edges[i] = {a, b, w}; // edges[i].a = a;  edges[i].b = b;  edges[i].w = w; 
	}
	bellman_ford();
	
	if(dist[n] > INF / 2) printf("impossible"); //这里是因为存在负权边，有可能到不了n但是存在负边使得dist[n] < INF 
	else				  printf("%d\n", dist[n]);
	return 0; 
 }

时间复杂度

参考文章

https://zhuanlan.zhihu.com/p/352724346

Bellman-Ford算法

简介(Introdution)

贝尔曼-福特算法（Bellman-Ford）是由理查德·贝尔曼和莱斯特·福特创立的，求解单源最短路径问题的一种算法。它的原理是对图进行V-1次松弛操作，得到所有可能的最短路径。其优于Dijkstra算法的方面是边的权值可以为负数、实现简单，缺点是时间复杂度过高，高达 $O(VE)$ 。

描述(Description)

Bellman-Ford算法是一种处理存在负权边的单元最短路问题的算法。解决了Dijkstra无法求的存在负权边的问题。 虽然其算法效率不高，但是也有其特别的用处。其实现方式是通过m次迭代求出从源点到终点不超过m条边构成的最短路的路径。一般情况下要求途中不存在负环。但是在边数有限制的情况下允许存在负环。因此Bellman-Ford算法是可以用来判断负环的。
看一个例子：

示例(Example)

很重要的一点是每次迭代都是在上一次的基础上进行的，因此我们在代码实现时要注意保留上一次的结果，在上一次的基础上算。(理论中改变是同步完成的，但是实际上我们需要一个一个修改值。)直接给模板题目：

应用：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

分析(Analysis)

因为存在可能存在负权边，所以Dijkstra算法无法完成。又因为可能存在负环，SPFA算法(下一篇会讲)也无法完成。按道理来说，只要有负环且不限路径数，答案就可能是负无穷，Bellman-Ford算法也不能完成。但是本题给定了路径数k的限制，所以可以用Bellman-Ford算法来实现。

代码实现(Code)
int dist[N],backup[N];//dist距离，backup用来存上一次的结果。
struct edge//用来存边
{
    int a;
    int b;
    int w;
}Edge[M];
int Bellman_Ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;//初始化
    for(int i = 0 ; i < k ; i++)//遍历k次
    {
        memcpy(backup,dist,sizeof dist);//存上一次答案。
        for(int j = 0 ; j < m ; j++)
        {
            int a = Edge[j].a, b = Edge[j].b, w = Edge[j].w;
            dist[b] = min(dist[b],backup[a] + w);
        }//遍历所有边
    }
    if(dist[n] > 0x3f3f3f3f/2) return -1;
    /*这里不像Dijkstra写等于正无穷是因为可能有负权边甚至是负环的存在，
    使得“正无穷”在迭代过程中受到一点影响。*/
    return dist[n];
}
时间复杂度为 $O(nm)$ 。

Bell-Ford算法专用处理可能存在负环的有限路线单源最短路问题。