HDU4183 Pahom on Water(基础) [最大流]来回走不重复点的网络流.

题意：确实难懂啊，网上找了翻译：二维空间上有一些点，每个点有一个半径r和频率f，要从某一个点S走到另一个点T，然后再从T回到S。从S到T时，如果两个点表示的圆相交并且第一个点小于第二个点的频率的，那么能从第一个点到第二个点，从T到S时，第一个点的频率要大于第二个点的频率。除了S和T，每个点走后就会消失，问是否存在一种走法。
思路：按照题意的要求建立图 边为1 ，跑两次isap看看是否流是不小于2的

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
#define cl(a,b) memset(a,b,sizeof(a))
const int maxn=20006;
const int inf=1<<28;
const int nv=1100;
const int ne=501000;
struct isap{
    int n,size;
    int head[nv];
    int dis[nv],gap[nv],cur[nv],pre[nv];
    int maxflow;

    struct edge{
        int v,w,next;
        edge(){}
        edge(int _v,int _w,int _next):v(_v),w(_w),next(_next){}
    }E[ne];

    void init(){
        //需要在外面额外设置n的大小
        size=0;
        //for(int i=0;i<=n;i++)head[i]=-1;
        cl(head,-1);
    }
    void insert(int u,int v,int w){
        E[size]=edge(v,w,head[u]);
        head[u]=size++;
        E[size]=edge(u,0,head[v]);
        head[v]=size++;
    }
    int maxFlow(int src,int des){
        maxflow=0;
        for(int i=0;i<=n;i++){
            dis[i]=gap[i]=0;
            cur[i]=head[i];
        }
        int u=pre[src]=src;
        int aug=-1;
        while(dis[src]<n){
           loop:for(int &i=cur[u];i!=-1;i=E[i].next){
                int v=E[i].v;
                if(E[i].w&&dis[u]==dis[v]+1){
                    aug=min(aug,E[i].w);
                    pre[v]=u;
                    u=v;
                    if(v==des){
                        maxflow+=aug;
                        for(u=pre[u];v!=src;v=u,u=pre[u]){
                            E[cur[u]].w-=aug;
                            E[cur[u]^1].w+=aug;
                        }
                        aug=inf;
                    }
                    goto loop;
                }
            }
            int mdis=n;
            for(int i=head[u];i!=-1;i=E[i].next){
                int v=E[i].v;
                if(E[i].w&&mdis>dis[v]){
                    cur[u]=i;
                    mdis=dis[v];
                }
            }
            if(--gap[dis[u]]==0)break;
            gap[dis[u]=mdis+1]++;
            u=pre[u];
        }
        return maxflow;
    }
}G;
struct node{
    double f;
    int x,y,r;
    bool operator<(const node&t) const {//先按照频率从小到大排序，便于建图
        return f<t.f;
    }
}p[maxn];
double distan(node a,node b){//计算距离
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int main(){
    int cas=1;
    int T;
    scanf("%d",&T);
    while(T--){
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%lf%d%d%d",&p[i].f,&p[i].x,&p[i].y,&p[i].r);
        }
        G.init();
        sort(p+1,p+n+1);
        for(int i=1;i<=n;i++){
            for(int j=1+i;j<=n;j++)if(i!=j){
                if(distan(p[i],p[j])<=p[i].r+p[j].r&&p[i].f<p[j].f){
                    G.insert(i,j,1);//建图
                }
            }
        }
        G.n=n;
        int num=G.maxFlow(1,n)+G.maxFlow(1,n);
       // printf("num = %d\n",num);
        if(!(num>=2)){
            puts("Game is NOT VALID");
        }
        else {
            puts("Game is VALID");
        }
    }
    return 0;
}