最短路径 Bellman-Ford

关于串联问题

• 关于存在串联的问题，也就是一轮循环会具有传递性
• 通过使用上一轮循环结果备份解决串联问题
• 以适配存在边数限制的最短路径问题
  

关于存在负环问题

• 存在负环，若所求最短路径经过该负环，则最短路径不存在
• 边数次循环后，再次循环，若发生松弛，即存在负环
  

代码

const int N = 510, M = 1e4+10, INF = 0x3f3f3f3f;
int h[N], e[M], ne[M], w[M], n, m, k, idx = 0;
int d[N], backup[N];
void add(int a, int b, int c){
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;}

int bellman_ford(int s)
{
    fill(d, d + N, INF);
    d[s] = 0;
    for(int i = 0; i < k; ++i)
    {
        memcpy(backup, d, sizeof(d));   // 备份上一轮循环的结果
        for(int u = 1; u <= n; ++u)
        {
            for(int v = h[u]; v != -1; v = ne[v])
            {
                int j = e[v];           // 检查松弛都使用备份
                if(backup[u] + w[v] < d[j])
                    d[j] = backup[u] + w[v];
            }
        }
    }
    for(int u = 1; u <= n; ++u) // 边数外循环判断负环
    {
        for(int v = h[u]; v != -1; v = ne[v])
        {
            int j = e[v];               // 判断负环也要使用backup，否则会出错
            if(backup[u] + w[v] < d[j]) 
                return false;
        }
    }
    return true;
}
int main()
{
    fill(h, h + N, -1);
    cin >> n >> m >> k;
    for(int i = 0; i < m; ++i)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    if(bellman_ford(1) == false || d[n] > INF / 2) // 注意这里的判断
        cout << "impossible";
    else
        cout << d[n];
    
    return 0;
}