bellman_ford算法求最短路问题

先简单介绍一下算法的思想：

与dijkstra算法不同的是，bellman_ford算法是利用边来更新两点之间的距离

每次遍历所有边，看是否能够松弛，即更新源点到其他点的最小值。最多遍历n-1次，即可得到单源最短路。（遍历k次求出的是从源点经过不超过k条边走到任一点的最短距离）

算法实现起来比较简单，下面直接上代码：

//解释：dist[i]代表i号点距离源点的最短距离
//pre[i]用于存储i号点的前驱节点
//temp[]用于存储上一次的dist值，防止更新下一次dist数组时用成本次的dist值
void bellman_ford()
{
    memset(dist,0x3f,sizeof dist);//初始化距离
    dist[1]=0;//将1号点设置成源点
    for(int i=1;i<=k;i++)//遍历k次求出的是从一号点经过不超过k条边走到任一点的最短距离 
    {
        memcpy(temp,dist,sizeof dist);//我们在更新过程中dist数组在变化，导致我们更新其他点时用的可能不是原来的数组，所以我们要用一个数组备份一下 
        for(int j=1;j<=m;j++)
        {
            int a=p[j].u,b=p[j].v,c=p[j].w;
            if(d[b]>temp[a]+c)
            {
            	d[b]=temp[a]+c;
            	pre[b]=a;//记录路径 
			}
        }
    }
}

下面给出一道例题：

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

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=15000;
struct node{
    int u,v,w;
}p[N];
int n,m,k,d[N],temp[N];
void bellman_ford()
{
    memset(d,0x3f,sizeof d);
    d[1]=0;
    for(int i=1;i<=k;i++)//遍历k次求出的是从一号点经过不超过k条边走到任一点的最短距离 
    {
        memcpy(temp,d,sizeof d);//我们在更新过程中dist数组在变化，导致我们更新其他点时用的可能不是原来的数组，所以我们要用一个数组备份一下 
        for(int j=1;j<=m;j++)
        {
            int a=p[j].u,b=p[j].v,c=p[j].w;
            if(d[b]>temp[a]+c) d[b]=temp[a]+c;
        }
    }
}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        p[i]={x,y,z};
    }
    bellman_ford();
    if(d[n]>0x3f3f3f3f/2) puts("impossible");
    else printf("%d",d[n]);
    return 0;
}

由于bellman_ford算法的操作对象是边，所以我们只要用一个结构体存一下边即可，但是由于题目中说明可能存在负权边，所以我们判断n号点与1号点是否可达时不能只判断dist[n]与0x3f3f3f3f的关系，因为有负权边的存在，即使1号点与n号点不可达，dist[n]也可能会被更新成小于0x3f3f3f3f的数，所以应该判断dist[n]和0x3f3f3f3f / 2的关系。

负权边的存在导致不能使用dijkstra算法求最短路，但是不难发现bellman_ford算法的复杂度又太高，所以我们将会引入spfa算法，我将在下篇博客中引入对spfa算法的介绍！