负环

最新推荐文章于 2022-06-18 11:50:43 发布
最新推荐文章于 2022-06-18 11:50:43 发布
阅读量552 收藏 5
点赞数
分类专栏： 算法 文章标签： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42638946/article/details/115284508
版权

负环

1. 负环原理

原理

  • 求解图中的负环，是基于spfa算法（n表示图中顶点数）:

（1）统计每个点入队的次数，如果某个点入队n次，则说明存在负环；

（2）统计当前每个点的最短路中所包含的边数，如果某点的最短路径所包含的边数大于等于n，则说明存在负环。

  • 对于（1）来说，因为spfa算法是基于bellmanford算法改进来的，对于bellmanford算法来说，如果迭代了n此之后还有节点被更新的话，说明存在负环；对应到spfa算法来说，某个点每入队一次，则说明其被更新了一次，因此如果某个点入队大于等于n次，则说明其被更新了大于等于n次，说明存在负环。
  • 对于（2）来说，如果某点的最短路径所包含的边数大于等于n，则说明这条路径中至少存在n+1个点，因为只有n个点，根据抽屉原理，必定有两个节点相同，因为只有距离变小时才会更新，因此存在负环。
  • 上面的两种方法最常用的是（2）。原因如下：

在这里插入图片描述

  • spfa算法：

在这里插入图片描述

  • spfa求负环：

在这里插入图片描述

  • spfa算法求负环，有时候可能时间复杂度接近 O ( n × m ) O(n\times m) O(n×m)，会超时，对于方法（2）这里有一个技巧：当所有的点入队的次数超过2n（或者3n）时，我们就认为图中有很大可能是存在负环的。

代码模板

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int N = 2010, M = 10010;

int n, m;
int h[N], w[M], e[M], ne[M], idx;
int dist[N], cnt[N];  // cnt[i]表示到虚拟源点的距离-1
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 spfa() {
    
    queue<int> q;
    for (int i = 1; i <= n; i++) {  // 相当于有一个虚拟源点，所有的点都要加入
        q.push(i);
        st[i] = true;
    }
    
    while (q.size()) {
        
        int t = q.front(); q.pop();
        st[t] = false;
        
        for (int i = h[t]; ~i; 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;
                if (!st[j]) {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
}

int main() {
    
    scanf("%d%d", &n, &m);
    
    memset(h, -1, sizeof h);
    
    for (int i = 0; i < m; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    
    if (spfa()) puts("Yes");
    else puts("No");
    
    return 0;
}

2. AcWing上的负环题目

AcWing 904. 虫洞

问题描述

分析

  • 本题有多组数据。
  • 农田代表图中的点，路径代表双向边（其上的权值为正），虫洞代表单向边（其上的权值为负）。因此本问题就可以转换成：该图中是否存在负环？
  • 直接使用spfa算法求解即可。

代码

  • C++
#include <iostream>
#include <cstring>

using namespace std;

const int N = 510, M = 5210;

int n, m, k;  // n:顶点数; m:双向边数; k:单向边数
int h[N], e[M], w[M], ne[M], idx;
int dist[N], cnt[N];
int q[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 spfa() {
    
    // dist初始值无所谓
    // st最终在队列为空时也会全部变为false
    memset(cnt, 0, sizeof cnt);
    
    int hh = 0, tt = 0;
    for (int i = 1; i <= n; i++) {
        q[tt++] = i;
        st[i] = true;
    }
    
    while (hh != tt) {
        
        int t = q[hh++];
        if (hh == N) hh = 0;
        
        st[t] = false;
        
        for (int i = h[t]; ~i; 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;
                if (!st[j]) {
                    q[tt++] = j;
                    if (tt == N) tt = 0;
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
}

int main() {
    
    int T;
    cin >> T;
    while (T--) {
        
        memset(h, -1, sizeof h);
        idx = 0;
        
        cin >> n >> m >> k;
        while (m--) {
            int a, b, c;
            cin >> a >> b >> c;
            add(a, b, c), add(b, a, c);
        }
        while (k--) {
            int a, b, c;
            cin >> a >> b >> c;
            add(a, b, -c);
        }
        
        if (spfa()) puts("YES");
        else puts("NO");
    }
    
    return 0;
}

AcWing 361. 观光奶牛

问题描述

分析

  • 分析题目可知，此题让我们求解一个环，使得

∑ f i ∑ t i \frac{\sum f_i}{\sum t_i} ∑ti​∑fi​​

取得最大值。

  • 所有形如这样的问题，有一个统一的名称：01分数规划。这样的问题一般都可以采用二分来解决。
  • 针对本题，因为 1 ≤ f [ i ] , t [ i ] ≤ 1000 1\le f[i],t[i] \le 1000 1≤f[i],t[i]≤1000，所以答案所在的范围是：(0, 1000]，可以对该区间进行二分。
  • 对于区间[l, r]以及mid=(l + r) / 2，如果有

∑ f i ∑ t i > m i d f i 是 环 上 的 点 的 权 值 ， t i 是 环 上 边 的 权 值 \frac{\sum f_i}{\sum t_i} > mid \quad f_i是环上的点的权值，t_i是环上边的权值 ∑ti​∑fi​​>midfi​是环上的点的权值，ti​是环上边的权值

则说明答案在[mid, r]之间，否则答案在[l, mid]之间，接着二分即可。

  • 对上面的不等式进行变形：

∑ f i ∑ t i > m i d ∑ f i − m i d × ∑ t i > 0 ∑ ( f i − m i d × t i ) > 0 \frac{\sum f_i}{\sum t_i} > mid \\ \sum f_i - mid \times \sum t_i > 0 \\ \sum (f_i-mid \times t_i) > 0 ∑ti​∑fi​​>mid∑fi​−mid×∑ti​>0∑(fi​−mid×ti​)>0

  • 根据上面的变形，我们可以将点上的权值变到出边上去，即每条边的权值变为 f i − m i d × t i f_i-mid \times t_i fi​−mid×ti​，这样方便我们处理。
  • 在变换边权之后，最终问题就转化成了：图中是否存在正环。
  • 那么如何求解正环呢？可以将所有的边权取个反，问题就变成了是否存在负环；但是实际上我们不需要这样做，我们只需要求最长路径即可。

在这里插入图片描述

代码

  • C++
#include <iostream>
#include <cstring>

using namespace std;

const int N = 1010, M = 5010;

int n, m;
int wf[N];  // 每个点的权值
int h[N], e[M], wt[M], ne[M], idx;
double dist[N];
int cnt[N];  // cnt[i]表示到达i的最长路径经过的边数
int q[N];  // 循环队列
bool st[N];  // 代表点是否在队列中

void add(int a, int b, int c) {
    e[idx] = b, wt[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

bool check(double mid) {
    
    // 该函数会被调用多次，因此需要初始化cnt
    memset(cnt, 0, sizeof cnt);
    // dist不需要初始化，因为存在正环的话，到达该点的距离会被更新为+∞
    // st不需要初始化，因为最终队列为空，st的值会全部变为false
    
    int hh = 0, tt = 0;
    for (int i = 1; i <= n; i++) {
        q[tt++] = i;
        st[i] = true;
    }
    
    while (hh != tt) {
        
        int t = q[hh++];
        if (hh == N) hh = 0;
        
        st[t] = false;
        
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] < dist[t] + wf[t] - mid * wt[i]) {  // 求负环这里是>
                dist[j] = dist[t] + wf[t] - mid * wt[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;
                if (!st[j]) {
                    q[tt++] = j;
                    if (tt == N) tt = 0;
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
}

int main() {
    
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> wf[i];
    
    memset(h, -1, sizeof h);
    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    double l = 0, r = 1010;
    while (r - l > 1e-4) {
        double mid = (l + r) / 2;
        if (check(mid)) l = mid;
        else r = mid;
    }
    
    printf("%.2lf\n", l);
    
    return 0;
}

AcWing 1165. 单词环

问题描述

分析

  • （1）首先我们需要考虑如何建图：一种直观的建图方式是顶点是各个字符串，如果字符串s2能接在s1的后面，那么连一条从s1指向s2的边。这样的话图中顶点的个数最多有 1 0 5 10^5 105个，可能是完全图，因此边的数量在 1 0 10 10^{10} 1010量级，会超时，因此这样的建图方式不可取。

  • 我们换一种建图的方式：顶点表示一个字符串的前两个字母或者后两个字母，边表示字符串的长度。相当于将上面一种建图方式中的顶点变成了边，边变成了顶点。这样的话，图中顶点的个数为676（ 26 × 26 26\times 26 26×26），边数最多 1 0 5 10^5 105个。

  • （2）另外我们还需要考虑一个问题，如何使得

∑ w i ∑ s i w i 表 示 环 上 字 符 串 长 度 ， s i 恒 为 1 \frac{\sum w_i}{\sum s_i} \quad w_i表示环上字符串长度，s_i恒为1 ∑si​∑wi​​wi​表示环上字符串长度，si​恒为1

最大。我们可以使用和上一题一样的思路：01分数规划，使用二分解决。

  • 针对本题，因为 1 ≤ w [ i ] ≤ 1000 1\le w[i] \le 1000 1≤w[i]≤1000，所以答案所在的范围是：(0, 1000]，可以对该区间进行二分。
  • 对于区间[l, r]以及mid=(l + r) / 2，如果有

∑ w i ∑ 1 > m i d \frac{\sum w_i}{\sum 1} > mid ∑1∑wi​​>mid

则说明答案在[mid, r]之间，否则答案在[l, mid]之间，接着二分即可。

  • 对上面的不等式进行变形：

∑ w i ∑ 1 > m i d ∑ w i − m i d × ∑ 1 > 0 ∑ ( w i − m i d × 1 ) > 0 \frac{\sum w_i}{\sum 1} > mid \\ \sum w_i - mid \times \sum 1 > 0 \\ \sum (w_i-mid \times 1) > 0 ∑1∑wi​​>mid∑wi​−mid×∑1>0∑(wi​−mid×1)>0

  • 根据上面的变形，每条边的权值变为 w i − m i d w_i-mid wi​−mid，在变换边权之后，最终问题就转化成了：图中是否存在正环。
  • 那么如何求解正环呢？可以将所有的边权取个反，问题就变成了是否存在负环；但是实际上我们不需要这样做，我们只需要求最长路径即可。
  • （3）另外题目可能没有解，如何判断这种情况呢？对于改变后的边权 w i − m i d w_i-mid wi​−mid，这个值越大，越有可能有正环，如果mid取0时都没有正环，则说明没有解。特判一下即可，我们可以使用AcWing 361. 观光奶牛的做法解决这个问题。
  • （4）如果单纯使用AcWing 361. 观光奶牛方法解决这个问题，会超时（TLE），因此需要使用上面原理中提到的技巧：当所有的点入队的次数超过2n（或者3n）时，我们就认为图中有很大可能是存在负环的。但是注意：本题的点数太少，不到700，但是边数非常多，最多有10000条，所以经验值不适用了，需要取一个更大的值。
  • 另外对于求负环的问题，如果超时的话，我们还可以尝试将队列改为栈，有可能更快找到这个环，这样一般都是能解决TLE问题的。

代码

  • C++
#include <iostream>
#include <cstring>

using namespace std;

const int N = 700, M = 100010;

int n;  // 图中边数，有多少字符串就有多少条有向边
int h[N], e[M], w[M], ne[M], idx;
double dist[N];
int cnt[N];  // cnt[i]表示到达i的最长路径经过的边数
int q[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 check(double mid) {
    
    memset(cnt, 0, sizeof cnt);
    
    int hh = 0, tt = 0;
    for (int i = 0; i < 26 * 26; i++) {
        q[tt++] = i;
        st[i] = true;
    }
    
    int count = 0;
    while (hh != tt) {
        
        int t = q[hh++];
        if (hh == N) hh = 0;
        
        st[t] = false;
        
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] < dist[t] + w[i] - mid) {
                dist[j] = dist[t] + w[i] - mid;
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= N) return true;  // n是边数，N才是点数
                
                if (++count > N * 10) return true;  // 经验上的trick
                
                if (!st[j]) {
                    q[tt++] = j;
                    if (tt == N) tt = 0;
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
}

int main() {
    
    char str[1010];
    while (scanf("%d", &n), n) {
        
        memset(h, -1, sizeof h);
        idx = 0;
        for (int i = 0; i < n; i++) {
            scanf("%s", str);
            int c = strlen(str);
            if (c >= 2) {
                int a = (str[0] - 'a') * 26 + str[1] - 'a';
                int b = (str[c - 2] - 'a') * 26 + str[c - 1] - 'a';
                add(a, b, c);
            }
        }
        
        if (!check(0)) puts("No solution");
        else {
            double l = 0, r = 1000;
            while (r - l > 1e-4) {
                double mid = (l + r) / 2;
                if (check(mid)) l = mid;
                else r = mid;
            }
            
            printf("%lf\n", r);
        }
    }
    
    return 0;
}

#include <iostream>
#include <cstring>

using namespace std;

const int N = 700, M = 100010;

int n;  // 图中边数，有多少字符串就有多少条有向边
int h[N], e[M], w[M], ne[M], idx;
double dist[N];
int cnt[N];  // cnt[i]表示到达i的最长路径经过的边数
int stk[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 check(double mid) {
    
    memset(cnt, 0, sizeof cnt);
    
    int tt = 0;
    for (int i = 0; i < 26 * 26; i++) {
        stk[++tt] = i;
        st[i] = true;
    }
    
    while (tt > 0) {  // 此时tt指向栈顶元素
        
        int t = stk[tt--];
        
        st[t] = false;
        
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] < dist[t] + w[i] - mid) {
                dist[j] = dist[t] + w[i] - mid;
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= N) return true;  // n是边数，N才是点数
                
                if (!st[j]) {
                    stk[++tt] = j;
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
}

int main() {
    
    char str[1010];
    while (scanf("%d", &n), n) {
        
        memset(h, -1, sizeof h);
        idx = 0;
        for (int i = 0; i < n; i++) {
            scanf("%s", str);
            int c = strlen(str);
            if (c >= 2) {
                int a = (str[0] - 'a') * 26 + str[1] - 'a';
                int b = (str[c - 2] - 'a') * 26 + str[c - 1] - 'a';
                add(a, b, c);
            }
        }
        
        if (!check(0)) puts("No solution");
        else {
            double l = 0, r = 1000;
            while (r - l > 1e-4) {
                double mid = (l + r) / 2;
                if (check(mid)) l = mid;
                else r = mid;
            }
            
            printf("%lf\n", r);
        }
    }
    
    return 0;
}
你好世界wxx
关注
专栏目录
【图论】负环
gzkeylucky的博客
07-27 659
求最短路径的时候可能会出现环状、边权为负数的情况，特别拿出来学习
图论学习-负环
麒麟001号的博客
03-03 1744
文章目录一、负环 acwing提高课正好看到负环，干脆写篇博客记录一下。 一、负环 定义：环中所有边权值和为负数的环，称为负环 负环可以有两种求法：bellman_ford和spfa spfa是对bellman_ford的优化，一般是用spfa求负环 时间复杂度最好O(m),最坏O(km) 给出判负环的两种方法： (1) 统计每个点入队次数，如果某个点入队n次，说明存在n条边的路径，那么必然有n+1个点，则存在负环 (2) 只要某个点最短路所含的边数大于等于n，说明至少n+1个点，则存在负环 注意：
判断负环算法
qq_41729237的博客
07-17 1151
负环的定义 负环是指权值和为负数的环。负环会使图的最短路径计算陷入死循环，因此，存在负环的图不存在最短路。 负环的计算方法： 负环有两种计算方法，都是基于Bellman-Ford算法或者SPFA算法。 第一种算法是：统计每个点的入队次数，如果某个点入队大于等于n次，则说明有负环 第二种算法是：统计到某个点的最短路所经过点的个数，如果经过n个点，则说明存在负环。 ...
负环与差分约束
m0_49959202的博客
09-21 392
文章目录负环与差分约束1. 基本概念、方法1.1 负环1.1.1 spfa 判负环/正环1.1.2 tarjan+缩点 判断正环/负环1.1.3 拓扑排序 判断正环/负环1.2 差分约束2. 例题2.1 负环/正环判定2.1.1 spfa判断负环/正环2.1.2 tarjan求scc+缩点判断正环/负环2.1.3 拓扑排序判断正环/负环2.2 差分约束2.2.1 spfa差分约束2.2.2 tarjan求scc + 缩点 + dp 差分约束2.2.3 拓扑排序 差分约束 负环与差分约束 1. 基本概念、方法
spfa算法求负环
Lucas_FC_的博客
06-18 409
 传送门：P3305[模板]负环 负环的定义是：一条边权之和为负数的回路。 一个含有负环的图是一定没有最短路的，因为一旦有负环则在求最短路的时候回陷在负环中而无法自拔。  所以，若图中没有负环，则最多经过n-1轮迭代后算法结束。若第n轮迭代仍有结点的最短路能被更新，则图中有负环。  所以我们用 cnt[x] 表示1到x的最短路包含的边数（该题要求以1作为源点），cnt[1]=0。每次用 dis[x]+w(x,y) 更新dis[y]时，也是cnt[x]+1更新 cnt[y]。此过程中若出现cnt[y]≥n，则
【日志】负环 差分约束
本居小铃的博客
01-11 232
文章目录负环差分约束题目 P3275 [SCOI2011]糖果 负环 如果图中存在权值为负的边，且产生了一个环，环上各边的权值和为负值，那么这个环就成为了负环。一旦图中存在负环，那么将会导致一遍又一遍地更新最短路。 Dijkstra算法不可以用于判断负环（其实图里面有负值边的都不可以用，因为松弛dist的时候负值边会导致dist可能不是最小），可以用Bellman-Ford或者队列优化的Bellman-Ford（SPFA）判断负环。 vector<vector<PII>>g; vec
4773: 负环
CRZbulabula的博客
04-04 736
4773: 负环 Time Limit: 100 Sec  Memory Limit: 256 MB Submit: 209  Solved: 105 [Submit][Status][Discuss] Description 在忘记考虑负环之后，黎瑟的算法又出错了。对于边带权的有向图 G = (V, E)，请找出一个点数最小的环，使得 环上的边权和为负数。保证图中不包含重边和
判断负环的方法。
永远鲜红の幼月的博客
02-02 3713
判断负环，也是一个小知识点了，之前一直比较迷，现在总结一下，再加一些板子，以后直接用了就。 判断负环，最常用的就是bellman-floy和spfa，暴力枚举/奇怪的贪心/超神搜索，这些算法了，但是因为要一般性，那些玄学算法就是放弃吧（难道真实原因不是非洲人没有玄学算法吗 Bellman-ford 两个神仙提出来的算法，据说一个好像还是动态规划的发明者（真神仙）， 这个算法的思路就是，从源...
负环详解
weixin_30340617的博客
08-16 1517
什么是负环？ 顾名思义，就是一个所有边的边权和为负数的环 出现负环会怎么样？ 我们知道，一般情况下，图上的最短路都是确定的。但是一旦图上有一个负环，\(s\)到\(t\)的最短路就会不远千里的去覆盖上这个环（只要能够到达），并且不厌其烦的走上一遍又一遍。由于负环的边权和是负的，并且它是一个环，也就是说走一遍和走无数遍都停留在进入的那个点。那么最短路每经过一次这个负环，这个费用都会缩小一点...
求负环-基于SPFA算法
qq_45766916的博客
03-02 438
一般情况下，我们用第二种。 在第一种中，如果有一个点入队n次，代表这个点被更新了n次。 负环: 一个有向图/无向图中 环路的边权和<0 因为是一个环,所以可以循环无限次,那么这些环上的点的距离就会变成-∞ 求负环: 基于spfa spfa 每入队一次 就相当于更新一次 如果入队>=n次 在bellman_ford中 每更新一次 最短距离变小 但一个点的最短距离不可能变小n次 1 统计每个点入队的次数 如果某个点入队n次 说明存在负环 ←o ↓ ↑ o→o→o…o→o 总共n个点,则对于点i到.
负环判断（SPFA）
jkchen's Haven
02-19 868
原题： https://www.luogu.org/problemnew/show/P3385 题意： n个点，m条边，判断是否存在负环。(输出YE5不是YES，N0不是NO) 解析： 这个题目真的是累，网上也没多少正确的题解，说的一些我都懂，但是时间复杂度不优秀。在洛谷和csdn上找了好久。真的是，洛谷时间复杂度前几的只有两种算法。第一种：百来行的建树做的，很优秀but看不懂；第二种：speci...
spfa判断负环
12-05 523
spfa判断负环 给出T组数据，其中有一个n点m边的图，问每个数据是否存在负环。N,M,|w|≤200 000。 spfa如何判断负环呢？只要枚举每一个点，然后dfs/bfs更新即可，具体看代码。 它的基本思想是：如果找到一个点x，能更新自己，那么就存在负环。然而有这样一种情况：由于\(dis+v<dis\)才能更新的限制，可能点X更新到Y就卡住，然后放弃更新了。那么这种情况是...
wormholes（判断负环）
nlp180720的博客
07-31 458
Time Limit: 2000ms Memory Limit: 65536KB 64-bit integer IO format: %lld      Java class name: Main While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormho...
[模板] 判负环
weixin_34314962的博客
04-10 112
之前判负环只会SPFA记录访问次数那种naive做法，交上去基本都是TLE的。 原来单纯判负环是由更好的算法的。 记不清在哪里看到过 ，单判负环优先队列比队列快（？！），试了一下，T到飞起。 把BFS改成DFS，直觉上也能明晰地感觉到可以更快地“接近”负环。 UPD:被特殊数据卡成傻子了 //Stay foolish,stay hungry,stay young,stay simple ...
bellmanford算法求负环
最新发布
07-20
Bellman-Ford算法可以用于检测图中是否存在负环。负环是指图中存在一个环，其权重之和为负数。下面是使用Bellman-Ford算法求解负环的步骤： 1. 初始化距离数组dist[]，将源节点的距离设置为0，其他节点的距离设置为正无穷大。 2. 对于图中的每条边(u, v, w)，按照边的顺序进行松弛操作。松弛操作即尝试通过边(u, v)缩短从源节点到节点v的路径长度。如果dist[u] + w < dist[v]，则更新dist[v]为dist[u] + w。 3. 重复执行步骤2，直到没有边可以进行松弛操作。 4. 再次遍历图中的每条边(u, v, w)，如果dist[u] + w < dist[v]，则存在负环。 如果Bellman-Ford算法执行了n-1轮松弛操作后，仍然存在可以进行松弛操作的边，则说明图中存在负环。这是因为在最短路径中，任何一个节点的最短路径长度最多经过n-1条边。 需要注意的是，Bellman-Ford算法的时间复杂度为O(V*E)，其中V是节点数，E是边数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值