有源汇上下界网络流简单总结

最新推荐文章于 2020-08-24 21:59:01 发布
最新推荐文章于 2020-08-24 21:59:01 发布
阅读量188 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40875466/article/details/95446513
版权

我们考虑普通的网络流只有上界，加个下界怎么做？

1.我们先把下界的限制消掉，就是使得每条边强制流上他下界的流量，这样限制得到了转化（只有上界），但是并不一定满足流量守恒

2.调整流量，使得他变成一个可行流，我们考虑建虚拟源汇点SS,TT，然后考虑如果某个点流量盈余a[i]<0就让他连一条向TT的容量上限为abs(a[i])的边，a[i]>0同理，然后我们跑一遍最大流，只要使得最大流为\sum_{a[i]>0} a[i]就保证原网络有可行流（由于该网络有源汇，所以要使T->S连一条容量上限为INF的边来保证每个点都满足流量守恒）

3.最后一步就是可行流转化为最大/最小流，我们只要在残量网络上跑一遍最大流就行了（求最大流），如果求最小流，只要T->S跑一遍最大流就行了

模板

 void add(int x,int y,int l,int r) {
        edge[k].u=y; edge[k].to=head[x]; edge[k].l=l; edge[k].r=r; edge[k].w=edge[k].r-edge[k].l; head[x]=k++;
        edge[k].u=x; edge[k].to=head[y]; edge[k].l=0; edge[k].r=0; edge[k].w=0; head[y]=k++;
    }
    void add_new(int x,int y,int z){
        edge[k].u=y; edge[k].to=head[x]; edge[k].w=z; head[x]=k++;
        edge[k].u=x; edge[k].to=head[y]; edge[k].w=0; head[y]=k++;
    }
 bool bfs(int S,int T) {
        queue<int>q;
        q.push(S);
        memset(arrange,0,sizeof(arrange));
        arrange[S]=1;
        while (!q.empty()) {
            int v=q.front(); q.pop(); if (v==T) return 1;
            for (int i=head[v];i!=-1;i=edge[i].to) {
                int u=edge[i].u;
                if (edge[i].w&&!arrange[u]) {
                    arrange[u]=arrange[v]+1;
                    q.push(u);
                }
            }
        }
        return 0;
    }
    int dfs(int now,int maxlow,int t) {
        if (now==t) return maxlow;
        int ret=0;
        for (int &i=cur[now];i!=-1;i=edge[i].to) {
            int u=edge[i].u;
            if (arrange[u]==arrange[now]+1&&edge[i].w) {
                int f=dfs(u,min(maxlow-ret,edge[i].w),t); ret+=f;
                edge[i].w-=f; edge[i^1].w+=f;
                if (ret==maxlow) return ret;
            }
        }
        return ret;
    }
    int dinic(int S,int T) {
        int ans=0;
        while (bfs(S,T)) {
            memcpy(cur,head,sizeof(head));
            ans+=dfs(S,INF,T);
        }
        return ans;
    }
   //以上为最大流dinic
    void upper_lower_maxflow(int S,int T,int n) {//n:总结点个数
        add(T,S,0,INF);
    	for (int i=1;i<=n+2;i++) {
    		for (int j=head[i];j!=-1;j=edge[j].to)
            {
    			ret_flow[i]-=edge[j].l; ret_flow[edge[j].u]+=edge[j].l;
            }
        }//计算节点盈余，在这里S=n+1,T=n+2
        int SS=n+3,TT=n+4;
        int maxflow=0;
        for (int i=1;i<=n+2;i++) 
            if (ret_flow[i]>0) add_new(SS,i,ret_flow[i]),maxflow+=ret_flow[i]; else add_new(i,TT,-ret_flow[i]);
        if (maxflow!=dinic(SS,TT))  {
            puts("JIONG!"); return;
        }
        maxflow=0;
        for (int i=head[T];i!=-1;i=edge[i].to) if (edge[i].u>=S) edge[i].w=0,edge[i^1].w=0;
        for (int i=head[S];i!=-1;i=edge[i].to) if (edge[i].u>=S) edge[i].w=0,edge[i^1].w=0; //去掉S-T的边
        dinic(T,S);//这里求最小流
 		for (int i=head[T];i!=-1;i=edge[i].to) {
        maxflow+=edge[i].w+edge[i^1].l;
        }
        printf("%d\n",maxflow);
    }

清理雪道

由于边可以重复，所以S向每个点连一条下界为0，上界为INF的边，每个点向T连一条下界为0，上界为INF的边，如果两点u->v在原图上有边，那么就连一条u->v下界为1，上界为INF的边，最后直接跑上下界网络流就行了

// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
const int N=300;
const int M=50010;
const int INF=0x3f3f3f3f;
struct node{
    int u,to,l,r,w;
};
node edge[M<<1];
int arrange[N],head[N],a[N],cur[N],ret_flow[N];
int n,cnt,S,T,k,x,y;
    void add(int x,int y,int l,int r) {
        edge[k].u=y; edge[k].to=head[x]; edge[k].l=l; edge[k].r=r; edge[k].w=edge[k].r-edge[k].l; head[x]=k++;
        edge[k].u=x; edge[k].to=head[y]; edge[k].l=0; edge[k].r=0; edge[k].w=0; head[y]=k++;
    }
    void add_new(int x,int y,int z){
        edge[k].u=y; edge[k].to=head[x]; edge[k].w=z; head[x]=k++;
        edge[k].u=x; edge[k].to=head[y]; edge[k].w=0; head[y]=k++;
    }
    bool bfs(int S,int T) {
        queue<int>q;
        q.push(S);
        memset(arrange,0,sizeof(arrange));
        arrange[S]=1;
        while (!q.empty()) {
            int v=q.front(); q.pop(); if (v==T) return 1;
            for (int i=head[v];i!=-1;i=edge[i].to) {
                int u=edge[i].u;
                if (edge[i].w&&!arrange[u]) {
                    arrange[u]=arrange[v]+1;
                    q.push(u);
                }
            }
        }
        return 0;
    }
    int dfs(int now,int maxlow,int t) {
        if (now==t) return maxlow;
        int ret=0;
        for (int &i=cur[now];i!=-1;i=edge[i].to) {
            int u=edge[i].u;
            if (arrange[u]==arrange[now]+1&&edge[i].w) {
                int f=dfs(u,min(maxlow-ret,edge[i].w),t); ret+=f;
                edge[i].w-=f; edge[i^1].w+=f;
                if (ret==maxlow) return ret;
            }
        }
        return ret;
    }
    int dinic(int S,int T) {
        int ans=0;
        while (bfs(S,T)) {
            memcpy(cur,head,sizeof(head));
            ans+=dfs(S,INF,T);
        }
        return ans;
    }
    void upper_lower_maxflow(int S,int T) {
    	for (int i=1;i<=n+2;i++) {
    		for (int j=head[i];j!=-1;j=edge[j].to)
            {
    			ret_flow[i]-=edge[j].l; ret_flow[edge[j].u]+=edge[j].l;
            }
        }
        int SS=++cnt,TT=++cnt;
        int maxflow=0;
        for (int i=1;i<=n+2;i++) 
            if (ret_flow[i]>0) add_new(SS,i,ret_flow[i]),maxflow+=ret_flow[i]; else add_new(i,TT,-ret_flow[i]);
        if (maxflow!=dinic(SS,TT))  {
            printf("%d\n",-1); return;
        }
        maxflow=0;
        for (int i=head[T];i!=-1;i=edge[i].to) if (edge[i].u>=S) edge[i].w=0,edge[i^1].w=0;
        for (int i=head[S];i!=-1;i=edge[i].to) if (edge[i].u>=S) edge[i].w=0,edge[i^1].w=0; 
        for (int i=1;i<=n+2;i++) {
//			for (int j=head[i];j!=-1;j=edge[j].to) printf("%d %d %d\n",i,edge[j].u,edge[j].w);
        } 
        dinic(T,S);
        for (int i=head[S];i!=-1;i=edge[i].to) {
        maxflow+=edge[i^1].w+edge[i].l;
        }
        printf("%d\n",maxflow);
    }
    
int main() {
    memset(head,-1,sizeof(head)); k=0;
    scanf("%d",&n);
    cnt=n+2; 
    S=n+1; T=n+2;
    for (int i=1;i<=n;i++) {
        add(S,i,0,INF); add(i,T,0,INF);
    }
    for (int i=1;i<=n;i++) {
        scanf("%d",&x);
        for (int j=1;j<=x;j++) {
            scanf("%d",&y); add(i,y,1,INF);
        }
    }
    add(T,S,0,INF);
    upper_lower_maxflow(S,T);
}

士兵占领

考虑二分图，把行与列分别作为行与列的两个点集，如果（i,j）上没有障碍，那么就i->j连一条下界为0，上界为1的边

同时S->i连一条下界为Li，上界为INF的边，j->T连一条下界为Ci，上界为INF的边，跑一遍上下界网络流

i,j分别为行与列经过映射的点

// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
const int N=300;
const int M=50010;
const int INF=0x3f3f3f3f;
struct node{
	int u,to,l,r,w;
};
node edge[M<<1];
int arrange[N],head[N],a[N],cur[N],ret_flow[N];
int b[110][110];
int n,cnt,S,T,k,x,y,m,k_sum;
	void add(int x,int y,int l,int r) {
		edge[k].u=y; edge[k].to=head[x]; edge[k].l=l; edge[k].r=r; edge[k].w=edge[k].r-edge[k].l; head[x]=k++;
		edge[k].u=x; edge[k].to=head[y]; edge[k].l=0; edge[k].r=0; edge[k].w=0; head[y]=k++;
	}
	void add_new(int x,int y,int z){
		edge[k].u=y; edge[k].to=head[x]; edge[k].w=z; head[x]=k++;
		edge[k].u=x; edge[k].to=head[y]; edge[k].w=0; head[y]=k++;
	}
    bool bfs(int S,int T) {
        queue<int>q;
        q.push(S);
        memset(arrange,0,sizeof(arrange));
        arrange[S]=1;
        while (!q.empty()) {
            int v=q.front(); q.pop(); if (v==T) return 1;
            for (int i=head[v];i!=-1;i=edge[i].to) {
                int u=edge[i].u;
                if (edge[i].w&&!arrange[u]) {
                    arrange[u]=arrange[v]+1;
                    q.push(u);
                }
            }
        }
        return 0;
    }
    int dfs(int now,int maxlow,int t) {
        if (now==t) return maxlow;
        int ret=0;
        for (int &i=cur[now];i!=-1;i=edge[i].to) {
            int u=edge[i].u;
            if (arrange[u]==arrange[now]+1&&edge[i].w) {
                int f=dfs(u,min(maxlow-ret,edge[i].w),t); ret+=f;
                edge[i].w-=f; edge[i^1].w+=f;
                if (ret==maxlow) return ret;
            }
        }
        return ret;
    }
    int dinic(int S,int T) {
        int ans=0;
        while (bfs(S,T)) {
            memcpy(cur,head,sizeof(head));
            ans+=dfs(S,INF,T);
        }
        return ans;
    }
    void upper_lower_maxflow(int S,int T,int n) {
    	for (int i=1;i<=n+2;i++) {
    		for (int j=head[i];j!=-1;j=edge[j].to)
			{
    			ret_flow[i]-=edge[j].l; ret_flow[edge[j].u]+=edge[j].l;
			}
		}
	    int SS=n+3,TT=n+4;
	    int maxflow=0;
		for (int i=1;i<=n+2;i++) 
			if (ret_flow[i]>0) add_new(SS,i,ret_flow[i]),maxflow+=ret_flow[i]; else add_new(i,TT,-ret_flow[i]);
		if (maxflow!=dinic(SS,TT))  {
		    puts("JIONG!"); return;
		}
		maxflow=0;
		for (int i=head[T];i!=-1;i=edge[i].to) if (edge[i].u>=S) edge[i].w=0,edge[i^1].w=0;
		for (int i=head[S];i!=-1;i=edge[i].to) if (edge[i].u>=S) edge[i].w=0,edge[i^1].w=0; 
//		for (int i=head[T];i!=-1;i=edge[i].to) printf("%d %d %d\n",T,edge[i].u,edge[i].w);
		dinic(T,S);
 		for (int i=head[T];i!=-1;i=edge[i].to) {
		maxflow+=edge[i].w+edge[i^1].l;
		}
		printf("%d\n",maxflow);
	}
	
int main() {
	memset(head,-1,sizeof(head)); k=0;
	scanf("%d%d%d",&n,&m,&k_sum);
	S=n+m+1; T=n+m+2;
	for (int i=1;i<=n;i++) {
		scanf("%d",&x);  add(S,i,x,INF);
	}	
	for (int i=1;i<=m;i++) {
		scanf("%d",&x);  add(n+i,T,x,INF);
	}
	for (int i=1;i<=k_sum;i++) {
		scanf("%d%d",&x,&y); b[x][y]=1;
	}
	for (int i=1;i<=n;i++) {
		for (int j=1;j<=m;j++)
		 if (!b[i][j]) add(i,n+j,0,1);
	}
	add(T,S,0,INF);
	upper_lower_maxflow(S,T,n+m);
}

 

psc233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
有源汇上下界网络流
forezxl的博客
02-28 226
%%%liu_runda 前置技能 无源汇上下界可行流 定义 有源点和汇点的上下界网络流。。。 三个模型及解决方法 有源汇上下界可行流 模型 有一个源点sss和一个汇点ttt，求一个流使得源点的总流出量等于汇点的总流入量。 解决方法 连一条ttt到sss的上下界为[0,+∞)[0,+∞)[0,+\infty)的边。问题转化为无源汇上下界可行流。 然后把这条...
有源汇有上下界最大/最小流
03-13 152
建图还是要想一想的...写一下吧 首先根据有源汇可行流建图，正向附加边满流证明有可行流 然后在这个残量网络上删掉 $(t,s,oo)$ 这条边，跑 $s->t$ 最大流就是最大流，$t->s$ 最大流就是最小流 #include <bits/stdc++.h> #define int long long #define LL long lo...
【Loj116】有源汇有上下界最大流（网络流）
小蒟蒻yyb的博客
07-09 258
题面 Loj 题解 模板题。 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; #include&lt;set&gt; #include&
无源汇有上下界可行流（网络流进阶）
weixin_30349597的博客
06-16 361
无源汇有上下界可行流(也就是循环流) 模型:一个网络,求出一个流,使得每条边的流量必须>=Li且<=Hi, 每个点必须满足总流入量=总流出量(流量守恒)(这个流的特点是循环往复,无始无终) 可行流算法的核心是将一个不满足流量守恒的初始流调整成满足流量守恒的流 流量守恒,即每个点的总流入量=总流出量 如果存在一个可行流,那么一定满足每条边的流量...
有源汇的上下界可行流
04-24
【有源汇的上下界可行流】是指在网络流问题中，网络图的每个弧（边）都有一个容量上限和下限，且存在一个特殊的节点称为源（source）和一个称为汇（sink）的节点。这样的网络流问题可以分为两类：有源汇网络和无源汇...
上下界网络流
04-16
在有源汇的上下界网络流中，可以通过添加一条 t->s 的边，流量限制为[0, inf]，将其转换为无源汇问题。然后，使用相同的方法来解决问题。 最小流： 最小流是指在网络流中，找到一个最小的流量，使得网络流中的所有...
有上下界网络流问题
11-26
在有源汇最小流问题中，我们需要将问题转化为无源汇网络流问题，然后使用ford-fulkerson算法或dinic算法来求解最大流。同时，我们还需要注意到原图中存在环，循环流的情况，以避免流增大。 有上下界网络流问题是...
有源滤波电路设计总结
01-19
本文介绍由集成运算放大器、电阻和电容设计有源滤波器，着重讲解低通、高通、带通滤波电路。 　1. 一阶有源滤波电路 　电路设计图如图1所示，通带电压增益A0等于同相比例放大电路的电压增益Avf，即：A0=Avf=l+Rf／...
噪声有源控制的递归神经网络方法
01-15
使用 Filter- X 算法研究有源噪声控制问题,存在需要较高阶次的滤波器和当噪声出现非线性 时控制效果不佳的缺陷。 为此提出一种基于对角递归神经网络的非线性噪声有源自适应控制方法, 并给 出一种基于误差...
有上下界的网络流
forever_dreams的博客
08-20 696
知识点系列之---有上下界的网络流
SGU 176 Flow construction 有源汇上下界网络流 最小流
inf_force
09-10 771
SGU 176 Flow construction 有源汇上下界网络流 最小流题意：有n个节点m根水管的网络，每根水管有个水流的限制，问最少要多少水流能满足整个网络。最小流 代码：//author: CHC //First Edit Time: 2015-09-10 10:45 #include <iostream> #include <cstdio> #include <cstring>
有上下界的网络流算法汇总
cj1064789374的博客
12-31 1110
有上下界的网络流算法汇总 零、预备知识 f(u,v)表示u-&gt;v这条边的实际流量 b(u,v)表示u-&gt;v这条边的流量下界 c(u,v)表示u-&gt;v这条边的流量上界 在无源汇普通网络流图中满足       在有上下界的网络流图中多了流量下界b(u,v)故需满足 0≤f(u,v)≤c(u,v) 流量限制条件     b(u,v)≤f(u,v)≤c(u,v) 流量限制条件...
poj 2396 Budget （有源汇有上下界的网络流）
clover_hxy的博客
01-07 490
Budget Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 7431   Accepted: 2776   Special Judge Description We are supposed to make a budget proposal for this
【Loj117】有源汇上下界最小流（网络流）
小蒟蒻yyb的博客
07-09 312
题面 Loj 题解 还是模板题。 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; #include&lt;set&gt; #include&am
有源汇的上下界最大/小流
_Griefs
08-24 249
（一）#116. 有源汇有上下界最大流 #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<cmath> #include<string> #include<queue> #define ll long long #define llu unsigned ll using namespace std; cons
有源汇上下界最大流
Psychosocial的博客
08-24 1405
目录有源汇上下界最大流无源汇有上下界可行流有源汇的上下界最大流。 有源汇上下界最大流 只记录一下做法，原理不证明。。 有源汇上下界最大流，指的是 有nnn个点，mmm条边，每条边eee有一个流量下届lowerlowerlower和流量上界upperupperupper，给定源点sss和汇t点，求源点到汇点的最大流 （相当于在之前的最大流的基础上，每条边加上一个流量下界，来求最大流） 做这个题之前先...
LOJ 117 有源汇有上下界最小流（模板）
HumveeA6的博客
05-30 348
建图方法 将有上下界的网络流图转化成普通的网络流图 首先建立附加源点ss和附加汇点tt 对于原图中的边x-&amp;amp;amp;gt;y，若限制为[b,c]，那么连边x-&amp;amp;amp;gt;y，流量为c-b 对于原图中的某一个点i，记d(i)为流入这个点的所有边的下界和减去流出这个点的所有边的下界和 若d(i)&amp;amp;amp;gt;0，那么连边ss-&amp;amp;amp;gt;i，流量为d(i) 若d(i)&amp;amp;
有源汇有上下界最小流
Shelter
01-04 451
Loj117模板 和最大流类似，最大流找到可行流后增流，最小流找到可行流后退流 Code #include&lt;bits/stdc++.h&gt; #define rep(i,a,b) for(int i=(a);i&lt;=(b);i++) #define per(i,a,b) for(int i=(a);i&gt;=(b);i--) #define ll long long using...
有源汇有上下界的最小流（LOJ117）
最新发布
06-11
这是一个IT类问题。该问题可以使用网络流算法解决。首先用 Dinic 或 ISAP 算法求出最大流，...在新图上跑一遍费用流，如果总流量等于原图的最大流，则新图中的最小费用即为所求最小流，否则原图不存在满足上下界的流。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值