上下界网络流

最新推荐文章于 2020-04-05 18:28:53 发布
最新推荐文章于 2020-04-05 18:28:53 发布
阅读量141 收藏
点赞数
原文链接：http://www.cnblogs.com/nosta/p/10938396.html
版权

目录

本篇笔记写于远古时代，写时虽然参考了一些的资料（罗列在文末），但口胡仍然占多数，准确性堪忧，如有不准确的地方，欢迎指正。

无源汇有上下界可行流

首先要满足流量下界的需求，强行让每条边都流过low的流量，那么每条边只剩下的容量为upp-low，同时设流入点x的流量-流出点x的流量为d[x]。

考虑调整流网络使得流量平衡（让d[x]变为0）1）对于d[x]<0的点，我们希望向x流入-d[x]的流量 2）对于d[x]>0的点，我们希望从x流出d[x]的流量；

因此，考虑新建附源汇点S-T，S指向所有d[x]>0的x，所有d[x]>0的x指向T就能提供像这样调整的“势”。

对流网络跑最大流，如果存在边(S,?,k)或(?,T,k)满足k!=0，则可知无法调整到流量平衡，即不存在可行流。 因为sum a[x] (a[x]>0)=sum -a[x] (a[x]<0)，具体操作时，只检差一边就行了。

显然，此时的一条边的可行流量为跑完最大流后所减少的流量（即反边流量）+原来的下界。

#include <bits/stdc++.h>
using namespace std;
const int N=207; 
const int L=30407;
const int inf=0x3f3f3f3f;

int S,T;
int head[N],to[L],cap[L],last[L],cnt=1;
int que[N],lev[N],hd,tl;

inline void add_edge(int x,int y,int c1,int c2=0) {
    to[++cnt]=y,cap[cnt]=c1,last[cnt]=head[x],head[x]=cnt;
    to[++cnt]=x,cap[cnt]=c2,last[cnt]=head[y],head[y]=cnt; 
}
inline bool bfs() {
    memset(lev,0,sizeof lev);
    lev[S]=1;
    que[hd=0,tl=1]=S;
    while(hd<tl) {
        int x=que[++hd];
        for(int i=head[x]; i; i=last[i]) if(cap[i]>0 && !lev[to[i]]) 
            lev[to[i]]=lev[x]+1, que[++tl]=to[i];
    }
    return lev[T]!=0;
}
int dfs(int x,int tf) {
    if(x==T) return tf;
    int tot=0,tmp;
    for(int i=head[x]; i; i=last[i]) if(cap[i]>0 && lev[x]+1==lev[to[i]]) {
        tmp=dfs(to[i],min(tf-tot,cap[i]));
        if(tmp) cap[i]-=tmp,cap[i^1]+=tmp,tot+=tmp;
        if(tot==tf) break;
    }
    if(!tot) lev[x]=-1;
    return tot;
}
int n,m,a[N],low[L]; 
bool check() {
    for(int i=head[S]; i; i=last[i]) 
        if(cap[i]) return false;
    for(int i=head[T]; i; i=last[i])
        if(cap[i^1]) return false;
    return true;
}
void solve() {
    cnt=1;
    memset(a,0,sizeof a);
    memset(head,0,sizeof head);
    for(int i=1,x,y,upp; i<=m; ++i) {
        scanf("%d%d%d%d",&x,&y,&low[i],&upp);
        a[x]-=low[i];
        a[y]+=low[i];
        add_edge(x,y,upp-low[i]);
    }
    int lst=cnt;
    S=n+1, T=n+2;
    for(int i=1; i<=n; ++i) {
        if(a[i]>0) add_edge(S,i,a[i]);
        if(a[i]<0) add_edge(i,T,-a[i]);
    }
    while(bfs()) dfs(S,inf);
    if(!check()) {
        puts("NO");
        return;
    }
    puts("YES"); 
    for(int i=2; i<=lst; i+=2) {
        printf("%d\n",cap[i^1]+low[i>>1]);
    }
}

int main() {
    while(~scanf("%d%d",&n,&m)) solve();
    return 0;
}

有源汇有上下界可行流

无源汇的流网络所有点都要满足d[x]=0，这说明它其实是一个“流循环图”。而对于有源汇的合法的流网络，除了d[s]<0，d[t]>0外，其余点满足d[x]=0，并且d[s]=-d[t]，这启发我们加入t到s的一条下界为0，上界为inf的边，这样，图转化为一个“流循环图”，可以借助无源汇的算法调整。

来看下调整后流网络的边t-s，它的反边流量k=与s、t有关的基准流量，即这样的一组调整必然会给s-t的最大流带来k的贡献。答案即为k。

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

const int N=207; 
const int L=30407;
const int inf=0x3f3f3f3f;

int S,T,s,t;
int head[N],to[L],cap[L],last[L],cnt=1;
int que[N],lev[N],hd,tl;

inline void add_edge(int x,int y,int c1,int c2=0) {
    to[++cnt]=y,cap[cnt]=c1,last[cnt]=head[x],head[x]=cnt;
    to[++cnt]=x,cap[cnt]=c2,last[cnt]=head[y],head[y]=cnt; 
}
inline bool bfs() {
    memset(lev,0,sizeof lev);
    lev[S]=1;
    que[hd=0,tl=1]=S;
    while(hd<tl) {
        int x=que[++hd];
        for(int i=head[x]; i; i=last[i]) if(cap[i]>0 && !lev[to[i]]) 
            lev[to[i]]=lev[x]+1, que[++tl]=to[i];
    }
    return lev[T]!=0;
}
int dfs(int x,int tf) {
    if(x==T) return tf;
    int tot=0,tmp;
    for(int i=head[x]; i; i=last[i]) if(cap[i]>0 && lev[x]+1==lev[to[i]]) {
        tmp=dfs(to[i],min(tf-tot,cap[i]));
        if(tmp) cap[i]-=tmp,cap[i^1]+=tmp,tot+=tmp;
        if(tot==tf) break;
    }
    if(!tot) lev[x]=-1;
    return tot;
}
int n,m,a[N],low[L]; 
bool check() {
    for(int i=head[S]; i; i=last[i]) 
        if(cap[i]) return false;
    for(int i=head[T]; i; i=last[i])
        if(cap[i^1]) return false;
    return true;
}
void solve() {
    cnt=1;
    memset(a,0,sizeof a);
    memset(head,0,sizeof head);
    for(int i=1,x,y,upp; i<=m; ++i) {
        scanf("%d%d%d%d",&x,&y,&low[i],&upp);
        a[x]-=low[i];
        a[y]+=low[i];
        add_edge(x,y,upp-low[i]);
    }
    add_edge(t,s,inf);
    S=n+1, T=n+2;
    for(int i=1; i<=n; ++i) {
        if(a[i]>0) add_edge(S,i,a[i]);
        if(a[i]<0) add_edge(i,T,-a[i]);
    }
    while(bfs()) dfs(S,inf);
    if(!check()) {
        puts("please go home to sleep");
        return;
    }
    printf("%d\n",upp[head[s]]);
}

int main() {
    while(~scanf("%d%d%d%d",&n,&m,&s,&t)) 
        solve();
    return 0;
}

有源汇有上下界最大流

接着第二来讲，因此，再将此边即所有与ST关联的边删除，剩下的便是张一般的流网络，k+此时s-t的最大流即为答案。

进一步的，我们可以不必删除t-s边和ST关联的边，直接采用当前流网络的s-t的最大流作为答案。因为1）t-s边的反边的基准流量必然会被增广；2）不可能存在经过S或T的增广路（S的出边、T的入边全部断开）。

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

const int N=207; 
const int L=30407;
const int inf=0x3f3f3f3f;

int S,T,s,t;
int head[N],to[L],cap[L],last[L],cnt=1;
int que[N],lev[N],hd,tl;

inline void add_edge(int x,int y,int c1,int c2=0) {
    to[++cnt]=y,cap[cnt]=c1,last[cnt]=head[x],head[x]=cnt;
    to[++cnt]=x,cap[cnt]=c2,last[cnt]=head[y],head[y]=cnt; 
}
inline bool bfs() {
    memset(lev,0,sizeof lev);
    lev[S]=1;
    que[hd=0,tl=1]=S;
    while(hd<tl) {
        int x=que[++hd];
        for(int i=head[x]; i; i=last[i]) if(cap[i]>0 && !lev[to[i]]) 
            lev[to[i]]=lev[x]+1, que[++tl]=to[i];
    }
    return lev[T]!=0;
}
int dfs(int x,int tf) {
    if(x==T) return tf;
    int tot=0,tmp;
    for(int i=head[x]; i; i=last[i]) if(cap[i]>0 && lev[x]+1==lev[to[i]]) {
        tmp=dfs(to[i],min(tf-tot,cap[i]));
        if(tmp) cap[i]-=tmp,cap[i^1]+=tmp,tot+=tmp;
        if(tot==tf) break;
    }
    if(!tot) lev[x]=-1;
    return tot;
}
int n,m,a[N],low[L]; 
bool check() {
    for(int i=head[S]; i; i=last[i]) 
        if(cap[i]) return false;
    for(int i=head[T]; i; i=last[i])
        if(cap[i^1]) return false;
    return true;
}
void solve() {
    cnt=1;
    memset(a,0,sizeof a);
    memset(head,0,sizeof head);
    for(int i=1,x,y,upp; i<=m; ++i) {
        scanf("%d%d%d%d",&x,&y,&low[i],&upp);
        a[x]-=low[i];
        a[y]+=low[i];
        add_edge(x,y,upp-low[i]);
    }
    add_edge(t,s,inf);
    S=n+1, T=n+2;
    for(int i=1; i<=n; ++i) {
        if(a[i]>0) add_edge(S,i,a[i]);
        if(a[i]<0) add_edge(i,T,-a[i]);
    }
    while(bfs()) dfs(S,inf);
    if(!check()) {
        puts("please go home to sleep");
        return;
    }
    int ret=0;
    S=s, T=t;
    while(bfs()) ret+=dfs(S,inf);
    printf("%d\n",ret);
}

int main() {
    while(~scanf("%d%d%d%d",&n,&m,&s,&t)) 
        solve();
    return 0;
}

有源汇有上下界最小流

直接的做法是s-t的最小流=基准流量k - (t-s的最大流)。此时要注意删除t-s的边（若不删除，则会使得t-s的最大流接近无穷大，成功GG）。

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

const int N=5e4+20;
const int L=2e6+20;
const LL inf=1e15;

int n,m,s,t,d[N];
int S=N-1,T=N-2;
int head[N],cur[N],to[L],last[L],cnt=1;
int que[N],lev[N],hd,tl;
LL upp[L];

inline void add_edge(int x,int y,LL u) {
    to[++cnt]=y,upp[cnt]=u,last[cnt]=head[x],head[x]=cnt;
    to[++cnt]=x,upp[cnt]=0,last[cnt]=head[y],head[y]=cnt; 
}
inline bool bfs() {
    memset(lev,0,(n+2)<<2);
    lev[S]=1;
    que[hd=0,tl=1]=S;
    while(hd<tl) {
        int x=que[++hd];
        for(int i=head[x]; i; i=last[i]) if(upp[i]>0 && !lev[to[i]]) 
            lev[to[i]]=lev[x]+1, que[++tl]=to[i];
    }
    return lev[T]!=0;
}
LL dfs(int x,LL tf) {
    if(x==T) return tf;
    LL tmp;
    for(int &i=cur[x]; i; i=last[i]) if(upp[i]>0 && lev[x]+1==lev[to[i]]) {
        tmp=dfs(to[i],min(tf,upp[i]));
        if(tmp) {
            upp[i]-=tmp;
            upp[i^1]+=tmp;
            return tmp;
        }
    }
    lev[x]=-1;
    return 0;
}
template<typename T> inline void read(T&d) {
    register char ch=getchar(); d=0;
    while(!isdigit(ch)) ch=getchar();
    while(isdigit(ch)) d=d*10+ch-'0',ch=getchar();
} 
LL dinic() {
    LL ret=0,tmp;
    while(bfs()) {
        for(int i=0; i<=n+1; ++i) cur[i]=head[i];
        while((tmp=dfs(S,inf))>0) ret+=tmp;
    }
    return ret;
}
int main() {
    read(n);read(m);read(s);read(t);
    for(int i=1,x,y,low,upp; i<=m; ++i) {
        read(x);read(y);read(low);read(upp);
        d[x]-=low;
        d[y]+=low;
        add_edge(x,y,upp-low); 
    }
    S=0, T=n+1;
    add_edge(t,s,inf);
    for(int i=1; i<=n; ++i) {
        if(d[i]>0) add_edge(S,i,d[i]);
        if(d[i]<0) add_edge(i,T,-d[i]);
    }
    dinic();
    for(int i=head[S]; i; i=last[i]) {
        if(upp[i]) {
            puts("please go home to sleep");
            return 0;
        }
    }
    long long st=upp[head[s]];
    upp[head[s]]=0;
    upp[head[t]]=0;
    S=t, T=s;
    printf("%lld\n",st-dinic());
    return 0;
}

无源汇有上下界最小费用可行流

干掉下界的时候，把费用先计算上。把超级源超级汇求最大流的一步，换成最小费用最大流即可。即满足合法的前提下，最小化费用。费用就是之前的费用加上这次的费用。

有源汇有上下界最小费用可行流

参考第一到第二的转化，添加边t-s，下界为0，上界为inf，费用为0。然后按照第五进行调整至所有点流量平衡即可。

有源汇有上下界最小费用最大流

似乎直接按照第三改一波。。mf改为mcmf。

有源汇有上下界最小费用最小流

似乎直接按照第四改一波。。我也不清楚，因为要减去最多的花费 最大费用流？？？

参考资料：

学习笔记 上下界网络流 作者*Miracle*。

网络流常见建模总结 作者panda_2134。

转载于:https://www.cnblogs.com/nosta/p/10938396.html

weixin_30466421
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
有上下界网络流问题
11-26
"有上下界网络流问题" 有上下界网络流问题是网络流问题的一种特殊情况， 涉及到流网络的每条边加上两个限制条件，即low和up，low代表此边流量的下界，up代表此边的流量上界，求源点到汇点的最大流。 在这种问题中...
有上下界的网络流学习笔记
weixin_30824479的博客
01-08 133
//其实主要还是自己复习用 //假定读者能够熟练打dinic的板子 有上下界的网络流的核心是”调整”,我们通过一个初始的未必可行的流调整出一个可行流,还可以从可行的未必最大/最小的流调整出最大/最小流. 另一个常用技巧是有源汇的流和无源汇的流(循环流)的转换.除了无源汇可行流的求解,其他有源汇的上下界网络流都要用到这个技巧. 无源汇有上下界可行流(也就是循环流) 模型:一个网络,...
有上下界的网络流
AZUI _ oi memories
01-05 541
我是在心情极度不爽且精神很疲惫的情况下写的这篇博客。可能语无伦次，见谅。 上下界网络流，大致思路是虚拟超级源点和汇点(ss&tt)，让每个点的流量底线强行用超级源点和超级汇点来满足。 具体来讲，分为无源汇（求循环流），有源汇（求满足限制的最大流、最小流）。 具体原理不想写了，实现的时候求最大流有两种写法：用ss&tt先跑一次，然后删ss和tt在利用原来的s和t跑一次两者加起来，或者不删点直接
5.有上下界的网络流_有上下界的网络流_
10-03
有上下界的网络流是图论中的一个重要概念，它在计算机科学和运筹学中有着广泛的应用，尤其是在解决运输问题、电路设计、资源分配等问题时。网络流问题通常涉及到在一个有向图中，从一个源节点到一个汇点，通过网络中...
周源-有上下界的网络流周源-有上下界的网络流
10-01
然而，当涉及到有上下界网络流时，边的流量不仅有上限，也有下限，即每条边都有一个最小流量要求和最大流量限制。 **定义与模型** 有上下界的网络流问题是在一个加权有向图G=(V,E)中进行的，其中V是节点集合，E是边...
有上下界限的网络流.pptx
11-18
### 有上下界网络流详解 #### 一、有上下界网络流定义 在传统的网络流问题中，我们通常只考虑边的容量上限，而有上下界网络流则在此基础上进一步引入了流量的下限约束。这意味着对于网络中的每一条边而言，其实际...
上下界网络流初探
weixin_30396699的博客
01-01 86
看文章各种不明真相... 请教了一下iwtwiioi大牛...大致有个理解.... 建模过程 1.拆边. 对于每一条给出的有向边(u,v,c,d) ,其中c指下界,d指上界,那么在实际的图中连三条只有上界没有下界的边: (S,v,c) (u,T,c) (u,v,d-c) 其中S是超级源,T是超级汇.(不同于题目给出的源与汇) 一条是超级源连向边的终点. 第二条是边的起点...
【有上下界的网络流】
leolin_的专栏
01-18 4056
相对于一般的网络流，有上下界的网络流的某些边多出了流量下界的限制，如边u->v，上下界为high、low，如果有流经过这条边，这个流必须在[low，high]这个区间内。这类题目主要要求解决下面三个问题，“有源汇、无源汇的可行流”、“有源汇的最大流”、“有源汇的最小流”，注意这里所说的源汇是原网络中的源汇，分别记为s、t。 　　这类题目的难点在于下界的限制很难处理，我们将所有有下界限制的边中分离
自己对有上下界的网络流的理解
天使也掉毛
08-14 1074
相对于一般的网络流，有上下界的网络流的某些边多出了流量下界的限制，如边u->v，上下界为high、low，如果有流经过这条边，这个流必须在[low，high]这个区间内。这类题目主要要求解决下面三个问题，“有源汇、无源汇的可行流”、“有源汇的最大流”、“有源汇的最小流”，注意这里所说的源汇是原网络中的源汇，分别记为s、t。 　　这类题目的难点在于下界的限制很难处理，我们将所有有下界限制的边中分离
上下界网络流 cf704D
rgndao的博客
04-05 170
cf704D 给棋盘上n个棋子染色，红黑两种，代价不同，有m个约束，要求某一行或某一列的红黑棋子数差不能超过某一数值。求最小代价的染色方案。 上下界网络流的思路就是分别减去最低流量，剩余的放在图中跑最大流，对于原有大于零下界的边就通过新建超级源点ss和汇点tt解决，即出点多出的连向汇点，入点缺少的从源点补充。合法要求：源点s发出的必须能跑满，否则原有的平衡条件就打破了，无可行流。 对于原本就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值