有下界最大流问题

最新推荐文章于 2025-09-04 10:50:32 发布
原创 最新推荐文章于 2025-09-04 10:50:32 发布 · 718 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#acm #有上下界的最大流问题 #poj2396 #zoj2314

（1）、无源无汇有容量下界的可行流问题；

建立附加源s和附加汇t，然后对弧进行改造：首先添加弧t->s容量为无穷大；然后把每条弧（u，v）拆成3条：s->v（容量为u,v的下界），u->t（容量为u,v下届），u ->v（容量为u,v上界减去u,v下界）

求改造后的网络的最大流即可。当且仅当所有附加弧（与s和t相连的边）满载时原网络有可行流。且原网络中每条边（u，v）的流量的等于改造后的网络中（u，v）的流量加上（u,v）的下界；

ZOJ2314 无源无汇可行流模板题目；

#include<cstdio>  
#include<cstring>  
#include<cmath>  
#include<cstdlib>  
#include<climits>  
#include<cctype>  
#include<iostream>  
#include<algorithm>  
#include<queue>  
#include<vector>  
#include<map>  
#include<set>  
#include<string>  
#include<stack>  
#define ll long long  
#define MAX 500  
#define eps 1e-8  
#define INF 100000000  
  
using namespace std;  

struct Node{
	int l,c;
}F[MAX][MAX];
  
struct Edge{  
    int from, to,cap,flow;  
};  
  
vector<int>G[MAX],T[MAX];  //T用来记录G的转置，用于下面逆向bfs遍历图  
vector<Edge>edges;  
  
int n;  
  
void init(){  
    for (int i=0; i<MAX; i++){  
        G[i].clear();  
        T[i].clear();  
    }  
    edges.clear();  
}  
  
void addEdge(int from, int to, int cap){  
    edges.push_back((Edge){from,to,cap,0});  
    edges.push_back((Edge){to,from,0,0});  
    int k = edges.size();  
    G[from].push_back(k-2);  
    G[to].push_back(k-1); 
	T[to].push_back(from); 
}  
  
int d[MAX];  
  
void bfs(int s, int t){  
    bool vis[MAX];  
    queue<int>q;  
    memset(vis,false,sizeof(vis));  
    q.push(s);  
    d[s] = 0;  
    vis[s] = true;  
    while (!q.empty()){  
        int u = q.front();  
        q.pop();  
        for (int i=0; i<T[u].size(); i++){  
            int v = T[u][i];  
            if (!vis[v]){  
                d[v] = d[u] + 1;  
                vis[v]  =  true;  
                q.push(v);  
            }  
        }  
    }  
}  
  
int p[MAX],num[MAX],cur[MAX];  
  
int Augment(int s, int t){  
    int x = t, a = INF;  
    while (x != s){  
        Edge& e = edges[p[x]];  
        a = min(a,e.cap - e.flow);  
        x = edges[p[x]].from;  
    }  
    x = t;  
    while (x != s){  
        edges[p[x]].flow += a;  
        edges[p[x]^1].flow -= a;  
        x = edges[p[x]].from;  
    }  
    return a;  
}  
  
int Maxflow(int s, int t){  
    int flow = 0;  
    bfs(t,s);                //逆向bfs    
    memset(num,0,sizeof(num));  
    for (int i=0; i<=n; i++) num[d[i]]++;   //注意此处i应该对应节点编号   
    int x = s;  
    memset(cur,0,sizeof(cur));  
    while (d[s] < n+1){          //此处d[s]应下于节点数量
        if (x == t){  
            flow += Augment(s,t);  
            x = s;  
        }  
        int ok = 0;  
        for (int i=cur[x]; i<G[x].size(); i++){  
            Edge& e = edges[G[x][i]];  
            if (e.cap > e.flow && d[x] == d[e.to] + 1){  
                ok = 1;  
                p[e.to] = G[x][i];  
                cur[x] = i;  
                x = e.to;  
                break;  
            }  
        }  
        if (!ok){  
            int m = n-1;  
            for (int i=0; i<G[x].size(); i++){  
                Edge& e = edges[G[x][i]];  
                if (e.cap > e.flow) m = min(m,d[e.to]);  
            }  
            if (--num[d[x]] == 0) break;       //gap优化，能使时间复杂度降低100倍左右  
            num[d[x] = m+1]++;  
            cur[x] = 0;  
            if (x != s) x = edges[p[x]].from;  
        }  
    }  
    return flow;  
}  

int mark[MAX][MAX];

int main(){
	int cas,m;
	scanf("%d",&cas);
	while (cas--){
		scanf("%d%d",&n,&m);
		int x,y,l,c;
		init();
		int SS = 0,TT = n+1;
		addEdge(TT,SS,INF);               
		memset(mark,0,sizeof(mark));
		for (int i=0; i<m; i++){        //拆边
			scanf("%d%d%d%d",&x,&y,&l,&c);
			mark[x][y] = 1;
			F[x][y] = (Node){l,c};
			addEdge(x,y,c-l);
			addEdge(x,TT,l);
			addEdge(SS,y,l);
		}
		n = TT;
		int ans = Maxflow(SS,TT);
	//	printf("ans = %d\n",ans);
		int ok = 1;
		for (int i = 0; i<edges.size(); i++){    //判断是否有可行流
			Edge e = edges[i];
			if ((e.from == SS || e.to == TT) && e.cap > e.flow){
				ok = 0;
				break;
			}
		}
		if (ok){
			printf("YES\n");
			
			for (int i=0; i<edges.size(); i++){    //求解每条边的流量
				Edge e =edges[i];
				if (e.flow >= 0 && mark[e.from][e.to] && e.from != SS && e.to != TT)
					printf("%d\n",e.flow + F[e.from][e.to].l);
			}
		}
		else printf("NO\n");
		if (cas) printf("\n");
	}
	return 0;
}


有源有汇有上下界的最大流问题；

设源点为s,t；建立附加源点SS，附加汇点TT；

首先连边t->s，容量为无穷大使其转化为无源无汇问题；在对网络中的每一条边（u,v）按照无源无汇中的方法拆成三条边；

最后求一下SS->TT的最大流；可行流存在的条件以及原网络中的每条边的流量同上；

poj2396 有源有汇有上下界的最大流问题；

#include<cstdio>  
#include<cstring>  
#include<cmath>  
#include<cstdlib>  
#include<climits>  
#include<cctype>  
#include<iostream>  
#include<algorithm>  
#include<queue>  
#include<vector>  
#include<map>  
#include<set>  
#include<string>  
#include<stack>  
#define ll long long  
#define MAX 500  
#define eps 1e-8  
#define INF 100000000  
  
using namespace std;  

struct Node{
	int l,c;
}F[MAX][MAX];
  
struct Edge{  
    int from, to,cap,flow;  
};  
  
vector<int>G[MAX],T[MAX];  //T用来记录G的转置，用于下面逆向bfs遍历图  
vector<Edge>edges;  
  
int n;  
  
void init(){  
    for (int i=0; i<MAX; i++){  
        G[i].clear();  
        T[i].clear();  
    }  
    edges.clear();  
}  
  
void addEdge(int from, int to, int cap){  
    edges.push_back((Edge){from,to,cap,0});  
    edges.push_back((Edge){to,from,0,0});  
    int k = edges.size();  
    G[from].push_back(k-2);  
    G[to].push_back(k-1); 
	T[to].push_back(from); 
}  
  
int d[MAX];  
  
void bfs(int s, int t){  
    bool vis[MAX];  
    queue<int>q;  
    memset(vis,false,sizeof(vis));  
    q.push(s);  
    d[s] = 0;  
    vis[s] = true;  
    while (!q.empty()){  
        int u = q.front();  
        q.pop();  
        for (int i=0; i<T[u].size(); i++){  
            int v = T[u][i];  
            if (!vis[v]){  
                d[v] = d[u] + 1;  
                vis[v]  =  true;  
                q.push(v);  
            }  
        }  
    }  
}  
  
int p[MAX],num[MAX],cur[MAX];  
  
int Augment(int s, int t){  
    int x = t, a = INF;  
    while (x != s){  
        Edge& e = edges[p[x]];  
        a = min(a,e.cap - e.flow);  
        x = edges[p[x]].from;  
    }  
    x = t;  
    while (x != s){  
        edges[p[x]].flow += a;  
        edges[p[x]^1].flow -= a;  
        x = edges[p[x]].from;  
    }  
    return a;  
}  
  
int Maxflow(int s, int t){  
    int flow = 0;  
    bfs(t,s);                //逆向bfs    
    //printf("ok1\n");
    memset(num,0,sizeof(num));  
    for (int i=0; i<=n; i++) num[d[i]]++;
    int x = s;  
    memset(cur,0,sizeof(cur));  
    while (d[s] < n+1){     //小于节点数目 
        if (x == t){  
            flow += Augment(s,t);  
            x = s;  
        }  
        int ok = 0;  
        for (int i=cur[x]; i<G[x].size(); i++){  
            Edge& e = edges[G[x][i]];  
            if (e.cap > e.flow && d[x] == d[e.to] + 1){  
                ok = 1;  
                p[e.to] = G[x][i];  
                cur[x] = i;  
                x = e.to;  
                break;  
            }  
        }  
        if (!ok){  
            int m = n-1;  
            for (int i=0; i<G[x].size(); i++){  
                Edge& e = edges[G[x][i]];  
                if (e.cap > e.flow) m = min(m,d[e.to]);  
            }  
            if (--num[d[x]] == 0) break;       //gap优化，能使时间复杂度降低100倍左右  
            num[d[x] = m+1]++;  
            cur[x] = 0;  
            if (x != s) x = edges[p[x]].from;  
        }  
    }  
    return flow;  
}  

int l[MAX][MAX],r[MAX][MAX],res[MAX][MAX],a[MAX],b[MAX],m;

bool judge(){
     for (int i=1; i<=n; i++)
         for (int j=1; j <= m; j++)
             if (r[i][j] < l[i][j]) return false;
     return true;
}

int main(){
	int cas;
	scanf("%d",&cas);
	while (cas--){
		init();
		scanf("%d%d",&n,&m);
		int s = n+m+1, t = n+m+2;
		int SS = 0, TT = n+m+3;
		addEdge(t,s,INF);          //注意添边t->s（原汇点到原源点），容量为无穷大 
		for (int i=1; i<=n; i++){
			scanf("%d",&a[i]);
			addEdge(SS,i,a[i]);
			addEdge(s,i,0);
			addEdge(s,TT,a[i]);
		}
		for (int i=1; i <= m; i++){
			scanf("%d",&b[i]);
			addEdge(SS,t,b[i]);
			addEdge(i+n,t,0);
			addEdge(i+n,TT,b[i]);
		}
		int x,y,z;
		char st[5];
		for (int i=1; i<=n; i++)
			for (int j = 1; j<=m; j++){
				l[i][j] = 0;
				r[i][j] = min(a[i],b[j]); 
			}
		int cc;
		scanf("%d",&cc);
		while (cc--){
			scanf("%d%d%s%d",&x,&y,st,&z);
			if (st[0] == '>'){
				if (x == 0 && y == 0){
					for (int i = 1; i <= n; i++)
						for (int j=1; j <= m; j++){
							l[i][j] = max(l[i][j],z+1);
						}
				}
				else if (x == 0){
					for (int i=1; i<=n; i++){
						l[i][y] = max(l[i][y],z+1);
					}
				}
				else if (y == 0){
					for (int i=1; i<=m; i++){
						l[x][i] = max(l[x][i],z+1);
					}
				}
				else{
					l[x][y] = max(l[x][y],z+1);
				}
			}
			else if (st[0] == '<'){
				if (x == 0 && y == 0){
					for (int i=1; i<=n; i++)
						for (int j = 1; j<=m; j++){
							r[i][j] = min(r[i][j],z-1);
						}
				}
				else if (x == 0){
					for (int i = 1; i<=n; i++){
						r[i][y] = min(r[i][y],z-1);
					}
				}
				else if (y == 0){
					for (int i = 1; i<=m; i++){
						r[x][i] = min(r[x][i],z-1);
					}
				}
				else {
					r[x][y] = min(r[x][y],z-1);
				}
			}
			else{
				if (x == 0 && y == 0){
					for (int i=1; i<=n; i++){
						for (int j=1; j<=m; j++){
                            l[i][j] = max(l[i][j],z);
                            r[i][j] = min(r[i][j],z);
                        }
					}
				}
				else if (x == 0){
                      for(int i = 1; i <= n; i++){
                              l[i][y] = max(l[i][y],z);
                              r[i][y] = min(r[i][y],z);
                      }
                }
                else if (y == 0){
                     for (int i = 1; i<=m; i++){
                         l[x][i] = max(l[x][i],z);
                         r[x][i] = min(r[x][i],z);
                     }
                }
                else {
                     l[x][y] = max(l[x][y],z);
                     r[x][y] = min(r[x][y],z);
                }              
			}
		}
		if (!judge()){
             printf("IMPOSSIBLE\n");
             if (cas) printf("\n");
             continue;
        }
		for (int i=1; i <= n; i++)
		    for (int j = 1; j <= m; j++){
                addEdge(SS,j+n,l[i][j]);
                addEdge(i,j+n,r[i][j] - l[i][j]);
                addEdge(i,TT,l[i][j]);
            }
        int nt = n;
        n = TT;
        Maxflow(SS,TT);
        int ok = 1;
        for (int i = 0; i<edges.size(); i++){
            Edge e = edges[i];
            int u = e.from;
            int v = e.to;
            if ((u == SS || v == TT) && e.flow != e.cap ){
                   ok = 0;
                   break;
            }
        }
        if (!ok){
            printf("IMPOSSIBLE\n");
            if (cas) printf("\n");
            continue;
        }
        for (int i = 0; i<edges.size(); i++){
            Edge e = edges[i];
            int u = e.from;
            int v = e.to;
            res[u][v] = e.flow;
        }
        for (int i=1; i<=nt; i++){
            printf("%d",res[i][1+nt] + l[i][1]);
            for (int j = 2; j<=m; j++) printf(" %d",res[i][j+nt]+l[i][j]);
            printf("\n");
        }
        if (cas) printf("\n");
	}
	return 0;
}














【网络流】最大流：点带需求的流通、边带下界的流通
mmc2015的专栏
11-05 2492
1）点带需求的流通： 新的框架特点：有多个供给点（d(v)0），都称作汇点。同时仍然满足传统最大流中的容量条件（0 需要解决的问题：由于有多个源点和汇点，所以不再考虑最大化问题，而是考虑有没有满足容量条件和需求条件的一个可行流通（可行性）。 判断可行性的方法是，把带需求{ d(v) }的可行流通问题转换为在另一个网络中找最大 s-t 流的问题。另一个网络的构造方法如下：
最大流最小费用问题转换为线性规划问题求解(附代码)
m0_74731893的博客
06-30 1158
现需要将城市s的石油通过管道运送到城市t ，中间有4个中转站 v1 ,v2 ,v3 和 v4 ，由于输油管道的长短不一或地质等原因，每条管道上运输费用也不相同，因此，除考虑输油管道的最大流外，还需要考虑输油管道输送最大流的最小费用。城市与中转站的连接以及管道的容量和运费如下图，其中第1个数字是网络的容量，第2个数字是网络的单位运费。符号说明流过管道(u,v)的流量管道(u,v)的容量管道(u,v)的单位运费E管道集合V中转站集合。
网络流入门3——有上下界的最大流
20164225的博客
01-31 764
如果流网络中每条边e对应两个数字B(e)和C(e),分别表示该边上的流量至少要是B(e)，最多C(e), 那么，在这样的流网络上求最大流，就是有上下界的最大流问题。  这种网络不一定存在可行流   ?思路：将下界“分离”出去，使问题转换为下界为０的普通网络流问题。  将原弧(u,v)分离出一条必要弧：   由于必要弧的有一定要满流的限制，将必要弧“拉”出来集中考虑：  添加附加点x,
网络流：有上下界的最大流
Khasehemwy的博客
02-02 695
有上下界的意思： 每条管道的流量必须在范围 [L,R] 内，即在普通最大流问题上增加了下界限制。 主要分为无源点汇点和有源点汇点两类问题。 1.无源汇点有上下界的最大流 此类问题一般为：给n个点，及m根pipe，每根pipe用来流躺液体的，单向的，每时每刻每根pipe流进来的物质要等于流出去的物质，要使得m条pipe组成一个循环体，里面流躺物质。并且满足每根pipe一定的流量限制，范围为[Li,Ri].即要满足每时刻流进来的不能超过Ri(最大流问题)，同时最小不能低于Li。 解决：普通的最大流可以视作下界为
有流量上下界的最大流最小流算法实现
03-04
有流量上下界的最大流和最小流
上下限最大流
weixin_34365417的博客
11-06 177
一、有上下限的最大流：首先，每条边的下限是必须要满足的。增加附加源点S和附加汇点T，原来的源点和汇点为s和t。对于原图G(s,t,low[u][v],high[u][v])构建相应的新图D(S,T,E)，E包括,<t,s,INF>,<S,i,in[i]>,<i,T,out[i]>,<u,v,high[u][v]-low[u][v]>。其中,in[i]...
有源汇带上下界最大流
Destiny
01-13 339
有源汇带上下界最大流 　　Loj 模板 　　本题的网络有源有汇，且每条边有上下界，求最大流。 　　其实就算是有源汇，普通的dinic还是处理有上下界的情况。因此，问题仍需要转化。其实，我们可以在t到s连接一条容量为无穷大的边，那么网络就变成了无源汇的
转换网络流求解最大流：去除下界与可改进路径法
本文主要讨论了如何通过构造不含下界的网络流图来寻找最大流的问题，这一过程被称为"可行流算法"。在运输网络中，例如公路运输图，问题的核心是确定在有限的运输能力下，如何最大化从源点S向汇点T运输物资。网络流图...
37、随机最小割与最大流问题的代数方法
star的博客
06-08 31
本文研究了随机最小割与最大流问题的代数求解方法。传统的确定性网络流模型在实际应用中存在容量固定不变的局限，而随机网络流模型更贴近现实，其中弧的容量遵循概率分布。文章提出了一种基于生成函数和布尔运算的代数方法，用于精确计算最小割容量的分布，并进一步推导出最大流值的概率分布。此外，还介绍了通过路径枚举和无环网络算法获得上下边界分布的技术，适用于在计算精度和效率之间进行权衡。该方法为运输、通信、调度等实际网络问题提供了新的分析工具。
4、最大流算法、加权最短路径算法与设施定位问题的最新进展
最新发布
a3b4c5的博客
09-04 22
本文综述了最大流算法、加权最短路径算法和设施定位问题的最新研究进展。在最大流算法方面，回顾了从早期增广路径法到现代阻塞流与容量缩放技术的发展，并介绍了Goldberg-Rao等高效算法的创新点；在加权最短路径算法中，重点分析了基于Steiner点离散化多面体并构建图G及其子图G*来求解近似最短路径的方法；对于设施定位问题，探讨了在动态距离函数模型下K-中心问题的挑战，特别是在两时间片和多时间片场景中的近似算法设计。文章还总结了各领域的关键技术与复杂度，并指出未来研究方向，如缩小多项式差距、优化几何参数依赖及
POJ 2396 Budget 带下界的最大流 Dinic
Join Hands
07-12 1821
参考：http://hi.baidu.com/%CD%F4%BD%ADwangjiang/blog/item/aa3bc8ec3d549edbb31cb1a3.html http://apps.hi.baidu.com/share/detail/31832477题意:现在有一个n
有源汇有上下界的最大流
weixin_30273501的博客
08-10 169
ZOJ--3229 Shoot the Bullet Time Limit: 2 Seconds Memory Limit: 32768 KB Special Judge Gensokyo is a world which exists quietly beside ours, separated by a mystical border. It is a utopia wh...
SGU194 Reactor Cooling 有下界最大流
Colin_27的专栏
08-06 1242
学习别人的方法。大致是： 无源汇的最大流 ： 新建源点，汇点，sum[i]为每个点进来的下界流之和减去出去的下界流之和，如果sum[i] > 0，由源点向该点建一条边，上界为sum[i]，下界为0 如果sum[i] #include #include #include #include #include #include #include #include #inc
POJ2396 Budget 【带下界的最大流】
长风的专栏
10-03 1301
Budget Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 5962   Accepted: 2266   Special Judge Description We are supposed to make a budget proposal for th
POJ 2396 有源汇上下界最大流
I will Do iT @ hlyblog.net
08-15 1642
最大流， X 集合为行， Y集合为列
loj116(有源汇有上下界最大流)
qkoqhh
04-06 501
这个问题其实是能转化成无源汇有上下界最大流，在原图基础上加一条从t到s的无限容量的边，就能转化成循环流了。。 按无源汇有上下界最大流建图跑最大流判断能否达到下限的要求，此时整图应形成了循环流，而t到s的流量代表了从s到t的总流量（如果没有t到s的边的话）那么去掉t到s，还剩余一些自由流量，在原有流量的基础上再将自由流量跑满即可。。 /** *　　　　　　　　┏┓　　 　┏
ZOJ 3229 Shoot the Bullet 有源有汇带下界的最大流
万事屋
07-18 983
题意： n天里给m个人拍照 每个人各自至少要拍Gx张 然后n天内，每天给c个人拍照，当天最多拍d张。c个人 T代表编号，l代表当天给这人拍照的下限，r是上限。 不行输出-1，可以输出最多n天拍多少张照片，按T输入顺序，输出该人 改天拍了几张。 做法： 按有源有汇带下界的网络流模型建模即可。 然后要查个流量来判断 该人该天拍了多少张照片，所以，我先建的是 每天和人之间的边。
LOJ - #116. 有源汇有上下界最大流(有源汇有上下界的最大流)
Falcon的博客
09-01 531
题目链接：点击查看 题目大意：给出一个 n 个点和 m 条边的有向图，每条边都有一个流量限制 [ lower , upper ]，给定源点 s 和汇点 t ，求出源点到汇点的最大流 题目分析：参考博客：https://zybuluo.com/xiaoziyao/note/1694812 无源汇上下界可行流： 统计每个点的入度 in[ x] 和出度 out[ x]，即连向 x 的流量之和与连出 x 的流量之和 对于每条原来的边，流量设置为 upper - lower 设置虚拟源点 st 和虚拟..
[bzoj3698]XWW的难题——有上下界的最大流
ylsoi的博客
07-29 345
题目大意： XWW是个影响力很大的人，他有很多的追随者。这些追随者都想要加入XWW教成为XWW的教徒。但是这并不容易，需要通过XWW的考核。 XWW给你出了这么一个难题：XWW给你一个N*N的正实数矩阵A，满足XWW性。 称一个N*N的矩阵满足XWW性当且仅当：（1）A[N][N]=0；（2）矩阵中每行的最后一个元素等于该行前N-1个数的和；（3）矩阵中每列的最后一个元素等于该列前N-1个数...
网络优化：最大流问题详解
"最大流问题及所有本章节问题" 最大流问题是一个经典的图论问题，它在计算机科学和运筹学中具有广泛的应用。该问题源于实际生活中的许多场景，例如公路交通流量分配、数据包在网络中的传输等。在这个问题中，我们有...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值