图论（7）负环和差分约束

于 2023-01-29 22:02:31 发布
阅读量567 收藏
点赞数
分类专栏： 摆烂日记from acwing 文章标签： 图论 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64197656/article/details/128793562
版权

一、概念

给定一张有向图，如果存在一个环，环上各边权值之和是负数，则称这个环为负环。

判断方式：bellman-ford算法和spfa算法。+抽屉原理

这里只介绍spfa。设立cnt数组表示从1到x的最短路径包含的边数，如果cnt[i]大于等于n，则存在负环。

二、例题

904. 虫洞

 虫洞是负边，存在负环则true。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

const int N =510,M=5210;

int f,n,m1,m2;
int dist[N];
int h[N],e[M],ne[M],w[M],idx;
bool st[N];
int cnt[N];
int q[N];

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

bool spfa()
{
    memset(dist,0,sizeof dist);
    memset(cnt, 0, sizeof cnt);
    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])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
    return false;
}


int main()
{
    cin>>f;
    while(f--)
    {
        cin>>n>>m1>>m2;
        memset(h,-1,sizeof h);
        idx=0;

        for(int i=0;i<m1;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            add(a,b,c),add(b,a,c);
        }
        for(int i=0;i<m2;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            add(a,b,-c);
        }
        if(spfa()) puts("YES");
        else puts("NO");
    }
    return 0;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4455339/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 361. 观光奶牛

 这个和01分数规划有关，涉及01分数规划，一般会用二分。

设二分答案为mid：

1.如果图中存在一个环，若\sum w(e)*mid-\sum w(v)<0，则说明

\exists S=\left \{ v,e \right \} \ \ st.\frac{\sum w(v)}{\sum w(e)}>mid

即本题所求的最大值大于mid

2如果对任意的环，都大于等于0，则说明最大值小于等于mid。

因此可以二分，并且我们发现（1）中的环，实际上可以替代为：没有点权，边权e（x，y）的权值是mid*w(e)-w(x)，即本来的边权乘以mid再减去入点的权值。的这样一个环。因此可以构建一个新图。

（1）中的条件变为，这样的新图有负环。

因此二分求解答案即可。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

const int N =1010,M=5010;

int n,m;
int wf[N];
int h[N],e[M],ne[M],wt[M],idx;
bool st[N];
int cnt[N];
double dist[N];
int q[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)
{
    memset(dist,0,sizeof dist);
    memset(cnt,0,sizeof cnt);
    memset(st,0,sizeof st);
    queue<int> q;

    for(int i=1;i<=n;i++)
    {
        st[i]=true;
        q.push(i);
    }
    while(q.size())
    {
        int 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]+mid*wt[i]-wf[t])
            {
                dist[j]=dist[t]+mid*wt[i]-wf[t];
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n) return true;
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
    return false;

}


int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>wf[i];
    memset(h,-1,sizeof h);

    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    double l=0,r=1e6;
    while(r-l>1e-4)
    {
        double mid=(l+r)/2;
        if(check(mid)) l=mid;
        else r=mid;
    }
    printf("%.2lf",l);
    return 0;


}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4455633/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1165. 单词环

 

 分析：

  1. 建图：最直观的建图方式，是把每个单词看做节点，然后连接可接龙的单词。但是这样最多有1e5个点，有1e10条边，存不下。因此要换方法。考虑一个对偶的建图方式,将每一个单词看作一条边,其开头两个字符和结尾两个字符为它两边的点。这样建图的话,节点数就缩小到了676个(26∗26)边数为1e5条。
  2. 01分数规划：我们要求\frac{\sum len}{s}=k的最大值，设二分答案mid。当k>mid时：\sum len-s*mid>0，因此我们把边权设置为len[i]−mid。
  3. 优化：spfa求负环时，可能一直跑不出结果。可以采取一种比较取巧的方法:当求最长路时,经过的点大于某一个数时,我们就可以武断地认为当前图中存在一个正环.
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

const int N =700,M=100010;

int n;
double dist[N];
int cnt[N];
int h[N],e[M],ne[M],w[M],idx;
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)
{
    queue<int> q;
    memset(dist,0,sizeof dist);
    memset(cnt,0,sizeof cnt);
    memset(st,0,sizeof st);

    for(int i=0;i<676;i++)
    {
        st[i]=true;
        q.push(i);
    }

    int count=0;
    while(q.size())
    {
        int 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]+mid-w[i])
            {
                dist[j]=dist[t]+mid-w[i];
                if(++count>10000) return true;
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=N) return true;
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
    return false;
}

int main()
{
    char str[1010];
    while(cin>>n,n)
    {
        memset(h,-1,sizeof h);
        idx=0;

        for(int i=0;i<n;i++)
        {
            cin>>str;
            int len=strlen(str);
            if(len>=2)
            {
                int left=(str[0] - 'a') * 26 + str[1] - 'a';
                int right = (str[len - 2] - 'a') * 26 + str[len - 1] - 'a';
                add(left,right,len);
            }
        }

        if(!check(0)) puts("No solution");
        else
        {
            double l=0,r=1010;
            while(r-l>1e-5)
            {
                double mid=(l+r)/2;
                if(check(mid)) l=mid;
                else r=mid;
            }
            printf("%.2lf\n",r);
        }
    }
    return 0;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4455934/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

三、差分约束

差分约束就是一组N元一次不等式。给出了多个约束条件形如：X_i-X_j\leqslant c_k。我们要解决的问题就是求出一组X，使得所有约束条件得到满足。

我们可以把X_i-X_j\leqslant c_k看做 j 节点向 i 节点连一条长度为ck的有向边。

则如果a1 a2....an是一组解，则对任意的常数delta，a+delta也是一组解。所以不妨先求一组负数解。假设所有ai小于等于0。我们再增加一个超级原点a0=0，则多了N个形如a_i-a_0\leqslant 0的约束条件。即我们把0号点向所有点连一条长度为0的边。

在我们建的图上跑最短路，如果存在负环，则说明有ai<ai，这是不可能满足的，所以差分系统无解，否则，ai=dist[i]就是一组解。

如果约束条件不等号反向，我们仍然可以不改变图，只不过改为计算单源最长路，如果有正环则无解。

 参考：AcWing 1169. 糖果 - AcWing

AcWing 1169. 糖果 - AcWing 

也就是说，如果是求最小值，则求最长路。求最大值，则求最短路。

四、例题

1169. 糖果

 

 注意超级原点。因此本题求最小值，跑最长路判断即可，判断有无正环

#include<iostream>
#include<algorithm>
#include<cstring>
#include<stack>
using namespace std;


const int N =1e5+10,M=3e5+10;

int n,m;
int h[N],e[M],ne[M],w[M],idx;
long long  dist[N];
bool st[N];
int cnt[N];


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

int spfa()
{
    memset(dist,-0x3f,sizeof dist);
    dist[0]=0;
    stack<int> q;
    q.push(0);
    st[0]=true;

    while(q.size())
    {
        int t=q.top();
        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+1) return false;
                if(!st[j]) 
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    return true;
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(int i=0;i<m;i++)
    {
        int a,b,x;
        cin>>x>>a>>b;
        if(x==1) add(a,b,0),add(b,a,0);
        else if(x==2) add(a,b,1);
        else if(x==3) add(b,a,0);
        else if(x==4) add(b,a,1);
        else add(a,b,0);
    }

    for(int i=1;i<=n;i++) add(0,i,1);

    if(!spfa()) cout<<"-1";
    else 
    {
        long long  res=0;
        for(int i=1;i<=n;i++) res+=dist[i];
        cout<<res;
    }


}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4482434/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

362. 区间（前缀和）

 AcWing 362. 区间 - AcWing

 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

const int N =5e4+10,M=2e5;

int n;
int h[N],e[M],ne[M],w[M],idx;
int dist[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++;
}

void spfa()
{
    memset(dist,-0x3f,sizeof dist);
    queue<int> q;
    dist[0]=0;
    q.push(0);
    st[0]=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];
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
}

int main()
{
    cin>>n;
    memset(h,-1,sizeof h);
    
    for(int i=1;i<N;i++)
    {
        add(i,i-1,-1);
        add(i-1,i,0);
    }
    
    for(int i=0;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        a++,b++;
        add(a-1,b,c);
    }
    
    spfa();
    cout<<dist[50001];
    
}

1170. 排队布局

 无穷即判断1号点和n号点有无约束关系即，即连不连通。

 

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

using namespace std;

const int N =1010,M=10000+10000+1010,INF=0x3f3f3f3f;

int n,m1,m2;
int dist[N];
bool st[N];
int h[N],e[M],ne[M],w[M],idx;
int cnt[N];

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

bool spfa(int size)
{
    memset(dist,0x3f,sizeof dist);
    memset(st,0,sizeof st);
    memset(cnt,0,sizeof cnt);
    queue<int> q;

    for(int i=1;i<=size;i++)
    {
        q.push(i);
        st[i]=true;
        dist[i]=0;
    }
    while(q.size())
    {
        int 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;
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    return false;
}

int main()
{
    cin>>n>>m1>>m2;
    memset(h,-1,sizeof h);
    for(int i=1;i<n;i++) add(i+1,i,0);

    for(int i=0;i<m1;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        if(a>b) swap(a,b);
        add(a,b,c);
    }
    for(int i=0;i<m2;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        if(a>b) swap(a,b);
        add(b,a,-c);
    }

    if(spfa(n)) puts("-1");//出现矛盾 有负环
    else
    {
        spfa(1);
        if(dist[n]==INF) puts("-2");
        else cout<<dist[n];
    }
    return 0;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4494625/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

393. 雇佣收银员

 

BlessingSoftware1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论学习-负环
麒麟001号的博客
03-03 1401
文章目录一、负环 acwing提高课正好看到负环，干脆写篇博客记录一下。 一、负环 定义：环中所有边权值和为负数的环，称为负环 负环可以有两种求法：bellman_ford和spfa spfa是对bellman_ford的优化，一般是用spfa求负环 时间复杂度最好O(m),最坏O(km) 给出判负环的两种方法： (1) 统计每个点入队次数，如果某个点入队n次，说明存在n条边的路径，那么必然有n+1个点，则存在负环 (2) 只要某个点最短路所含的边数大于等于n，说明至少n+1个点，则存在负环 注意：
spfa算法判断负环【什么是负环】【出现负环会怎么样】【牢记，此时不是求最短路】
最新发布
蓝天it（让亿万孩子在蓝天下共享优质教育）
12-04 901
spfa算法判断负环【什么是负环】【出现负环会怎么样】【牢记，此时不是求最短路】
图论——负环
qq_53504307的博客
05-18 425
图论——负环 笔记： 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时说明至少存在
环和负环及差分约束
qq_42852687的博客
09-15 163
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
poj2983-差分约束判定存在&正环与负环-Is the Information Reliable?
天与云与山与水
11-23 557
https://vjudge.net/problem/POJ-2983 给定一些坐标的位置，问你这些坐标的摆放是否合理。 ① P x y c，说明x再y左边c米处。 ② V x y 说明x在y 左边。 差分约束，大佬的博客。 http://blog.csdn.net/consciousman/article/details/53812818 （因为差分约束的距离都是根据不等式算的
图论- 差分约束系统.rar
09-16
在图论中，差分约束系统（Differential Constraint System，DCS）是一种特殊的模型，广泛应用于路径规划、网络流问题、机器人运动规划等领域。本文将深入探讨差分约束系统的概念、性质以及它们在实际问题中的应用。 ...
ACM 程序设计：图论2 最短路径 差分约束系统-1.pdf
06-18
【ACM程序设计：图论2 最短路径 差分约束系统-1.pdf】这篇文档主要探讨了在图论中的最短路径问题，并且引入了差分约束系统这一概念，这是在解决某些优化问题时非常重要的工具。在这个特定的问题中，最短路径问题被...
ACM 程序设计：图论2 最短路径 差分约束系统-p6.pdf
06-18
在ACM程序设计中，图论是一门重要的理论基础，特别是在解决实际问题时，如本题所述的"最短路径"和"差分约束系统"。在这个特定的问题中，我们面临的是一个寻找最安全路径的问题，而非通常意义上的最短路径。问题背景...
ACM 程序设计：图论2 最短路径 差分约束系统-p1.pdf
06-18
在 ACM 程序设计中，图论和最短路径算法是两大重要的知识点。本文将通过一个具体的例子来介绍这两个概念，并对其在程序设计中的应用进行详细的解释。 一、图论基础 图论是数学的一个分支，研究图的结构和性质。图...
差分约束系统题解1
08-03
总的来说，差分约束系统是一种强大的工具，能够处理多种优化问题，通过将其转化为图论问题，我们可以运用图的遍历算法找到最优解。在解决具体问题时，理解Dist数组的含义，正确构建边，以及选择合适的最短路径算法...
poj2240Arbitrage(bellman_ford判负环)
weixin_30745641的博客
09-30 79
题意 给n种货币，m条货币之前的汇率，判断最后能否从中套利 解题思路 典型的判定负环图的问题，题目给的货币字符串，用map来给不同的字符串一个映射就可以了 AC代码 #include<vector> #include<algorithm> #include<cstdio> #include<iostream> #include<set> ...
判断负环的方法
weixin_33889245的博客
07-25 118
1. folyed ：出现road[i][i]<0的情况 2. spfa：出现一个点进入queue的次数大于等于n的情况 转载于:https://www.cnblogs.com/chinacwj/p/7236116.html
负环 —— SPFA扩展
weixin_45724872的博客
02-22 412
负环的定义 在有向图或无向图中，存在一个环，权值之和为负数； 那么按常规最短路，就会无限在这上面更新了，也就是使得dist(u)=−INFdist(u) = -INFdist(u)=−INF 负环的问题最经常结合01分数规划； 方法 建议使用第二种方法，一般来说，方法二跑的比较快； 方法一解释 这个方法是由Bellman−FordBellman-FordBellman−Ford扩展过来的； BF算法告诉我们，如果我们迭代了nnn次，还有节点没更新，那么说明存在负环； 而我们的SPFA是基于BF算法的，在
图论 —— 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...
10.4 最短路径相关算法——点权、边权、最短路径条数（基础算法）
小魚兒
10-30 1570
#include <cstdio> #include <vector> using namespace std; //单源最短路径——Dijkstra算法 //1、伪代码 //G为图，一般设成全局变量 ，数组d为源点到达各点的最短路径长度 /*Dijstra(G,d[],s) { 初始化； for(循环n次) { u=使d[u]最小的还未被访问的顶点的标号 ...
poj 3259 Wormholes（判断图中是不是存在负环）
guihaiyuan123的博客
04-30 182
                                                                                   WormholesTime Limit: 2000MS Memory Limit: 65536KTotal Submissions: 59278 Accepted: 22160DescriptionWhile exploring hi...
图论 —— 环与块 —— 负权环
Alex_McAvoy的博客
07-24 1741
【概述】 从一个点出发，经过一条简单路径回到起点，称为图的环，而图的负权环就是环中所有的边的权值均为负值。 所谓负权环问题，就是判断图中是否存在一个环，且这个环上的各边的权值均为负。 【Bellman-Ford 算法】 Bellman-Ford 算法在计算单源最短路径时可以判断是否存在负环 关于 Bellman-Ford 算法：点击这里 int n,w,m; int dis[N]; ...
【图论】SPFA算法判断图中是否存在负环/环
Rainfoo的博客
02-24 896
时间复杂度是O(nm),n表示点数，m表示边数 板子裸题：AcWing.852 #include<bits/stdc++.h> #define ll long long #define endl '\n' using namespace std; const int INF=0x3f3f3f3f; const int maxn=1e5+5; vector<pair<ll,l...
图论之负环问题
ZZU_LGY
10-28 263
一.模板 1.spfa判断负环 #include <iostream> #include <cstring> #include <algorithm> #include <queue> using namespace std; const int N = 100010; int e[N],ne[N],w[N],h[N],idx=0; bool st[N]; int n,m; int dist[N]; int cnt[N]; void add(int a,int
使用Bellman-Ford解决差分约束系统与最短路径
总结来说，差分约束系统和最短路径问题可以通过图论方法来解决，特别是当存在负权重时，Bellman-Ford算法是一种有效的工具。通过理解和应用这些概念，我们可以解决各种实际问题，如时间旅行路径规划。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值