最短路：Bellman-Ford和SPFA求最短路和负环

Bellman-Ford和SPFA求最短路

Bellman-Ford

时间复杂度 O(nm), n 表示点数，m 表示边数

最大特点：

• 能找到负环
• 得到不超过k条路的最短路，例如：要求解决最多只能完成K次飞行，在完成K飞行时的最短路。
• 注意：backup是备份上一次的dist数组。

int n, m;       // n表示点数，m表示边数
int dist[N];        // dist[x]存储1到x的最短路距离

struct Edge
{
    int a, b, w;
} edges[M];
// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

     // 如果第n次迭代仍然会松弛三角不等式，说明图中存在负权回路。
    for (int i = 0; i < n; i++) // k
    {
        memcpy(backup, 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], backup[a] + w);
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

SPFA(很好用)

SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA一般情况复杂度是O(m) 最坏情况下复杂度和朴素 Bellman-Ford 相同，为O(nm)。

时间复杂度：平均O(m)最坏O(nm)

步骤：

queue <– 1
while queue 不为空
​ (1) t <– 队头
​ queue.pop()
​ (2)用 t 更新所有出边 t –> b，权值为w
​ queue <– b (若该点被更新过，则拿该点更新其他点)

最大特点：

• 平均时间复杂度低
• 利用队列将距离变小的点加入队列中，降低了时间

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

SPFA判负环

使用spfa算法解决是否存在负环问题

• 1、dist[x] 记录当前1到x的最短距离
• 2、cnt[x] 记录当前最短路的边数，初始每个点到1号点的距离为0，只要他能再走n步，即cnt[x] >= n,则表示该图中一定存在负环，由于从1到x至少经过n条边时，则说明图中至少有n + 1个点，表示一定有点是重复使用
• 3、若dist[j] > dist[t] + w[i],则表示从t点走到j点能够让权值变少，因此进行对该点j进行更新，并且对应cnt[j] = cnt[t] + 1,往前走一步

注意：该题是判断是否存在负环，并非判断是否存在从1开始的负环，因此需要将所有的点都加入队列中，更新周围的点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2BfLgwsK-1591143546080)(…/…/…/图库/1591086720935.png)]

nt n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点，那么至少有n+1. 那么必定重复

    queue<int> q;
    for (int i = 1; i <= n; i ++ ) //判断是否存在负环，并非判断是否存在从1开始的负环，因此需要将**所有的点都加入队列中**，更新周围的点
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}