HDU4322 Candy（费用流）

最新推荐文章于 2020-06-15 21:34:19 发布

Michael_GLF

最新推荐文章于 2020-06-15 21:34:19 发布

阅读量164

点赞数

分类专栏： ————图论———— 网络流 Let's Network Flow!

本文链接：https://blog.csdn.net/g21glf/article/details/83006153

版权

————图论———— 同时被 3 个专栏收录

57 篇文章 1 订阅

订阅专栏

网络流

31 篇文章 0 订阅

订阅专栏

Let's Network Flow!

29 篇文章 0 订阅

订阅专栏

题目传送门：http://acm.hdu.edu.cn/showproblem.php?pid=4322

【题目大意】

给你N个糖果，M个小朋友，给你一个M*N的矩阵S，S[i][j]表示第i个小朋友拿到第j块糖产生的“喜好”x(x=0或1)，如果喜好为1，那么如果分给这个小朋友这颗糖，那么他会得到K的高兴值，如果分给一个小朋友他不喜欢的糖，那么他会获得1高兴值。

给你M个数Bi，现询问能否找到一种分配方案使所有小朋友获得的高兴值不小于Bi。

【输入格式】

第一行为一个整数T，表示测试组数。

接下来T组数据，每一组第一行为三个整数N,M,K。

接下来一行为M个整数，表示Bi。

接下来是一个M*N的矩阵，含义见题目大意。

【输出格式】

对于每一组数据，如果可以使所有人的高兴值大于Bi，那么输出“Yes”，否则输出"No"。

【样例输入】

3 2 2

2 2

0 0 0

0 0 1

3 2 2

2 2

0 0 0

【样例输出】

Yes

【备注】

N,M<=13，K<=100

【题目分析】

感谢xly大佬的纠正（不然我有可能调一年啊，先是SPFA的vis没有清空，然后费用流忘写work数组，然后答案全输成大写。。。。。。完了我学的可能是假的费用流，xly大佬的博客：https://blog.csdn.net/weixin_42557561）

好了扯回来讲讲正解。一开始拿到这道题的时候，能看出来这是一个最大匹配的模型，但难就难在如何匹配。

首先肯定还是所有糖果向源点连一条容量为1的边，然后对于每个非喜爱糖果，那么他的贡献就只有1，我们当然希望每颗糖能够做出更多的贡献，所以我们可以暂时不考虑非喜爱糖果，最后剩下的糖果，肯定对于所有还没达到Bi的小朋友，没人喜欢，所以就一个一个的补，如果能补满，那么就可行，否则不行。

然后就考虑喜爱糖果的连边，因为一颗糖果可以产生K的高兴值，那么一个小朋友最多匹配(bi/k)+1次，但我们发现，如果bi%k！=0，那么匹配bi/k次后，他就会有个剩余bi%k，那么如果我们再用一个喜爱糖果去填，那么他就会产生一个超出，所以我们先将该糖果与小朋友之间连一条容量为bi/k，费用为k的边，然后对于这个剩余，我们分两种情况：

1.bi%k==1，这时候1个喜爱糖果和1个非喜爱糖果产生的效果一样，那么可以用一个非喜爱糖果去填，可以跳过不连边。

2.bi%k>1，连第二条边。但如果我们只考虑容量，就无法保证选择次数，所以这里加入费用，整个图变成费用流，那么一开始连的边费用就设为0，这里连的边就容量为1，保证只选一次，费用为b[i]%k的边。但这时候有个小问题：在SPFA的时候这条边因为费用小于费用为k的边，所以可能导致费用为k的边还未流满，该条边就已经流满了，这样是非法的，因为你流的第一块糖果（如果bi/k>=1）一定会产生k的贡献，但你只记了bi%k的贡献。记住：只有最后一块会产生bi%k的贡献，这样理解就行了。所以在SPFA增广最短路的时候，我们要先增广到费用为k的边，所以我们将费用取个相反数再跑最小费用流，最后得到的费用再取反就是最大费用（因为贪心思想，我们希望喜爱糖果产生的贡献要尽可能多），最后再比较一下剩下的糖果数和剩下的待贡献值即可。

（口胡完毕，如果有错请各位大佬指正）

【代码~】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
#include<cstdlib>
using namespace std;
const int MAXN=100;
const int MAXM=1e3+10;
const int INF=0x3f3f3f3f;

int n,m,k,cnt,s,t,cost,sum;
int head[MAXN],cur[MAXN],dis[MAXN],vis[MAXN];
int work[MAXN];
int nxt[MAXM],to[MAXM],w[MAXM],c[MAXM];

void Add(int x,int y,int z,int v)
{
	nxt[cnt]=head[x];
	head[x]=cnt;
	to[cnt]=y;
	w[cnt]=z;
	c[cnt]=v;
	cnt++;
}

void add(int x,int y,int z,int v)
{
	Add(x,y,z,v);
	Add(y,x,0,-v);
}

bool SPFA()
{
	queue<int> q;
	memset(dis,INF,sizeof(dis));
	memset(work,0,sizeof(work));
	memset(vis,0,sizeof(vis));
	dis[s]=0;
	q.push(s);vis[s]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=head[u];i!=-1;i=nxt[i])
		{
			int v=to[i];
			if(dis[v]>dis[u]+c[i]&&w[i])
			{
				dis[v]=dis[u]+c[i];
				if(!vis[v])
				{
					vis[v]=1;
					q.push(v);
				}
			}
		}
	}
	if(dis[t]==INF)
	  return false;
	return true;
}

int dfs(int u,int dist)
{
	if(u==t)
	{
		cost+=dist*dis[t];
		return dist;
	}
	int res=0;
	work[u]=1;
	for(int &i=cur[u];i!=-1;i=nxt[i])
	{
		int v=to[i];
		if(dis[v]==dis[u]+c[i]&&w[i]&&!work[v])
		{
			int di=dfs(v,min(dist-res,w[i]));
			if(di)
			{
				w[i]-=di;
				w[i^1]+=di;
				res+=di;
				if(res==dist)
				  break;
			}
		}
	}
	return res;
}

int dinic()
{
	int maxf=0;
	while(SPFA())
	{
		for(int i=s;i<=t;++i)
		  cur[i]=head[i];
	    maxf+=dfs(s,INF);
	}
	return maxf;
}

int main()
{

	int cas=1;
	int tt;
	scanf("%d",&tt);
	while(tt--)
	{
		scanf("%d%d%d",&n,&m,&k);
		memset(head,-1,sizeof(head));
		memset(nxt,-1,sizeof(nxt));
		cnt=2,sum=0,cost=0;
		s=0,t=n+m+1;
		for(int i=1;i<=n;++i)
		  add(s,i,1,0);
		for(int i=1;i<=m;++i)
		{
			int x;
			scanf("%d",&x);
			sum+=x;
			add(n+i,t,x/k,-k);
			if(x%k>1)
			  add(n+i,t,1,-x%k);
		}
		for(int i=1;i<=m;++i)
		{
			for(int j=1;j<=n;++j)
			{
				int x;
				scanf("%d",&x);
				if(x)
				  add(j,n+i,1,0);
			}
		}
		int flow=dinic();
		int tmp=-cost;
		if(n-flow>=sum-tmp)
		  cout<<"Case #"<<cas<<": "<<"YES"<<'\n';
		else
		  cout<<"Case #"<<cas<<": "<<"NO"<<'\n';
		cas++;
	}
	return 0;
}