Bellman-Ford算法

时间复杂度O（mn）

存边方式(从a到b边权为w）

struct Edge
{
    int a,b,w; 
}edges[m];

算法大致过程

两重循环

第一重循环n次每次循环遍历所有变更新所有dist（更新方式与dijkstra算法相同）

Bellman-Ford算法循环完n次之后满足所有的边dist[b]<=dist[a]+w;

dist[b]<=dist[a]+w:三角不等式

dist[b]=min(dist[b],dist[a]+w):松弛操作；

Bellman-ford算法处理有负权边的最短路

当图中存在负权回路时最短路不一定存在

每当在2->3->4回路绕一圈最短路就会减少1当绕无穷圈时最短路就是-∞

如果能求出来最短路，图中一定不会存在负环

Bellman-Ford算法可以用来找负环但一般不用来找负环，找负环一般用spfa算法，bellman-ford算法找负环时间复杂度比较高

有边数限制的最短路不能用spfa算法只能用Bellman-Ford算法

第一重循环的n有实际意义代表不超过经过n条边的最短路

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N=510,M=10010;

int n,m,k;
struct Edge
{
    int a,b,w;
}edges[M];

int dist[N],backup[N];

int bellman_ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0; 
    //求不超过k条边的最短路
    for(int i=0;i<k;i++)
    {
        memcpy(backup,dist,sizeof dist);
        for(int j=0;j<m;j++)
        {
            auto e = edges[j];
            dist[e.b] = min(dist[e.b],backup[e.a]+e.w);
        }
    }
    return dist[n];
}

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};
    }
    int t=bellman_ford();
    if(t>0x3f3f3f3f/2)   puts("impossible");
    else        printf("%d\n",t);
    
    return 0;
}