POJ 3498 March of the Penguins（网络最大流）

Description

Somewhere near the south pole, a number of penguins are standing on a number of ice floes. Being social animals, the penguins would like to get together, all on the same floe. The penguins do not want to get wet, so they have use their limited jump distance to get together by jumping from piece to piece. However, temperatures have been high lately, and the floes are showing cracks, and they get damaged further by the force needed to jump to another floe. Fortunately the penguins are real experts on cracking ice floes, and know exactly how many times a penguin can jump off each floe before it disintegrates and disappears. Landing on an ice floe does not damage it. You have to help the penguins find all floes where they can meet.

A sample layout of ice floes with 3 penguins on them.

Input

On the first line one positive number: the number of testcases, at most 100. After that per testcase:

• One line with the integer N (1 ≤ N ≤ 100) and a floating-point number D (0 ≤ D ≤ 100 000 ), denoting the number of ice pieces and the maximum distance a penguin can jump.

• N lines, each line containing x_i, y_i, n_i and m_i, denoting for each ice piece its X and Y coordinate, the number of penguins on it and the maximum number of times a penguin can jump off this piece before it disappears ( −10 000 ≤ x_i, y_i ≤ 10 000 , 0 ≤ n_i ≤ 10, 1 ≤ m_i ≤ 200).

Output

Per testcase:

• One line containing a space-separated list of 0-based indices of the pieces on which all penguins can meet. If no such piece exists, output a line with the single number −1.

 

题目大意：有n块浮冰，每块冰上有ni只企鹅，他们最多能跳距离D，现在这些企鹅想在同一块冰上集中，但是呢，冰有裂缝，每块冰只能被企鹅在上面跳走mi次（跳进来和站在上面都不影响），问企鹅们可以集中在哪些浮冰上。

思路：拆点，每个点x拆成x和x'，每个x到x'连边，容量为能跳多少次。然后如果i到j的距离不大于D，那么在i'到j连一条边，容量为无穷大。源点S到每一个点x连一条边，容量为有多少只企鹅在x上。最后，枚举每一个点x，x到汇点T连一条边，容量为无穷大，判断最大流是否等于企鹅的数量。

算法正确性说明：如此建图，每只企鹅都从源点开始走到汇点，但每个冰块只能经过cap[x->x']次，保证了企鹅只能从x跳走mi次。

PS：我枚举的时候，只是把前一条边的容量搞成0（要删掉好像好麻烦的样子），再新建一条从枚举点到汇点的边，这样就不用每次都建图了。

PS2：D居然是浮点数……还好没因此WA……

 

BFS+ISAP（235MS）：

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
using namespace std;

const int MAXN = 222;
const int MAXE = MAXN * MAXN * 2;
const int INF = 0x3f3f3f3f;

struct SAP {
    int head[MAXN], dis[MAXN], gap[MAXN], pre[MAXN], cur[MAXN];
    int to[MAXE], next[MAXE], flow[MAXE], cap[MAXE];
    int st, ed, n, ecnt;

    void init() {
        memset(head, 0, sizeof(head));
        ecnt = 2;
    }

    void add_edge(int u, int v, int f) {
        to[ecnt] = v; cap[ecnt] = f; flow[ecnt] = 0; next[ecnt] = head[u]; head[u] = ecnt++;
        to[ecnt] = u; cap[ecnt] = 0; flow[ecnt] = 0; next[ecnt] = head[v]; head[v] = ecnt++;
        //printf("%d->%d cap=%d\n", u, v, f);
    }

    void bfs() {
        memset(dis, 0x3f, sizeof(dis));
        queue<int> que; que.push(ed);
        dis[ed] = 0;
        while(!que.empty()) {
            int u = que.front(); que.pop();
            ++gap[dis[u]];
            for(int p = head[u]; p; p = next[p]) {
                int v = to[p];
                if(dis[v] > n && cap[p ^ 1]) {
                    dis[v] = dis[u] + 1;
                    que.push(v);
                }
            }
        }
    }

    int Maxflow(int ss, int tt, int nn) {
        st = ss, ed = tt, n = nn;
        int ans = 0, minFlow = INF, u;
        for(int i = 0; i <= n; ++i) {
            cur[i] = head[i];
            gap[i] = 0;
        }
        u = pre[st] = st;
        bfs();
        while(dis[st] < n) {
            bool flag = false;
            for(int &p = cur[u]; p; p = next[p]) {
                int v = to[p];
                if(cap[p] > flow[p] && dis[u] == dis[v] + 1) {
                    flag = true;
                    minFlow = min(minFlow, cap[p] - flow[p]);
                    pre[v] = u;
                    u = v;
                    if(u == ed) {
                        ans += minFlow;
                        while(u != st) {
                            u = pre[u];
                            flow[cur[u]] += minFlow;
                            flow[cur[u] ^ 1] -= minFlow;
                        }
                        minFlow = INF;
                    }
                    break;
                }
            }
            if(flag) continue;
            int minDis = n - 1;
            for(int p = head[u]; p; p = next[p]) {
                int v = to[p];
                if(cap[p] > flow[p] && dis[v] < minDis) {
                    minDis = dis[v];
                    cur[u] = p;
                }
            }
            if(--gap[dis[u]] == 0) break;
            gap[dis[u] = minDis + 1]++;
            u = pre[u];
        }
        return ans;
    }
} G;

struct Point {
    int x, y, n, m;
    void read() {
        scanf("%d%d%d%d", &x, &y, &n, &m);
    }
};

double dist(const Point &a, const Point &b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

int n, ss, tt;
int ans[110], cnt;
double d;
Point p[110];

void make_graph() {
    ss = 2 * n + 1, tt = ss + 1;
    G.init();
    for(int i = 1; i <= n; ++i)
        if(p[i].n) G.add_edge(ss, 2 * i - 1, p[i].n);
    for(int i = 1; i <= n; ++i) G.add_edge(2 * i - 1, 2 * i, p[i].m);
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= n; ++j) {
            if(i == j || dist(p[i], p[j]) > d) continue;
            G.add_edge(i * 2, j * 2 - 1, INF);
        }
    }
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d%lf", &n, &d);
        for(int i = 1; i <= n; ++i) p[i].read();
        int sum = 0;
        for(int i = 1; i <= n; ++i) sum += p[i].n;
        make_graph();
        cnt = 0;
        for(int i = 1; i <= n; ++i) {
            G.add_edge(i * 2 - 1, tt, INF);
            memset(G.flow, 0, sizeof(G.flow));
            if(sum == G.Maxflow(ss, tt, tt)) ans[++cnt] = i - 1;
            G.cap[G.ecnt - 2] = 0;
        }
        if(cnt == 0) puts("-1");
        else {
            for(int i = 1; i < cnt; ++i) printf("%d ", ans[i]);
            printf("%d\n", ans[cnt]);
        }
    }
}