图论之判断负环

本博客贴出两种常见的 Spfa 判断负环的方法。
题目链接

spfa 超级源点判断

参考 Y 总做法

/*
 * 判断图中负环
 *
 * 判断负环是一个比较经典的问题，图中是否存在负环甚至是某些算法应用的先决条件，首先我们探讨一下什么是什么是环。
 *
 * 环
 *      环使之从一个点出发，经过其他点能，最后能够折返回到该点。环是相对于有向图而言的。因为无向图的话，倘若存在边，就存在环。
 *      有向图判断是否存在环，可以通过 TopSort (拓扑排序)，通过入度 in degree 的统计，复杂度是 O(M)
 *      有向图是否存在环，也可以使用 DFS 来判断，从一个点出发，然后查看是否会重复经过自己。复杂度是 O(NM)
 *          这里需要主要其中一个优化思想是错的，有些人认为在搜寻过程中，重复经过任意点就是环，
 *          如 1->2, 1->3, 2->3 图中, 3这个点重复经过了，但不存在环。因此复杂度需要 O(NM)。
 *
 *      综上，环的判断方法主要是 DFS 和 TopSort，复杂度分别是 O(NM) 和 O(M)
 * 负环
 *      负环，是在环的基础之上，进一步要求环上边的权重之和为负数。
 *      从定义来看，负环不仅仅和边的存在还和边的权重相关。判断是否存在的算法，我个人感觉有以下几种（我并没有搜索）
 *      1. DFS，这次DFS 复杂度会比 环DFS 复杂度高，因为环只需要判断是否可以到达该点，此时我们需要加上权重的衡量，距离 dist 要小。
 *      2. 根据最短路的边长来看
 *          * Bellman-Ford在没有负环的前提下，最多运行 n - 1次循环，一定循环次数大于等于 n 即说明存在负环，使得最短路路径 >= n 复杂度 O(NM)
 *          * 不论是什么算法，一定最短路的路径大于等于 n 的话，就说明存在负环
 *          * spfa 算法，以任意原点为起点，倘若存在其他点路径 >= n 就说明存在负环，否则其他未经过的点为起点，重复进行。
 *          *   复杂度 O(NM)，并且往往达不到 O(NM)，这是因为以 u 点为原点，不存在负环的话，那么说明 所有 U 可达的点，都不存在负环，
 *          *   一个集合一个集合的遍历，复杂度自然是很低。
 *          * - spfa 另一种 spfa 可以直接，相当于直接开启一个超级远点 O 点，距离其他点为 0，查看其他点是否存在负环的情况。
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <queue>
 
using namespace std;
 
const int N = 2010, M = 10010, INF = 0x3f3f3f3f;
int n, m;
int h[N], e[M], ne[M], w[M], idx;
int dist[N], cnt[N];
bool st[N];
 
 
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
 
bool super_src_judge_negative_circle() {
    // initialize
    memset(st, false, sizeof st);
    memset(dist, 0, sizeof dist);   // 直接 dist = 0，或者是任意常数即可，主要是怕 INF 越界
    memset(cnt, 0x3f, sizeof cnt);
 
    queue<int> que;
    for (int i = 1; i <= n; i ++ ) {
        st[i] = true;
        cnt[i] = 0;
        que.push(i);
    }
    // 倘若 visited 的点，就不必再次经过了，因为他身上绝不会存在负环。
    // 一旦经过了负环上的点，那么一点按照负环环绕，最短路径必然会大于 n
    int u, v;
    while (que.empty() == false) {
        u = que.front();    que.pop();
        st[u] = false;
        for (int i = h[u]; ~i; i = ne[i]) {
            v = e[i];
            if (dist[v] > dist[u] + w[i]) {
                dist[v] = dist[u] + w[i];
                cnt[v] = cnt[u] + 1;
                if (cnt[v] >= n) {  // 出现负环
                    return true;
                }
                if (st[v] == false) {
                    st[v] = true;
                    que.push(v);
                }
            }
        }
    }
 
    return false;
}
 
 
int main()
{
    // initialize
    memset(h, -1, sizeof h);
    memset(ne, -1, sizeof ne);
    idx = 0;
 
    // input
    scanf("%d%d", &n, &m);
    int a, b, c;
    while (m -- ) {
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
 
 
    if (super_src_judge_negative_circle()) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
 
    return 0;
}
 

spfa 记忆数组实现

自己基于记忆数组的想法

/*
 * 判断图中负环
 *
 * 判断负环是一个比较经典的问题，图中是否存在负环甚至是某些算法应用的先决条件，首先我们探讨一下什么是什么是环。
 *
 * 环
 *      环使之从一个点出发，经过其他点能，最后能够折返回到该点。环是相对于有向图而言的。因为无向图的话，倘若存在边，就存在环。
 *      有向图判断是否存在环，可以通过 TopSort (拓扑排序)，通过入度 in degree 的统计，复杂度是 O(M)
 *      有向图是否存在环，也可以使用 DFS 来判断，从一个点出发，然后查看是否会重复经过自己。复杂度是 O(NM)
 *          这里需要主要其中一个优化思想是错的，有些人认为在搜寻过程中，重复经过任意点就是环，
 *          如 1->2, 1->3, 2->3 图中, 3这个点重复经过了，但不存在环。因此复杂度需要 O(NM)。
 *
 *      综上，环的判断方法主要是 DFS 和 TopSort，复杂度分别是 O(NM) 和 O(M)
 * 负环
 *      负环，是在环的基础之上，进一步要求环上边的权重之和为负数。
 *      从定义来看，负环不仅仅和边的存在还和边的权重相关。判断是否存在的算法，我个人感觉有以下几种（我并没有搜索）
 *      1. DFS，这次DFS 复杂度会比 环DFS 复杂度高，因为环只需要判断是否可以到达该点，此时我们需要加上权重的衡量，距离 dist 要小。
 *      2. 根据最短路的边长来看
 *          * Bellman-Ford在没有负环的前提下，最多运行 n - 1次循环，一定循环次数大于等于 n 即说明存在负环，使得最短路路径 >= n 复杂度 O(NM)
 *          * 不论是什么算法，一定最短路的路径大于等于 n 的话，就说明存在负环
 *          * spfa 算法，以任意原点为起点，倘若存在其他点路径 >= n 就说明存在负环，否则其他未经过的点为起点，重复进行。
 *          *   复杂度 O(NM)，并且往往达不到 O(NM)，这是因为以 u 点为原点，不存在负环的话，那么说明 所有 U 可达的点，都不存在负环，
 *          *   一个集合一个集合的遍历，复杂度自然是很低。
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <queue>
 
using namespace std;
 
const int N = 2010, M = 10010, INF = 0x3f3f3f3f;
int n, m;
int h[N], e[M], ne[M], w[M], idx;
int dist[N], cnt[N];
bool st[N], visited[N];
 
 
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
 
bool judge_negative_circle(int src) {
    // initialize
    memset(st, false, sizeof st);
    memset(dist, 0x3f, sizeof dist);
    memset(cnt, 0x3f, sizeof cnt);
    st[src] = true;
    dist[src] = 0;
    cnt[src] = 0;
 
    queue<int> que;
    que.push(src);
    // 倘若 visited 的点，就不必再次经过了，因为他身上绝不会存在负环。
    // 一旦经过了负环上的点，那么一点按照负环环绕，最短路径必然会大于 n
    int u, v;
    while (que.empty() == false) {
        u = que.front();    que.pop();
        st[u] = false;
        for (int i = h[u]; ~i; i = ne[i]) {
            v = e[i];
            if (visited[v] == true) {   // visited[u] = true, 那么就没必要遍历了
                continue;
            } else {
                if (dist[v] > dist[u] + w[i]) {
                    dist[v] = dist[u] + w[i];
                    cnt[v] = cnt[u] + 1;
                    if (cnt[v] >= n) {  // 出现负环
                        return true;
                    }
                    if (st[v] == false) {
                        st[v] = true;
                        que.push(v);
                    }
                }
            }
        }
    }
 
    // 更新
    for (int i = 1; i <= n; i ++ ) {
        if (dist[i] <= INF / 2) {
            visited[i] = true;
        }
    }
 
    return false;
}
 
int main()
{
    // initialize
    memset(h, -1, sizeof h);
    memset(ne, -1, sizeof ne);
    idx = 0;
 
    // input
    scanf("%d%d", &n, &m);
    int a, b, c;
    while (m -- ) {
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
 
    bool exist_negative_circle = false;
    memset(visited, false, sizeof visited);
    for (int i = 1; i <= n; i ++ ) {
        if (visited[i] == false) {
            // visited[i] = true; 不应该放在这里，应该在 judge_negative_circle 函数后面补充
            if (judge_negative_circle(i)) {
                exist_negative_circle = true;
                break;
            }
        }
    }
 
    if (exist_negative_circle) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
 
    return 0;
}