福州oj--2232--炉石传说(最大匹配||最大流)



                                              Problem 2232 炉石传说

Accept: 19    Submit: 49
Time Limit: 1000 mSec    Memory Limit : 32768 KB

 Problem Description

GG学长虽然并不打炉石传说，但是由于题面需要他便学会了打炉石传说。但是传统的炉石传说对于刚入门的GG学长来说有点复杂，所以他决定自己开发一个简化版的炉石传说。

在简化版的炉石传说中：

每个随从只有生命值和攻击力，并且在你的回合下，你的每只随从在本回合下只能选择一个敌方随从进行攻击。当两个随从a，b交战时，a的生命值将减去b的攻击力，b的生命值将减去a的攻击力，（两个伤害没有先后顺序，同时结算）。如果a或b的生命值不大于0，该随从将死亡。

某一次对局中，GG学长和对手场面上均有n个随从，并且是GG学长的回合。由于GG学长是个固执的boy，他一定要在本回合杀死对方所有随从，并且保证自己的随从全部存活。他想知道能否做到。

 Input

第一行为T，表示有T组数据。T<=100。

每组数据第一行为n，表示随从数量(1 <= n <= 100)

接下来一行2 * n个数字a1, b1, a2, b2, ... , an, bn (1 <= ai, bi <= 100)

表示GG学长的n个随从，ai表示随从生命，bi表示随从攻击力

接下来一行2 * n个数字c1, d1, c2, d2, ... , cn, dn (1 <= ci, di <= 100)

表示对手的n个随从，ci表示随从生命，di表示随从攻击力。

 Output

每组数据，根据GG是否能完成他的目标，输出一行”Yes”或”No”。

 Sample Input

2
3
4 4 5 5 6 6
1 1 2 2 3 3
3
4 4 5 5 6 6
1 4 2 4 3 4

 Sample Output

Yes
No

 Source

福州大学第十三届程序设计竞赛

完美匹配

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
#define MAXN 100000+10
struct node
{
	int x,y;
}p[1010],q[1010];
vector<int>G[10000];
int pipei[MAXN],used[MAXN],n,m;
int find(int u)
{
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		if(!used[v])
		{
			used[v]=1;
			if(pipei[v]==-1||find(pipei[v]))
			{
				pipei[v]=u;
				return 1;
			}
		}
	}
	return 0;
}
int main()
{
	int n,m;
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		G[i].clear();
		memset(pipei,-1,sizeof(pipei));
		for(int i=1;i<=n;i++)
		scanf("%d%d",&p[i].x,&p[i].y);
		for(int j=1;j<=n;j++)
		scanf("%d%d",&q[j].x,&q[j].y);
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				if(p[i].x>q[j].y&&p[i].y>=q[j].x)
				{
					G[i].push_back(j+n);
				}
			}
		}
		int ans=0;
		for(int i=1;i<=n;i++)
		{
			memset(used,0,sizeof(used));
			ans+=find(i);
		}
		if(ans==n)
			printf("Yes\n");
		else
			printf("No\n");
	}
	return 0;
}

也用最大流写了，很水的最大流，判断是否满流就行

#include<stdio.h>
#include<string.h>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
#define MAX 2100
#define INF 10000000+10
int head[MAX*100],cur[MAX*100];
int dis[MAX*100],vis[MAX*100];
int m,n,top;
struct node
{
	int u,v,cap,flow,next;
}edge[MAX*100];
struct Node 
{
	int x,y;
}p[10100],q[10100];
void init()
{
	top=0;
	memset(head,-1,sizeof(head));
}
void add(int a,int b,int c)
{
	node E1={a,b,c,0,head[a]};
	edge[top]=E1;
	head[a]=top++;
	node E2={b,a,0,0,head[b]};
	edge[top]=E2;
	head[b]=top++;
}
void getmap()
{
	int a,b,c;
	for(int i=1;i<=n;i++)
	scanf("%d%d",&p[i].x,&p[i].y);
	for(int j=1;j<=n;j++)
	scanf("%d%d",&q[j].x,&q[j].y);
	for(int i=1;i<=n;i++)
	{
		add(0,i,1);
		for(int j=1;j<=n;j++)
		{
			if(p[i].x>q[j].y&&p[i].y>=q[j].x)
			add(i,j+n,1);
		}
	}
	for(int j=1;j<=n;j++)
	add(j+n,2*n+1,1);
}
bool bfs(int s,int e)
{
	queue<int>q;
	memset(dis,-1,sizeof(dis));
	memset(vis,0,sizeof(vis));
	vis[s]=1;
	dis[s]=0;
	while(!q.empty()) q.pop();
	q.push(s);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=head[u];i!=-1;i=edge[i].next)
		{
			node E=edge[i];
			if(!vis[E.v]&&E.cap>E.flow)
			{
				vis[E.v]=1;
				dis[E.v]=dis[E.u]+1;
				if(E.v==e)
				return true;
				q.push(E.v);
			}
		}
	}
	return false;
}
int dfs(int x,int a,int e)
{
	if(x==e||a==0)
	return a;
	int flow=0,f;
	for(int i=cur[x];i!=-1;i=edge[i].next)
	{
		node& E=edge[i];
		if(dis[x]+1==dis[E.v]&&(f=dfs(E.v,min(a,E.cap-E.flow),e))>0)
		{
			E.flow+=f;
			edge[i^1].flow-=f;
			flow+=f;
			a-=f;
			if(a==0) break;
		}
	}
	return flow;
}
int MAXflow(int s,int e)
{
	int flow=0;
	while(bfs(s,e))
	{
		memcpy(cur,head,sizeof(cur));
		flow+=dfs(s,INF,e);
	}
	return flow;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		init();
		getmap();
		if(MAXflow(0,2*n+1)==n)
			printf("Yes\n");
		else
			printf("No\n");
	}
	return 0;
}