Pahom on Water

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 772    Accepted Submission(s):
355

Problem Description

Pahom on Water is an interactive computer game inspired
by a short story of Leo Tolstoy about a poor man who, in his lust for land,
forfeits everything. The game‘s starting screen displays a number of circular
pads painted with colours from the visible light spectrum. More than one pad may
be painted with the same colour (defined by a certain frequency) except for the
two colours red and violet. The display contains only one red pad (the lowest
frequency of 400 THz) and one violet pad (the highest frequency of 789 THz). A
pad may intersect, or even contain another pad with a different colour but never
merely touch its boundary. The display also shows a figure representing Pahom
standing on the red pad.
The game‘s objective is to walk the figure of Pahom
from the red pad to the violet pad and return back to the red pad. The walk must
observe the following rules:
1.If pad α and pad β have a common intersection
and the frequency of the colour of pad α is strictly smaller than the frequency
of the colour of pad β, then Pahom figure can walk from α to β during the walk
from the red pad to the violet pad
2. If pad α and pad β have a common
intersection and the frequency of the colour of pad α is strictly greater than
the frequency of the colour of pad β, then Pahom figure can walk from α to β
during the walk from the violet pad to the red pad
3. A coloured pad, with
the exception of the red pad, disappears from display when the Pahom figure
walks away from it.
The developer of the game has programmed all the
whizzbang features of the game. All that is left is to ensure that Pahom has a
chance to succeed in each instance of the game (that is, there is at least one
valid walk from the red pad to the violet pad and then back again to the red
pad.) Your task is to write a program to check whether at least one valid path
exists in each instance of the game.

Input

The input starts with an integer K (1 <= K <= 50)
indicating the number of scenarios on a line by itself. The description for each
scenario starts with an integer N (2 <= N <= 300) indicating the number of
pads, on a line by itself, followed by N lines that describe the colors,
locations and sizes of the N pads. Each line contains the frequency, followed by
the x- and y-coordinates of the pad‘s center and then the radius. The frequency
is given as a real value with no more than three decimal places. The coordinates
and radius are given, in meters, as integers. All values are separated by a
single space. All integer values are in the range of -10,000 to 10,000
inclusive. In each scenario, all frequencies are in the range of 400.0 to 789.0
inclusive. Exactly one pad will have a frequency of “400.0” and exactly one pad
will have a frequency of “789.0”.

Output

The output for each scenario consists of a single line
that contains: Game is VALID, or Game is NOT VALID

Sample Input

2

2

400.0 0 0 4

789.0 7 0 2

4

400.0 0 0 4

789.0 7 0 2

500.35 5 0 2

500.32 5 0 3

Sample Output

Game is NOT VALID

Game is VALID

题意：一个电脑游戏，有各种颜色的光圈，题目要求你从红色光圈到紫色光圈再回到红色光圈（中间可已经经过其他颜色的光圈）光圈形状为圆形

要求：1、如果两个光圈相交，则可以从光谱大的走到光谱小的

2、紫色光圈和红色光圈可以走两次，别的颜色的只能走一次

问是否能够实现要求

题解：建立超级源点0，超级汇点n+1

1、紫色光圈连接源点权值为2

2、红色光圈连接汇点权值为2

3、其他颜色光圈  光谱大的连接到光谱小的，权值为1；

如果最大流为2则可以完成，

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
#include<stack>
#include<algorithm>
#define INF 0x7ffffff
#define MAX 10010
#define MAXM 100100
#define eps 1e-5
#define DD double
using namespace std;
DD pad[MAX],x[MAX],y[MAX],r[MAX];
struct node
{
	int from,to,cap,flow,next;
}edge[MAXM];
int vis[MAX],dis[MAX];
int cur[MAX];
int head[MAX],ans;
void init()
{
	ans=0;
	memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
	edge[ans]={u,v,w,0,head[u]};
	head[u]=ans++;
	edge[ans]={v,u,0,0,head[v]};
	head[v]=ans++;
}
int judge(int i,int j)//判断两个光谱是否相交
{
	if((sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]))-r[i]-r[j])<0)
		return 1;
	return 0;
}
int bfs(int beg,int end)
{
	memset(vis,0,sizeof(vis));
	memset(dis,-1,sizeof(dis));
	queue<int>q;
	while(!q.empty())
	    q.pop();
	q.push(beg);
	vis[beg]=1;
	dis[beg]=0;
	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.to]&&E.cap>E.flow)
			{
				dis[E.to]=dis[u]+1;
				vis[E.to]=1;
				if(E.to==end) return 1;
				q.push(E.to);
			}
		}
	}
	 return 0;
}
int dfs(int x,int a,int end)
{
	if(a==0||x==end)
	    return a;
	int flow=0,f;
	for(int &i=cur[x];i!=-1;i=edge[i].next)
	{
		node& E=edge[i];
		if(dis[E.to]==dis[x]+1&&(f=dfs(E.to,min(a,E.cap-E.flow),end))>0)
		{
			E.flow+=f;
			edge[i^1].flow-=f;
			flow+=f;
			a-=f;
			if(a==0) break;
		}
	}
	return flow;
}
int Maxflow(int beg,int end)
{
	int flow=0;
	while(bfs(beg,end))
	{
		memcpy(cur,head,sizeof(head));
		flow+=dfs(beg,INF,end);
	}
	return flow;
}
int main()
{
	int t,n,m,i,j;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		init();
		for(i=1;i<=n;i++)
			scanf("%lf%lf%lf%lf",&pad[i],&x[i],&y[i],&r[i]);
        for(i=1;i<=n;i++)
        {
        	if(fabs(pad[i]-789.0)<=eps)//紫色光圈连接源点
        	add(0,i,2);
        	if(fabs(pad[i]-400.0)<=eps)//红则光谱连接汇点
        	add(i,n+1,2);
        	for(j=1;j<=n;j++)
        	{
        		if(i!=j)//判断到同一个光圈时跳过
        		{
        			if(judge(i,j)&&pad[i]>pad[j])//光圈相交且第一个的光普大
        			{
        				add(i,j,1);
        			}
        		}
        	}
        }
        if(Maxflow(0,n+1)==2)
            printf("Game is VALID\n");
        else
            printf("Game is NOT VALID\n");
	}
	return 0;
}