题解：AcWing 852 SPFA判断负环

【题目来源】

AcWing：852 spfa判断负环 - AcWing题库

【题目描述】

给定一个\(n\)个点\(m\)条边的有向图，图中可能存在重边和自环，边权可能为负数。请你判断图中是否存在负权回路

【输入】

第一行包含整数 \(n\) 和 \(m\)。

接下来\(m\)行每行包含三个整数 \(x,y,z\)，表示存在一条从点\(x\)到点\(y\)的有向边，边长为\(z\)

【输出】

如果图中存在负权回路，则输出Yes，否则输出No。

【输入样例】

【输出样例】

Yes

【核心思想】

问题分析：给定有向图 \(G=(V,E)\)，其中 \(|V|=n\)，\(|E|=m\)，边权可能为负数。需要判断图中是否存在负权回路（即环上所有边权之和为负数的回路）。这是一个图论中的经典判定问题，可以使用 SPFA 算法结合松弛次数统计来解决。
算法选择：
- SPFA 算法判断负环：基于 Bellman-Ford 算法的思想，利用抽屉原理判断负环存在性
- 计数数组 \(cnt[]\)：\(cnt[i]\) 表示从起点到节点 \(i\) 的最短路径上经过的边数（或节点被松弛的次数）
- 抽屉原理：若某个节点被松弛超过 \(n\) 次，说明存在负权回路
- 全源初始化：将所有节点都加入队列，确保能检测到图中任意位置的负环
关键步骤：
- 初始化：
  - 读取 \(n\)（节点数）、\(m\)（边数）
  - 初始化邻接表头数组 \(h[i] = -1\)，边索引 \(idx = 0\)
  - 读入 \(m\) 条边 \((x, y, z)\)，使用 add(x, y, z) 添加到邻接表
  - 初始化距离数组 \(dist[i]\)（可为任意值），计数数组 \(cnt[i] = 0\)
  - 初始化标记数组 \(st[i] = false\)
- 全源入队：将所有节点 \(i\) 从 \(1\) 到 \(n\) 入队，q.push(i)，st[i] = true
- 主循环（当队列非空时循环）：
  - 取出队首：t = q.front()，然后 q.pop()，st[t] = false
  - 松弛邻接边：遍历 \(t\) 的所有邻接边 \((t \to j，权重w)\)：
    - 若 \(dist[j] > dist[t] + w\)，则更新 \(dist[j] = dist[t] + w\)
    - 更新计数：\(cnt[j] = cnt[t] + 1\)
    - 负环判断：若 \(cnt[j] \geq n\)，说明节点 \(j\) 被松弛超过 \(n\) 次，存在负环，返回 true
    - 若 \(j\) 不在队列中，则将 \(j\) 入队 q.push(j)，st[j] = true
- 返回结果：若循环结束未触发负环判断，返回 false
时间/空间复杂度：
- 时间复杂度：\(O(n \cdot m)\)，最坏情况下每个节点都被松弛 \(n\) 次
- 空间复杂度：\(O(n + m)\)，邻接表 \(O(n + m)\)，距离数组、计数数组、标记数组、队列各 \(O(n)\)
- 适用于判断图中是否存在负权回路
SPFA 判断负环的核心思想：
- 抽屉原理：在无负环的图中，最短路径最多包含 \(n-1\) 条边（经过 \(n\) 个节点）。若某个节点被松弛超过 \(n\) 次，说明存在负环使得路径可以无限缩短
- 全源入队策略：由于负环可能不在从节点 \(1\) 出发可达的范围内，因此需要将所有节点都加入队列初始化
- 计数统计：通过 \(cnt[]\) 数组记录每个节点被松弛的次数，超过 \(n\) 次即判定存在负环
- 松弛即更新：只要有距离更新就说明可能存在更短路径，继续松弛检查
- 适用于判断负权回路存在性、差分约束系统无解判定等场景

【解题思路】

【解题思路2】

【算法标签】

SPFA

【代码详解】

#include <bits/stdc++.h>
using namespace std;

// 定义常量
const int N = 2010, M = 10010, INF = 1e9; // N为节点数上限，M为边数上限，INF为无穷大

// 定义图的邻接表表示
int h[N], e[M], w[M], ne[M], idx; // h数组存储每个节点的第一条边的索引，e数组存储边的终点，w数组存储边的权重，ne数组存储下一条边的索引，idx为边的计数器

// 定义SPFA算法所需的数组
int dist[N], cnt[N]; // dist数组存储从起点到每个节点的最短距离，cnt数组存储每个节点入队次数
queue<int> q; // 队列用于BFS
bool st[N]; // st数组标记节点是否在队列中

// 定义节点数和边数
int n, m;

// 添加边的函数
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c; // 设置边的终点和权重
    ne[idx] = h[a], h[a] = idx++; // 更新邻接表
}

// SPFA算法实现
bool spfa() {
    // 初始化所有节点的距离为无穷大，并将所有节点入队
    for (int i = 1; i <= n; i++) {
        q.push(i);
        st[i] = true;
    }
    // 开始BFS
    while (!q.empty()) {
        int nd = q.front(); q.pop(); // 取出队首节点
        st[nd] = false; // 标记该节点已出队
        // 遍历该节点的所有出边
        for (int i = h[nd]; i != -1; i = ne[i]) {
            int j = e[i]; // 边的终点
            // 如果通过当前边可以得到更短的距离，则更新距离并入队
            if (dist[j] > dist[nd] + w[i]) {
                dist[j] = dist[nd] + w[i];
                cnt[j] = cnt[nd] + 1; // 更新入队次数
                // 如果某个节点入队次数超过n次，说明存在负环
                if (cnt[j] >= n) return true;
                // 如果该节点不在队列中，则入队
                if (!st[j]) {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return false; // 未发现负环
}

int main() {
    cin >> n >> m; // 输入节点数和边数
    memset(h, -1, sizeof(h)); // 初始化邻接表
    while (m--) {
        int a, b, c;
        cin >> a >> b >> c; // 输入边的起点、终点和权重
        add(a, b, c); // 添加边
    }
    // 初始化距离数组为无穷大
    memset(dist, INF, sizeof(dist));
    dist[1] = 0; // 起点到起点的距离为0
    // 调用SPFA算法
    if (spfa()) cout << "Yes"; // 存在负环
    else cout << "No"; // 不存在负环
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> PII;  // 虽然定义了但未使用
const int N = 100010;        // 最大顶点数

int n, m;                    // n: 顶点数, m: 边数
int h[N], w[N], e[N], ne[N], idx;  // 链式前向星
int dist[N];                // 最短距离数组
int cnt[N];                 // 记录每个顶点被松弛的次数
bool st[N];                 // 标记顶点是否在队列中

/**
 * 添加有向边
 * @param a 起点
 * @param b 终点
 * @param c 权重
 */
void add(int a, int b, int c)
{
    e[idx] = b;        // 边指向的顶点
    w[idx] = c;        // 边的权重
    ne[idx] = h[a];    // 指向原链表头
    h[a] = idx++;      // 更新头指针
}

/**
 * SPFA算法检测负权环
 * 从所有顶点开始搜索，检测是否存在负权环
 * @return 存在负权环返回true，否则返回false
 */
int spfa()
{
    queue<int> q;  // SPFA队列

    // 将所有顶点入队，确保检测到所有连通分量中的负权环
    for (int i = 1; i <= n; i++)
    {
        st[i] = true;  // 标记在队列中
        q.push(i);     // 顶点入队
    }

    // 这句代码是多余的，因为上面循环已经将st[1]设为true
    st[1] = true;

    // SPFA主循环
    while (q.size())
    {
        int t = q.front();  // 取出队首顶点
        q.pop();
        st[t] = false;      // 标记不在队列中

        // 遍历t的所有邻接边
        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;       // 松弛次数+1

                // 如果顶点j被松弛了n次，说明存在负权环
                if (cnt[j] >= n)
                {
                    return true;  // 存在负权环
                }

                // 如果j不在队列中，入队
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;  // 不存在负权环
}

int main()
{
    // 输入顶点数和边数
    scanf("%d%d", &n, &m);

    // 初始化邻接表
    memset(h, -1, sizeof(h));

    // 读入边
    while (m--)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);  // 添加有向边
    }

    // 检测负权环并输出结果
    if (spfa())
    {
        puts("Yes");
    }
    else
    {
        puts("No");
    }

    return 0;
}

【运行结果】

posted @ 2026-06-27 14:20 团爸讲算法阅读(7) 评论(0) 收藏举报

刷新页面返回顶部

题解：AcWing 852 SPFA判断负环

SPFA

公告