HDU -- 4183 Pahom on Water（最大流）

题目大意：

二维空间上有一些点，每个点有一个频率，圆心坐标，半径，设s点是频率最低的点，t是频率最高的点，要求从s点走到t点，在从点t回到点s。当从s走到t时，要求两个点表示的园相交并且第一个点的频率小于第二个点的频率，而从t到s，要第一个点的频率高于第二个点的频率，除了s点t点，所有的点走过一次就会消失，问是否存在这样的一种走法；

思路分析：从s到t频率降低，从t到s频率升高，其实也就是从s点走到t点能否有两条不同的路径；

代码实现：

Sap：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>
#define Max(a,b) ((a)>(b)?(a):(b))
using namespace std;
const int N=310;
const int M=90010;
const int INF=0x3f3f3f3f;
int n,s,t,top,head[N],gap[N],cur[N],pre[N],dis[N];

struct Edge{
    int to,next,flow;
}edge[M*2];

struct Point{
    double fre;
    int x,y,r;
}point[N];

int cmp(Point a,Point b){
    return a.fre<b.fre;
}

int Check(int i,int j){
    return ((point[i].x-point[j].x)*(point[i].x-point[j].x)+(point[i].y-point[j].y)*(point[i].y-point[j].y))<(point[i].r+point[j].r)*(point[i].r+point[j].r);
}

void Addedge(int from,int to,int flow){
    edge[top].to=to,edge[top].next=head[from],edge[top].flow=flow,head[from]=top++;
    edge[top].to=from,edge[top].next=head[to],edge[top].flow=0,head[to]=top++;
}

void Bfs(){
    queue<int> q;
    memset(gap,0,sizeof(gap));
    memset(dis,-1,sizeof(dis));
    gap[0]=1,dis[t]=0;
    q.push(t);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=head[u];i+1;i=edge[i].next){
            if(dis[edge[i].to]==-1){
                dis[edge[i].to]=dis[u]+1;
                gap[dis[edge[i].to]]++;
                q.push(edge[i].to);
            }
        }
    }
}

int Sap(){
    Bfs();
    memset(pre,-1,sizeof(pre));
    for(int i=0;i<n;++i) cur[i]=head[i];
    int u=s,cur_flow,max_flow=0,neck,tmp;
    while(dis[s]<=n){
        if(u==t){
            cur_flow=INF;
            for(int i=s;i!=t;i=edge[cur[i]].to){
                if(cur_flow>edge[cur[i]].flow){
                    neck=i;
                    cur_flow=edge[cur[i]].flow;
                }
            }
            for(int i=s;i!=t;i=edge[cur[i]].to){
                tmp=cur[i];
                edge[tmp].flow-=cur_flow;
                edge[tmp^1].flow+=cur_flow;
            }
            max_flow+=cur_flow;
            u=neck;
        }
        int i;
        for(i=cur[u];i+1;i=edge[i].next)
            if(edge[i].flow&&dis[u]==dis[edge[i].to]+1) break;
        if(i!=-1){
            cur[u]=i;
            pre[edge[i].to]=u;
            u=edge[i].to;
        }else{
            if(--gap[dis[u]]==0) break;
            cur[u]=head[u];
            int mindis=n;
            for(int i=head[u];i+1;i=edge[i].next)
                if(edge[i].flow&&mindis>dis[edge[i].to])
                    mindis=dis[edge[i].to];
            dis[u]=mindis+1;
            gap[dis[u]]++;
            if(u!=s) u=pre[u];
        }
    }
    return max_flow;
}

int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        memset(head,-1,sizeof(head));
        top=0;
        scanf("%d",&n);
        s=0,t=n-1;
        for(int i=0;i<n;++i) scanf("%lf%d%d%d",&point[i].fre,&point[i].x,&point[i].y,&point[i].r);
        sort(point,point+n,cmp);
        if(Check(0,n-1)){
            printf("Game is VALID\n");
            continue;
        }
        for(int i=0;i<n;++i){
            for(int j=i+1;j<n;++j){
                if(Check(i,j)) Addedge(i,j,1);
            }
        }
        int res=Sap();
        if(res>=2) printf("Game is VALID\n");
        else printf("Game is NOT VALID\n");
    }
}

Dinic：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
using namespace std;
const int N=310;
const int M=90010;
const int INF=0x3f3f3f3f;
int n,s,t,top,head[N],dis[N];
struct Edge{
    int to,next,flow;
}edge[M*2];

struct Point{
    double fre;
    int x,y,r;
}point[N];

int cmp(Point a,Point b){
    return a.fre<b.fre;
}
 
int Check(int i,int j){
    return ((point[i].x-point[j].x)*(point[i].x-point[j].x)+(point[i].y-point[j].y)*(point[i].y-point[j].y))<(point[i].r+point[j].r)*(point[i].r+point[j].r);
}

void Addedge(int from,int to,int flow){
    edge[top].to=to,edge[top].next=head[from],edge[top].flow=flow,head[from]=top++;
    edge[top].to=from,edge[top].next=head[to],edge[top].flow=0,head[to]=top++;
}

int Bfs(){
    queue<int> q;
    memset(dis,-1,sizeof(dis));
    dis[s]=0;
    q.push(s);
    while(!q.empty()){
        int u=q.front();
        if(u==t) return 1;
        q.pop();
        for(int i=head[u];i+1;i=edge[i].next){
            if(dis[edge[i].to]==-1&&edge[i].flow){
                dis[edge[i].to]=dis[u]+1;
                q.push(edge[i].to);
            }
        }
    }
    return 0;
}

int Dinic(int u,int sum){
    if(u==t) return sum;
    int max_flow=0;
    for(int i=head[u];i+1;i=edge[i].next){
        if(dis[edge[i].to]==dis[u]+1&&edge[i].flow){
            int a=Dinic(edge[i].to,Min(sum-max_flow,edge[i].flow));
            edge[i].flow-=a;
            edge[i^1].flow+=a;
            max_flow+=a;
            if(max_flow==sum) return max_flow;
        }
    }
    if(!max_flow) dis[u]=-1;
    return max_flow;
}

int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        memset(head,-1,sizeof(head));
        top=0;
        scanf("%d",&n);
        s=0,t=n-1;
        for(int i=0;i<n;++i) scanf("%lf%d%d%d",&point[i].fre,&point[i].x,&point[i].y,&point[i].r);
        sort(point,point+n,cmp);
        if(Check(0,n-1)){
            printf("Game is VALID\n");
            continue;
        }
        for(int i=0;i<n;++i){
            for(int j=i+1;j<n;++j){
                if(Check(i,j)) Addedge(i,j,1);
            }
        }
        int res=0;
        while(Bfs()){
            res+=Dinic(s,INF);
        }
        if(res>=2) printf("Game is VALID\n");
        else printf("Game is NOT VALID\n");
    }
}