【消圈】poj2175

最新推荐文章于 2020-04-08 21:02:18 发布
最新推荐文章于 2020-04-08 21:02:18 发布
阅读量829 收藏
点赞数
分类专栏： poj 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huyuncong/article/details/15505505
版权
图论 同时被 2 个专栏收录
48 篇文章 0 订阅
订阅专栏
poj
9 篇文章 0 订阅
订阅专栏

poj2175只用到了一次找负圈，因此比较快，如果一直找下去，效率应该很低

首先是用拓展km直接做——375ms

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
const int oo=1073741819;
using namespace std;
int x[500],y[500],p[500],q[500];
int a[500],b[500],lx[500],ly[500],vx[500],vy[500];
int f[500],g[500],slack[500],w[500][500],c[500][500];
int n,m;
bool km(int x)
{
	if (vx[x]) return 0;
	vx[x]=1;
	for (int i=1;i<=m;i++) {
		if (vy[i]) continue;
		int tmp=lx[x]+ly[i]-w[x][i];
		if (!tmp) {
			vy[i]=1;
			if (b[i]) {
				f[x]=i,g[x]=0;
				return 1;
			}
			for (int j=1;j<=n;j++)
				if (c[j][i] && km(j)) {
					f[x]=i,g[x]=j;
					return 1;
				}
		}
		else slack[i]=min(slack[i],tmp);
	}
	return 0;
}
int push(int x)
{
	int d=a[x];
	for (int i=x;i;i=g[i]) {
		if (g[i]) d=min(d,c[g[i]][f[i]]);
		else d=min(d,b[f[i]]);
	}
	int sum=0;
	a[x]-=d;
	for (int i=x;i;i=g[i]) {
		if (g[i]) sum-=d*w[g[i]][f[i]],c[g[i]][f[i]]-=d;
		else b[f[i]]-=d;
		sum+=d*w[i][f[i]],c[i][f[i]]+=d;
	}
	return sum;
}
int main()
{
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
	for (;scanf("%d%d",&n,&m)==2;) {
		for (int i=1;i<=n;i++) {
			scanf("%d%d%d",&x[i],&y[i],&a[i]);
			lx[i]=0,ly[i]=0;
		}
		for (int i=1;i<=m;i++)
			scanf("%d%d%d",&p[i],&q[i],&b[i]);
		for (int i=1;i<=n;i++)
			for (int j=1;j<=m;j++) {
				w[i][j]=-(abs(x[i]-p[j])+abs(y[i]-q[j])+1);
				c[i][j]=0;
			}
		int tot=0;
		for (int i=1;i<=n;i++)
			for (int j=1;j<=m;j++) {
				int x;
				scanf("%d",&x);
				tot+=w[i][j]*x;
			}
		int ans=0;
		for (int i=1;i<=n;i++) {
			for (;a[i];) {
				for (int j=1;j<=m;j++) slack[j]=oo;
				for (;a[i];) {
					for (int j=1;j<=n;j++) vx[j]=0;
					for (int j=1;j<=m;j++) vy[j]=0;
					if (km(i))
						ans+=push(i);
					else break;
				}
				if (!a[i]) break;
				int d=oo;
				for (int j=1;j<=m;j++) 
					if (!vy[j]) d=min(d,slack[j]);
				for (int j=1;j<=n;j++)
					if (vx[j]) lx[j]-=d;
				for (int j=1;j<=m;j++)
					if (vy[j]) ly[j]+=d;
			}
		}
		if (ans==tot) printf("OPTIMAL\n");
		else {
			printf("SUBOPTIMAL\n");
			for (int i=1;i<=n;i++) {
				for (int j=1;j<m;j++) printf("%d ",c[i][j]);
				printf("%d\n",c[i][m]);
			}
		}
	}
	return 0;
}

然后是原始对偶费用流直接做,tle,本机1.3s+，如果常数再小点不知能不能过 

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
const int oo=1073741819;
using namespace std;
int b[500][500],flow[500][500],c[500][500];
int B[4096],n,m,s,t,ans,phi,w_time,m1;
int x[500],y[500],p[500],q[500],d[500];
int w[500][500],flag[500];
void change(int x,int w)
{
	d[x]=w;
	for (x=((x+m1)>>1);x;x>>=1)
		if (d[B[x<<1]]>d[B[(x<<1)^1]]) B[x]=B[(x<<1)^1];
		else B[x]=B[x<<1];
}
bool spfa(int s,int t)
{
	int ne,na;
	for (int i=0;i<=t;i++) d[i]=p[i]=oo;
	change(t,0),p[t]=0;
	for (;d[B[1]]!=oo;) {
		ne=B[1];
		change(ne,oo);
		for (int i=1;i<=b[ne][0];i++) {
			na=b[ne][i];
			if (flow[na][ne] && p[ne]+c[na][ne]<p[na]) {
				p[na]=p[ne]+c[na][ne];
				change(na,p[na]);
			}
		}
	}
	if (p[s]>=oo) return 0;
	phi+=p[s];
	for (int i=1;i<=t;i++) 
		for (int j=1;j<=b[i][0];j++) {
			ne=b[i][j];
			c[i][ne]-=p[i]-p[ne];
		}
	return 1;
}
int dfs(int x,int low)
{
	if (t==x) {
		ans+=phi*low;
		return low;
	}
	int sum=0,tmp,ne;
	flag[x]=w_time;
	for (int i=1;i<=b[x][0];i++) {
		ne=b[x][i];
		if (flow[x][ne] && flag[ne]!=w_time && !c[x][ne]) {
			if (flow[x][ne]<low) tmp=dfs(ne,flow[x][ne]);
			else tmp=dfs(ne,low);
			flow[x][ne]-=tmp,flow[ne][x]+=tmp,sum+=tmp,low-=tmp;
			if (!low) break;
		}
	}
	return sum;
}
void origin()
{
	s=n+m+1,t=s+1;
	for (int i=1;i<=t;i++) b[i][0]=0;
	for (m1=1;m1<=t+2;m1<<=1) ;
	for (int i=1;i<=t;i++) B[i+m1]=i;
}
void link(int x,int y,int z,int cc)
{
	b[x][++b[x][0]]=y,flow[x][y]=z,c[x][y]=cc;
	b[y][++b[y][0]]=x,flow[y][x]=0,c[y][x]=-cc;
}
int main()
{
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
	for (;scanf("%d%d",&n,&m)==2;) {
		origin();
		for (int i=1;i<=n;i++) {
			int z;
			scanf("%d%d%d",&x[i],&y[i],&z);
			link(s,i,z,0);
		}
		for (int i=1;i<=m;i++) {
			int z;
			scanf("%d%d%d",&p[i],&q[i],&z);
			link(i+n,t,z,0);
		}
		for (int i=1;i<=n;i++)
			for (int j=1;j<=m;j++) {
				w[i][j]=abs(x[i]-p[j])+abs(y[i]-q[j])+1;
				link(i,j+n,oo,w[i][j]);
			}
		int tot=0;
		for (int i=1;i<=n;i++)
			for (int j=1;j<=m;j++) {
				int x;
				scanf("%d",&x);
				tot+=w[i][j]*x;
			}
		ans=0;
		for (phi=0;spfa(s,t);) 
			for (;w_time++,dfs(s,oo);) ;
		if (ans==tot) printf("OPTIMAL\n");
		else {
			printf("SUBOPTIMAL\n");
			for (int i=1;i<=n;i++) {
				for (int j=1;j<m;j++) printf("%d ",flow[j+n][i]);
				printf("%d\n",flow[m+n][i]);
			}
		}
	}
	return 0;
}

最后是找一次负圈，也并不比拓展km快 

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
const int oo=1073741819;
using namespace std;
int b[500][500],flow[500][500],c[500][500];
int n,m,s,t,ans;
int x[500],y[500],p[500],q[500],d[500],cnt[500],pre[500];
int w[500][500];
int st[2000000],v[500];
void origin()
{
	s=n+m+1,t=s+1;
	for (int i=1;i<=t;i++) b[i][0]=0;
}
void link(int x,int y,int z,int cc)
{
	b[x][++b[x][0]]=y,flow[x][y]=z,c[x][y]=cc;
	b[y][++b[y][0]]=x,flow[y][x]=0,c[y][x]=-cc;
}
bool spfa(int s,int t)
{
	int h,r,ne,na;
	h=r=0;
	for (int i=1;i<=t;i++) {
		d[i]=0;
		st[++r]=i,v[i]=1,pre[i]=0,cnt[i]=1;
	}
	for (;h<r;) {
		ne=st[++h];
		for (int i=1;i<=b[ne][0];i++) {
			na=b[ne][i];
			if (flow[ne][na] && d[ne]+c[ne][na]<d[na]) {
				d[na]=d[ne]+c[ne][na],pre[na]=ne;
				if (!v[na]) {
					v[na]=1,st[++r]=na;
					cnt[na]++;
					if (cnt[na]>t) return 1;
				}
			}
		}
		v[ne]=0;
	}
	return 0;
}
int widen()
{
	int k;
	for (int i=1;i<=t;i++) {
		if (cnt[i]>t) k=i;
		v[i]=0;
	}
	int r=0;
	int sum=0;
	for (;!v[k];k=pre[k]) v[k]=1;
	st[r=1]=k;
	for (int i=pre[k];i!=k;i=pre[i]) st[++r]=i;
	for (int i=1;i<=r;i++) {
		v[st[i]]=0;
		flow[pre[st[i]]][st[i]]--;
		flow[st[i]][pre[st[i]]]++;
		sum+=c[pre[st[i]]][st[i]];
	}
	return sum;
}
int main()
{
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
	for (;scanf("%d%d",&n,&m)==2;) {
		origin();
		for (int i=1;i<=n;i++) {
			int z;
			scanf("%d%d%d",&x[i],&y[i],&z);
			link(s,i,z,0);
		}
		for (int i=1;i<=m;i++) {
			int z;
			scanf("%d%d%d",&p[i],&q[i],&z);
			link(i+n,t,z,0);
		}
		for (int i=1;i<=n;i++)
			for (int j=1;j<=m;j++) {
				w[i][j]=abs(x[i]-p[j])+abs(y[i]-q[j])+1;
				link(i,j+n,oo,w[i][j]);
			}
		int tot=0;
		for (int i=1;i<=n;i++)
			for (int j=1;j<=m;j++) {
				int x;
				scanf("%d",&x);
				tot+=w[i][j]*x;
				flow[s][i]-=x,flow[i][j+n]-=x,flow[j+n][t]-=x;
				flow[i][s]+=x,flow[j+n][i]+=x,flow[t][j+n]+=x;
			}
		ans=tot;
		if (spfa(s,t)) ans+=widen();
		if (ans==tot) printf("OPTIMAL\n");
		else {
			printf("SUBOPTIMAL\n");
			for (int i=1;i<=n;i++) {
				for (int j=1;j<m;j++) printf("%d ",flow[j+n][i]);
				printf("%d\n",flow[m+n][i]);
			}
		}
	}
	return 0;
}


huyuncong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Poj2175(费用流,负环消圈)
ACM之梦
11-13 1703
挺好的题 充分利用了spfa 判断最费用流是否最优的充分必要条件是——图中是否存在负环  如果存在说明最费用流最优否则相反
poj 2175(费用流判负环+消环)
LSS
09-17 721
题意：给出n栋房子位置和每栋房子里面的人数，m个避难所位置和每个避难所可容纳人数。然后给出一个方案，判断该方案是否最优，如果不是求出一个更优的方案。 思路：很容易想到用最小费用流求出最优时间，在与原方案花费时间对比判断原方案是否最优。但是这种方法会超时的。 放弃该思路。 看看题目没要求要最优解，而是得到一个更优的解，那么如果在原图中能够找到一个总费用为负的回路的话，那就该解不是最优解，把该负环
消圈定理详解
favomj的博客
12-14 1967
消圈定理
poj 2175 费用流+消圈
Little_boy_z的博客
12-10 331
这道题如果直接费用流会超时。 题目只是让我们判断是否是最好的情况，我们只需要找到更好的一种情况即可，不需要求最好的。 也就是说按照最小费用流的做法，我们只需要在残余网络还能找到一个负圈的即可。这是充分必要条件，如果达到最优解，就没有负圈了。 所以我们按照题意建立图还有残余网络。之后判断图中是否存在一个负圈（spfa），如果存在则跳出，返回那个点。 当前那个点不一定在负圈当中，我们开始whi
poj 2175
OZY的博客
04-01 540
题意 n栋大楼，每个大楼里ni个人，m个避难所，每个避难所能容纳mi个人。每个建筑物都有坐标，每个人到达避难所的费用是距离+1。给了你一种安排，问这种安排是不是最优的。 题解 根据消圈定理 如果一个费用流的残留网络，他如果存在有一个负环 那么这个肯定不是最小费用流 因为你可以用这个负环去更新答案 反过来也是一样，如果没有负环，那么就是最小费用流 然后这题是一个模板题 我们考虑根据...
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ.rar_poj
09-19
【标题】"POJ.rar_poj" 指的是一份与编程竞赛相关的压缩文件，主要涉及POJ（Problem Overloading Judge）平台上的问题解答。POJ是一个在线的编程竞赛平台，它为参赛者提供了大量的算法题目进行练习和比赛，以提升...
POJ.rar_poj java_poj1048
09-24
在这个问题中，人们站成一个圈，并按照一定的顺序报数，报到特定数字的人会被排除出圈，然后从下一个人继续报数，直到只剩下最后一个人为止。加强版可能意味着有一些额外的条件或复杂性，比如多轮报数、不同步的报数...
POJ2175 费用流消负圈
lijijun12321的专栏
01-25 417
题意： n个房子，m个避难所，接下来n行，房子的坐标和人数，m行，避难所的坐标和容量，接下来n*m矩阵表示当前方案，房子 I 去避难所 j 的人数，问有没有更优方案。 思路：一开始直接用费用流，TLE了，后来想了很久不知道怎么做，看别人的博客，明白是个消圈问题，即判断从汇点到源点有无负圈，如果有则存在更优方案。现在还没完全理解，以后再补充。 链接：http://poj.org/
POJ2175_Evacuation Plan_消负圈的“更小”费用流
弱的奋斗之旅
06-24 422
消圈法与”更小“费用流
POJ2175-消圈算法
CY05627的博客
06-04 1175
题意： 题意:一个城市中有n个大楼，m个避难所，接下来给出n个大楼的坐标和人数，接下来m行给出每个避难所的坐标和容纳量，大楼到避难所的距离定义为曼哈顿距离+1，然后给出n行m列数据，第i行第j列代表从第i个大楼到第j个避难所去的人数，保证此方案合法，然后判断此方案是否所有人到避难所的距离和最小，是的话输出OPTIMAL，否则给出更好的方案，但不一定是最优的； 思路： 如果用最小费用最大流算法直接求...
POJ 2175 Evacuation Plan(网络流消负圈算法)
llzhh的博客
08-05 942
这是挑战上的一道题。 一开始看到这道题，我是直接套最小费用流上去写的，然后无限T。。。 后来看到，原来不是要找最优的情况，只需要输出一组答案比当前结果花费小即可。 然后看书，才知道有消负圈算法这种东西。 费用流中最优的网络是不存在负圈的，最最简单的理解就是， 可以看到上面这个图，我们费用流是在最大流的前提下找最小费用，但是上面这个图肯定不是最大流，s到t还有1个流量单位。 何为负圈
POJ 2175 Floyd-Warshall
neweryyy的博客
04-08 139
题意 传送门 POJ 2175 题解 流量过大，最小费用流跪了。题意只要求答案优于当前方案即可，用 Floyd-Warshall 在增光路上求负圈，沿着负圈增广即可得到费用更小的流。实现上考虑到所提供方案城市人数安排一一对应，则源点到城市的边满流，求负圈时源点可不考虑在内。 #include <cstdio> #include <cstring> #include <...
poj-2175 Evacuation Plan
ó
08-01 190
[题目链接] 思路： 题目要求输出比样例更优的任意一个解，用最小费用流建模求出最优解会TLE。 某个流f是同流量中的最小费用流，等价于f的残余网络中没有负圈。&lt;最小费用流的证明&gt; 构造残余网络，从汇点开始遍历，因为源点s发出的边满流了，即没有容量为0。用spfa算法找负圈，注意跳出的点不一定在负圈上（可能是与负圈有多个边相连的点，也会多次更新）！然后更新一下负圈上的点即可。 ...
poj 2175--指派问题
AndyTeen的专栏
03-29 1036
题意： n幢大楼，m个防空洞，给出每个大楼的人数和防空洞可容纳人数，以及大楼到防空洞费用的计算方式，给定一个方案，问是否总的费用最优（最小），若不是最优，给出一个更优的解。 思路： 典型的指派类问题，大楼和防空洞分别做点，并新增源点s,汇点t，s向每幢大楼连一条容量为大楼人数，费用为0的边，每幢大楼向每个防空洞连一条容量为inf ，费用为相应费用的边，每个防空洞向t点连一条容量为防空洞容量，
poj2175费用流消圈算法
墨鱼菜鸡
12-18 156
题意： 有n个建筑，每个建筑有ai个人，有m个避难所，每个避难所的容量是bi,ai到bi的费用是|x1-x2|+|y1-y2|+1,然后给你一个n*m的矩阵，表示当前方案，问当前避难方案是否是最优的，如果不是，输出一个比这个好的就行。 思路： 大体看一下题目，很容易想到费用流直接去弄，建...
POJ2175
Hellsegamosken
05-14 285
n 个建筑物 m 个避难所，每个建筑物有一定数量的人，每个避难所有一定的容量限制，每个人要跑到避难所里，代价为曼哈顿距离+1。给出一种疏散的方案，问是不是最优的。如果不是最优的，给出一个更优的方案。 n,m≤100n,m\leq 100n,m≤100 按照给定的方案构建残余网络，如果网络上有负环，就说明该方案不是最优的。沿着负环增广就可以获得一个更优的方案。 #include<cstdio&...
POJ 2175
weixin_44019404的博客
04-07 131
消负权法。 最小费用最大流的充要条件是，增广路没有负圈。 所以这道题就是找到一个负圈，然后绕着路自己增广一周就好了。 注意这里用的是，floyd算法去寻找负圈，要用类似链式储存的方式，来进行保存前面的节点。 #include<iostream> #include<cstring> #include<algorithm> #include<cmath>...
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值