AcWing算法提高课----图论 笔记 （SPFA找负环）

最新推荐文章于 2022-09-27 12:12:08 发布
最新推荐文章于 2022-09-27 12:12:08 发布
阅读量384 收藏 1
点赞数
分类专栏： 算法学习笔记 AcWing
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45830025/article/details/119724768
版权

SPFA找负环

知识点讲解

负环：在一个有向（无向）图当中， 存在一个环路，使得这个环的边权之和小于0

求负环常见方法（基于SPFA、抽屉原理）：

  1. 统计每个点入队的次数，如果某个点入队n次，则说明存在负环（等价于bellman-Ford）
  2. 统计当前每个点的最短路中所包含的边数，如果某点的最短路所包含的边数大于等于n，则也说明存在负环（推荐）
    在这里插入图片描述
    2优于1的原因，若上图环中2的方法O(n)，1的方法O(n^2)

图中负环不一定从起点走到，可以在图中任意一个位置

若有一下图
1 2->3->4->2(负环)
方法：
将所有点入队，同时dist[i]=0，然后用第二方法判断
Q1:为什么等价于将所有点入队
A1:虚拟源点技巧。假想一个虚拟源点，虚拟源点向原图中的每个点连一条距离为0的边，若原图中存在负环，等价于新图中存在负环，新图中所有负环都可以走到。若存在负环，则证明有某些点距离虚拟源点的距离是-∞。
Q2:为什么可以讲距离初始化为0

当SPFA效率比较低的时候，可以认为存在负环（trick）
当所有点的入队次数超过2n时，我们就认为图中有很大可能是存在负环的（不一定对，若超时可以一试，某些题目有效）

例题1：AcWing904.虫洞

#include <iostream>
#include <algorithm>
#include<bits/stdc++.h>
#define ll long long
#define mem(a,b) memset(a,b,sizeof a)
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define rep(i,a,b) for(auto i=a;i<=b;++i)
#define bep(i,a,b) for(auto i=a;i>=b;--i)
#define lowbit(x) x&(-x)
#define PII pair<int,int>
#define x first
#define y second
#define PLL pair<ll,ll>
#define PI acos(-1)
#define pb push_back
#define eb emplace_back
const double eps = 1e-6;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const int N = 555;
const int M = 5555;
int dx[]={-1, 0, 1, 0};
int dy[]={0, 1, 0, -1};
using namespace std;

int n,m1,m2;  //m1,m2分别表示双项边、虫洞的数量
int h[N],e[M],w[M],ne[M],idx;  //邻接表
int dist[N];  //距离
int q[N],cnt[N];  //队列，每个点当前最短路径的长度,所有最短路包含的边数
bool st[N]; //判重数组

void add(int u,int v,int k){
    e[idx]=v,w[idx]=k,ne[idx]=h[u],h[u]=idx++;
}

bool SPFA(){
    int hh=0,tt=0;
    mem(dist,0);  //可以删掉 初值可以为任意值
    mem(st,0);
    mem(cnt,0);
    for(int i=1;i<=n;i++){  //所有点入队
        q[tt++]=i;
        st[i]=1;
    }
    while(hh!=tt){  //队列不空取点
        int t=q[hh++];
        if(hh==N) hh=0;  //判断是否到达终点，走到终点需要还原
        st[t]=0;  //出队标记
        for(int i=h[t];~i;i=ne[i]){ //枚举当前的临边
            int j=e[i];  //j当前点的编号
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n) return 1;
                if(!st[j]){
                    q[tt++]=j;
                    if(tt==N) tt=0;
                    st[j]=1;
                } 
            }
        }
    }
    return 0;
}

inline void solve(){
    cin>>n>>m1>>m2;
    mem(h,-1);
    idx=0;
    while(m1--){
        int u,v,k;
        cin>>u>>v>>k;
        add(u,v,k);
        add(v,u,k);
    }
    while(m2--){
        int u,v,k;
        cin>>u>>v>>k;
        add(u,v,-k);
    }
    if(SPFA()) cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t=1;
    cin>>t;
    while(t--) solve();
    return 0;
}

01分数规划

01分数规划是这样的一类问题，有一堆物品，每一个物品有一个收益ai，一个代价bi，我们要求一个方案使选择的∑ai/∑bi最大

找到一个环，使得环上所有的点权之和∑fi/所有边权之和∑ti，使得∑fi/∑ti
最大 --> 01分数规划

二分方法

点权放在初边上

∑(fi - mid*ti) >0 <—> 图中是否存在正环

在这里插入图片描述
求最短路改成求最长路
二分出一个定值->整理表达式->重新定义边权->图论算法

例题2：AcWing361.观光奶牛

答案：

#include <iostream>
#include <algorithm>
#include<bits/stdc++.h>
#define ll long long
#define mem(a,b) memset(a,b,sizeof a)
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define rep(i,a,b) for(auto i=a;i<=b;++i)
#define bep(i,a,b) for(auto i=a;i>=b;--i)
#define lowbit(x) x&(-x)
#define PII pair<int,int>
#define x first
#define y second
#define PLL pair<ll,ll>
#define PI acos(-1)
#define pb push_back
#define eb emplace_back
const double eps = 1e-6;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const int N = 1111;
const int M = 5555;
int dx[]={-1, 0, 1, 0};
int dy[]={0, 1, 0, -1};
using namespace std;

int n,m;
int wf[N];
int h[N],e[M],wt[M],ne[M],idx;  //邻接表
double dist[N];  //距离
int q[N],cnt[N];  //队列，每个点当前最短路径的长度,所有最短路包含的边数
bool st[N]; //判重数组

void add(int u,int v,int w){
    e[idx]=v,wt[idx]=w,ne[idx]=h[u],h[u]=idx++;
}

bool judge(double mid){
    int hh=0,tt=0;
    //mem(dist,0);
    mem(st,0);
    mem(cnt,0);
    for(int i=1;i<=n;i++){  //所有点入队
        q[tt++]=i;
        st[i]=1;
    }
    while(hh!=tt){  //队列不空取点
        int t=q[hh++];
        if(hh==N) hh=0;  //判断是否到达终点，走到终点需要还原
        st[t]=0;  //出队标记
        for(int i=h[t];~i;i=ne[i]){ //枚举当前的临边
            int j=e[i];  //j当前点的编号
            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 1;
                if(!st[j]){
                    q[tt++]=j;
                    if(tt==N) tt=0;
                    st[j]=1;
                } 
            }
        }
    }
    return 0;
}

inline void solve(){
    cin>>n>>m;
    mem(h,-1);
    idx=0;
    rep(i,1,n) cin>>wf[i];
    while(m--){
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);
        //add(v,u,k);
    }
    double l=0,r=1000;
    while(r-l>1e-4){
        double mid=(l+r)/2;
        if(judge(mid)) l=mid;
        else r=mid;
    }
    cout<<fixed<<setprecision(2)<<r<<endl;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--) solve();
    return 0;
}

例题3：AcWing1165.单词环

  • Q:
    • a.建图
    • b.01分数规划
    • c.数据量大、优化

建图方式：
把字符串看成边 e.g. ababc -》 ab->ba(5)
在这里插入图片描述

答案：

#include <iostream>
#include <algorithm>
#include<bits/stdc++.h>
#define ll long long
#define mem(a,b) memset(a,b,sizeof a)
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define rep(i,a,b) for(auto i=a;i<=b;++i)
#define bep(i,a,b) for(auto i=a;i>=b;--i)
#define lowbit(x) x&(-x)
#define PII pair<int,int>
#define x first
#define y second
#define PLL pair<ll,ll>
#define PI acos(-1)
#define pb push_back
#define eb emplace_back
const double eps = 1e-6;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const int N = 700;
const int M = 1e5 + 10;
int dx[]={-1, 0, 1, 0};
int dy[]={0, 1, 0, -1};
using namespace std;

int n,m;
int wf[N];
int h[N],e[M],wt[M],ne[M],idx;  //邻接表
double dist[N];  //距离
int q[N],cnt[N];  //队列，每个点当前最短路径的长度,所有最短路包含的边数
bool st[N]; //判重数组

void add(int u,int v,int w){
    e[idx]=v,wt[idx]=w,ne[idx]=h[u],h[u]=idx++;
}

bool judge(double mid){
    int hh=0,tt=0;
    //mem(dist,0);
    mem(st,0);
    mem(cnt,0);
    for(int i=0;i<676;i++){  //所有点入队
        q[tt++]=i;
        st[i]=1;
    }
    int tot=0;
    while(hh!=tt){  //队列不空取点
        int t=q[hh++];
        if(hh==N) hh=0;  //判断是否到达终点，走到终点需要还原
        st[t]=0;  //出队标记
        for(int i=h[t];~i;i=ne[i]){ //枚举当前的临边
            int j=e[i];  //j当前点的编号
            if(dist[j]<dist[t]+wt[i]-mid){
                dist[j]=dist[t]+wt[i]-mid;
                cnt[j]=cnt[t]+1;
                if(++tot>2*n) return 1;
                if(cnt[j]>=N) return 1;
                if(!st[j]){
                    q[tt++]=j;
                    if(tt==N) tt=0;
                    st[j]=1;
                } 
            }
        }
    }
    return 0;
}

inline void solve(){
    char s[1111];
    while(cin>>n&&n){
        mem(h,-1);
        rep(i,1,n){
            cin>>s;
            //cout<<s<<endl;
            int len=strlen(s);
            if(len>=2){
                int l=(s[0]-'a')*26+s[1]-'a';
                int r=(s[len-2]-'a')*26+s[len-1]-'a';
                add(l,r,len);
            }
        }
        if(!judge(0)) cout<<"No solution"<<endl;
        else{
            double l=0,r=1000;
            while(r-l>1e-4){
                double mid=(l+r)/2;
                if(judge(mid)) l=mid;
                else r=mid;
            }
            cout<<r<<endl;
        }
    }
    //cout<<fixed<<setprecision(2)<<r<<endl;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--) solve();
    return 0;
}

经验上的trick可以换成另一种方式 把spfa中的栈换成队列,一定对蛋效率不稳,不过有负环时效果很好
上述judge变换
在这里插入图片描述

彡倾灬染|
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论——负环
qq_53504307的博客
05-18 424
图论——负环 笔记： 1： 通用算法：SPFA O(m)O(m)O(m)~O(nm)O(nm)O(nm) 2： 如何判断负环？有222种方法，第111种是 Bellman-ford 判负环方法，每入队一次相当于更新一次，当入队次数 >=n>=n>=n 时 确定存在负环 ，时间复杂度 O(n2)O(n^2)O(n2) 太慢 。第222种是常用方法时间复杂度是 O(n2)O(n^2)O(n2) 统计每个点所在的最短路中边的条数。一旦边的条数 >=n>=n>=n时说明至少存在
找负环（图论基础）
weixin_61426225的博客
02-15 1519
实际上两种方法是等价的，都是判断是否路径包含n条边，用的更多的还是第二种方法。环内路径上的权值和为负。所经过的最短路径的边数。
【ACWing】1165. 单词环
数学、算法爱好者的博客
04-26 359
题目地址： https://www.acwing.com/problem/content/1167/ 我们有nnn个字符串，每个字符串都是由a∼za∼za∼z的小写英文字母组成的。如果字符串AAA的结尾两个字符刚好与字符串BBB的开头两个字符相匹配，那么我们称AAA与BBB能够相连（注意：AAA能与BBB相连不代表BBB能与AAA相连）。我们希望从给定的字符串中找出一些，使得它们首尾相连形成一个环串（一个串首尾相连也算），我们想要使这个环串的平均长度最大。如下例： ababc bckjaca caahoyn
算法提高课-图论-负环-AcWing 904. 虫洞：spfa求负环裸题
阿正的梦工坊
04-07 235
刷题
负环——spfa判断负环的两种方式
测试
09-27 1545
统计当前每个点的最短路的边数，如果存在负环，负环上的某一个点的最短路边数一定会是正无穷，只要边数超过n(节点数)，就可以判断存在负环。图并不是全部连通，存在单独一个点没有入度和出度。这时候就不能只从某一个点进去找，有可能根本更新不到其他点。统计每个点的入队次数，如果某一个点入队了n次，则说明存在负环。但以上这个方法被硬卡数据有可能超市，可以尝试。这时候可以假设一个虚拟源点与所有的点都相连，并且距离为零。一次把所有点入队，后续更新就可以检测出负环。
算法刷题提高阶段-图论7
12-24
"算法刷题提高阶段-图论7"的主题很可能聚焦于图论中的一个关键算法——SPFA（Shortest Path Faster Algorithm）寻找负权环。 SPFA算法是一种用于解决单源最短路径问题的算法，尤其适用于存在负权重边的情况。与...
算法刷题提高阶段-图论2
12-24
除了上述算法，还有其他一些方法，如**SPFA（Shortest Path Faster Algorithm）**，虽然它不是一种普适的算法，但在某些情况下（如稀疏图）表现优秀，但可能会有负权边的问题。 在实际编程挑战或面试中，理解并掌握...
算法刷题提高阶段-图论1
12-24
若存在负权环，则该算法会检测到并报告。 3. **Floyd-Warshall算法**：Floyd-Warshall算法是动态规划的一种应用，用于求解所有顶点对之间的最短路径。它通过不断尝试所有可能的中间顶点来更新路径长度，最终得到一...
蓝桥杯CJ2-11-图论最短路径问题 Bellman-Ford算法+SPFA.pdf
最新发布
02-18
蓝桥杯CJ2-11-图论最短路径问题 Bellman-Ford算法+SPFA.pdf
图论- 最短路- Bellman-Ford 算法与 SPFA.rar
09-16
SPFA的优点是它可以在大多数情况下比Bellman-Ford算法更快地找到最短路径，但无法保证严格正确性，特别是对于含有负权环的图。此外，其时间复杂度难以准确预估，但在实际应用中通常比Bellman-Ford更快。 这两种算法...
负环 —— SPFA扩展
weixin_45724872的博客
02-22 412
负环的定义 在有向图或无向图中，存在一个环，权值之和为负数； 那么按常规最短路，就会无限在这上面更新了，也就是使得dist(u)=−INFdist(u) = -INFdist(u)=−INF 负环的问题最经常结合01分数规划； 方法 建议使用第二种方法，一般来说，方法二跑的比较快； 方法一解释 这个方法是由Bellman−FordBellman-FordBellman−Ford扩展过来的； BF算法告诉我们，如果我们迭代了nnn次，还有节点没更新，那么说明存在负环； 而我们的SPFA是基于BF算法的，在
3.4 SPFA找负环
esjiang的博客
03-08 497
负环 有向图或者无向图中, 存在环路, 使得一圈的权值之和 < 0, 称为负环 负环为什么要单独处理, 比如最短路中, 如果一个点能走到负环上, 那么就能在这个点上转无穷多次, 每转1次, 距离就会小一点, 因此图形中, 某些点的最短路就会变成−∞-\infty−∞, 会影响最短路算法的正确性 求负环的常用方法, 基于SPFA (1) : 统计每个点入队的次数, 如果某个点入队n次, 说明存在负环 实际上就是bellman-ford算法: bellman-ford算法说迭代n次, 还有点被更新的话,
无向图找环
Harris-H的博客
07-28 2170
无向图找环 1.用记录深度的方法 void dfs(int u,int s){ d[u]=s; for(int i=h[u];i;i=e[i].nt){ int v=e[i].to; if(d[v]){ //如果有深度说明之前访问过,可能存在环. ans=max(ans,d[v]-d[u]+1); } else dfs(v,s+1); } } 如果vvv是uuu的前驱结点的话不受影响，因为d[v]+1=d[u]d[v]+1=d[u]d[v]+1=d[u] 所以d[v]−d[u
904 虫洞（spfa找负环）
二哈
11-03 208
1. 问题描述： 农夫约翰在巡视他的众多农场时，发现了很多令人惊叹的虫洞。虫洞非常奇特，它可以看作是一条 单向 路径，通过它可以使你回到过去的某个时刻（相对于你进入虫洞之前）。农夫约翰的每个农场中包含 N 片田地，M 条路径（双向）以及 W 个虫洞。现在农夫约翰希望能够从农场中的某片田地出发，经过一些路径和虫洞回到过去，并在他的出发时刻之前赶到他的出发地。他希望能够看到出发之前的自己。请你判断一下约翰能否做到这一点。翰拥有的农场数量 F，以及每个农场的完整信息。已知走过任何一条路径所花费的时间都不超过 1
acwing算法提高课笔记
m0_66600340的博客
05-26 441
系列文章目录 文章目录系列文章目录@[TOC](文章目录)前言Acwing.12 背包问题具体方案题目描述思路代码 前言 本文为记录复习acwing算法提高课所用。 提示：最好观看完视频阅读。不推荐直接。 Acwing.12 背包问题具体方案 题目描述 有 N 件物品和一个容量是 V的背包。每件物品只能使用一次。 第 i件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出 字典序最小的方案。这里的字典序是指： 所选物品的编号所构成的序列。
spfa找负环要注意的地方
黑历史
04-06 690
当找到入队次数大于n的点时，n却不一定会在负环里面。。。 所以要先往前驱pre走n次才能确保当前的点在负环上。。。 恶心死人啊。。。
图论 —— floyd算法（全源最短路问题 / 无向图找最小环）
Plus Ultra！
08-20 1213
floyd算法： 对于一个含有nnn个结点的无负环图GGG（通常用邻接矩阵存储），floyd算法可以用于解决全源最短路问题，和查找无向图中最小环，时间复杂度O(n3)O(n^3)O(n3)， ①全源最短路问题： 邻接矩阵g[i][j]g[i][j]g[i][j]：表示边i→ji\rarr ji→j的距离，INF表示i,ji,ji,j之间无边直接相连 dist[i][j]dist[i][j]di...
【算法题归纳合集】图论-SPFA找负环
一只快乐的小蒟蒻~
02-08 1015
一、AcWing 904. 虫洞 【题目描述】 农夫约翰在巡视他的众多农场时，发现了很多令人惊叹的虫洞。 虫洞非常奇特，它可以看作是一条单向路径，通过它可以使你回到过去的某个时刻（相对于你进入虫洞之前）。 农夫约翰的每个农场中包含NNN片田地，MMM条路径（双向）以及WWW个虫洞。 现在农夫约翰希望能够从农场中的某片田地出发，经过一些路径和虫洞回到过去，并在他的出发时刻之前赶到他的出发地。 他希望能够看到出发之前的自己。 请你判断一下约翰能否做到这一点。 下面我们将给你提供约翰拥有的农场数量FFF，以及每个
最小圈 找负环（spfa+二分）
nearal的博客
12-26 164
题目描述 样例 1 输入 4 5 1 2 5 2 3 5 3 1 5 2 4 3 4 1 3 输出 3.66666667 样例 2 输入 2 2 1 2 -2.9 2 1 -3.1 输出 -3.00000000 #include<stdio.h> #include<string.h> #define ep 1e-10 int n,m,flag,tot; int fre[10010],nxt[10010],son[10010],vis[10010]; double w[10010]
ACM-ICPC竞赛必备算法与数据结构模板
- 无负权图的最小环：寻找图中最小权重的环。 - 2-SAT：解决满足一定条件的布尔逻辑问题。 - 完美消除序列：处理二分图的最大匹配问题。 - 最大团：寻找图中最大大小的团（完全子图），包括搜索、随机贪心和独立...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值