HDU 4183(max flow)

HDU 4183(max flow)

链接

题意：orz，论翻译的重要性，看了半天。进入正题：
有n(2 <= n <= 300)个圆圈，每个圆圈都有其频率f，坐标(x,y)，半径r。（题目保证圈的频率在 400.0 ~ 789.0间），起点第一个圈，频率固定400.0，终点第n个圈，频率固定789.0。 能从一个圈a走到另外一个圈b，需要两个圈有交点且圈a的频率小于圈b的频率。 问是否从1走到n，再从n走回1。

思路： 读懂题目会发现这其实就是一条经典建图题目的小修改。
首先由于每条边只能用一次，但一个点可以用多次，所以需要拆点。
把点u拆成入点iu，出点ou；
1）新建源点s向起点连流量为2的边，
2）每个点的入点向出点连流量无穷的边。
2）新建汇点t，第n个点的出点向汇点连流量为2的边。
4）对所有圈按照频率f从小到大排序，满足规则建边。
然后跑最大流，判断流量是否大于2即可。

AC code：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 600 + 50;
const int maxm = 1e5 + 10;
const int INF = 0x3f3f3f3f;
#define captype int
struct SAP{
    struct Edge{
        int from,to,next;
        captype cap;
    }edge[maxm];
    int tot,head[maxn];
    int dis[maxn],cur[maxn],pre[maxn],gap[maxn];
    void init(int n){
        tot = 0;
        //memset(head,-1,sizeof(head));
        for(int i = 0; i <= n; ++i) head[i] = -1;
    }
    inline void addedge(int u,int v,captype c,captype rc = 0){
        edge[tot] = (Edge){u,v,head[u],c}, head[u] = tot++;
        edge[tot] = (Edge){v,u,head[v],rc}, head[v] = tot++;
    }
    captype max_flow(int s,int t,int n){ //包括源点和汇点在内的总点数
        for(int i = 0; i < maxn; ++i){
            gap[i] = dis[i] = 0;
            cur[i] = head[i];
        }
        pre[s] = -1, gap[s] = n;
        captype ans = 0;
        int u = s;
        while(dis[s] < n){
            if(u == t){
                captype minn = INF;
                int v;
                for(int i = pre[u]; ~i; i = pre[edge[i^1].to]){
                    if(minn > edge[i].cap){
                        minn = edge[i].cap, v = i;
                    }
                }
                for(int i = pre[u]; ~i; i = pre[edge[i^1].to]){
                    edge[i].cap -= minn;
                    edge[i^1].cap += minn;
                }
                ans += minn;
                u = edge[v^1].to;
                continue ;
            }
            bool ok = 0;
            int v;
            for(int i = cur[u]; ~i; i = edge[i].next){
                v = edge[i].to;
                if(edge[i].cap > 0 && dis[u] == dis[v] + 1){
                    ok = 1, cur[u] = pre[v] = i;
                    break ;
                }
            }
            if(ok){
                u = v; continue ;
            }
            int mind = n;
            for(int i = head[u]; ~i; i = edge[i].next){
                if(edge[i].cap > 0 && mind > dis[edge[i].to]){
                    mind = dis[edge[i].to];
                    cur[u] = i;
                }
            }
            --gap[dis[u]];
            if(!gap[dis[u]]) return ans;
            dis[u] = mind + 1;
            ++gap[dis[u]];
            if(u != s) u = edge[pre[u]^1].to;
        }
        return ans;
    }
}F;

struct Point{
    double f;
    int x,y,r;
}a[350];

inline bool cmp(const Point &a, const Point &b){
    return a.f < b.f;
}

inline bool check(const Point &a, const Point &b){
    return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) <= (a.r + b.r) * ((a.r + b.r));
}

int main(){
    int T,n;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i = 1; i <= n; ++i){
            scanf("%lf%d%d%d",&a[i].f,&a[i].x,&a[i].y,&a[i].r);
        }
        sort(a + 1, a + n + 1, cmp);
        F.init(2 * n + 5);
        int s = 0, t = 2 * n + 1;
        F.addedge(s,1,2);
        F.addedge(2 * n, t,2);
        for(int i = 1; i <= n; ++i){
            F.addedge(i, i + n, INF);
        }
        for(int i = 1; i <= n; ++i){
            for(int j = i + 1; j <= n; ++j){
                if(check(a[i],a[j])){
                    F.addedge(i + n, j, 1);
                }
            }
        }
        int flow = F.max_flow(s, t, 2 * n + 2);
        if(flow >= 2){
            puts("Game is VALID");
        }
        else{
            puts("Game is NOT VALID");
        }
    }
    return 0;
}