HDU 2732：Leapin' Lizards（最大流）

http://acm.hdu.edu.cn/showproblem.php?pid=2732

题意：给出两个地图，蜥蜴从一个柱子跳跃到另外一个地方，那么这个柱子就可能会坍塌，第一个地图是柱子可以容忍跳跃多少次（即从它为起点可以跳跃多少次，然后坍塌），第二个地图是蜥蜴的位置。还有一个跳跃距离d，即蜥蜴可以跳跃不超过d的距离（曼哈顿距离），如果跳到地图外面，即蜥蜴逃跑成功，问最终留下的蜥蜴数最少是多少。

思路：我觉得如果不是在做网络流套题应该想不到这是网络流。其实挺简单的建图。首先考虑蜥蜴的位置，和柱子的位置，如果柱子的位置有蜥蜴，那么这个柱子可以容忍的跳跃次数wi要-1，因为这个地方的蜥蜴必须跳走。然后把蜥蜴的位置，柱子的位置，和地图外边的位置存下来，蜥蜴和柱子拆点，形成一个S->lizard1->lizard2->pil1->pil2->out->T这样的网络。

1、如果蜥蜴可以直接跳到地图外，那么可以在lizard2和out之间连一条边，如果柱子可以跳到地图外，就在pil2和out之间连边，权值都为INF。

2、如果柱子之间如果距离在d之间，那么也可以连边，权值为将要跳到的柱子的wi。

3、如果蜥蜴可以跳到柱子，那么可以连边，权值为柱子的wi。

4、S和lizard1连边权值为1。

5、out和T连边权值为INF。

6、蜥蜴拆点权值为1，柱子拆点权值为wi。

这样就做完了。注意输出要仔细。

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <set>
using namespace std;
#define INF 0x3f3f3f3f
#define N 100010
typedef long long LL;
struct Edge {
    int v, nxt, cap;
    Edge () {}
    Edge (int v, int cap, int nxt) : v(v), cap(cap), nxt(nxt) {}
} edge[N];
struct Node {
    int x, y;
    friend bool operator < (const Node &a, const Node &b) {
        return a.x < b.x;
    }
} lizard[N], pil[N], out[N];
int head[N], tot, cur[N], gap[N], pre[N], dis[N], w[N], S, T;

void Add(int u, int v, int cap) {
    edge[tot] = Edge(v, cap, head[u]); head[u] = tot++;
    edge[tot] = Edge(u, 0, head[v]); head[v] = tot++;
}

int Cal(Node a, Node b) {
    return abs(a.x - b.x) + abs(a.y - b.y);
}

void BFS() {
    memset(dis, -1, sizeof(dis));
    memset(gap, 0, sizeof(gap));
    queue<int> que; que.push(T);
    dis[T] = 0; gap[0]++;
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = head[u]; ~i; i = edge[i].nxt) {
            Edge& e = edge[i];
            if(~dis[e.v]) continue;
            dis[e.v] = dis[u] + 1;
            que.push(e.v);
            gap[dis[e.v]]++;
        }
    }
}

int ISAP(int n) {
    BFS();
    memcpy(cur, head, sizeof(cur));
    int ans = 0, i, u = pre[S] = S;
    while(dis[S] < n) {
        if(u == T) {
            int flow = INF, index;
            for(i = S; i != T; i = edge[cur[i]].v)
                if(edge[cur[i]].cap < flow) flow = edge[cur[i]].cap, index = i;
            for(i = S; i != T; i = edge[cur[i]].v)
                edge[cur[i]].cap -= flow, edge[cur[i]^1].cap += flow;
            ans += flow; u = index;
        }
        for(i = cur[u]; ~i; i = edge[i].nxt)
            if(dis[edge[i].v] + 1 == dis[u] && edge[i].cap > 0) break;
        if(~i) {
            pre[edge[i].v] = u; cur[u] = i;
            u = edge[i].v;
        } else {
            if(--gap[dis[u]] == 0) break;
            int md = n;
            for(int i = head[u]; ~i; i = edge[i].nxt)
                if(dis[edge[i].v] < md && edge[i].cap > 0)
                    md = dis[edge[i].v], cur[u] = i;
            gap[dis[u] = md + 1]++;
            u = pre[u];
        }
    }
    return ans;
}

int main() {
    int t, cas = 0;
    cin >> t;
    while(t--) {
        int n, d, m; char mp[50][50], s[50][50];
        scanf("%d%d", &n, &d);
        memset(head, -1, sizeof(head)); tot = 0;
        int lzcnt = 0, picnt = 0, oucnt = 0;
        for(int i = 1; i <= n; i++) scanf("%*c%s", mp[i] + 1);
        m = strlen(mp[1] + 1);
        for(int i = 1; i <= n; i++) {
            scanf("%*c%s", s[i] + 1);
            for(int j = 1; j <= m; j++) {
                if(s[i][j] == 'L') {
                    lizard[++lzcnt].x = i, lizard[lzcnt].y = j;
                    if(mp[i][j] - '0' > 0) {
                        pil[++picnt].x = i, pil[picnt].y = j, w[picnt] = mp[i][j] - '0' - 1; // 如果柱子位置有蜥蜴,那么流量要-1
                    }
                } else if(mp[i][j] != '0') {
                    pil[++picnt].x = i, pil[picnt].y = j, w[picnt] = mp[i][j] - '0';
                }
            }
        }
        for(int i = 1; i <= n; i++) {
            out[++oucnt].x = i; out[oucnt].y = 0;
            out[++oucnt].x = i; out[oucnt].y = m + 1;
        }
        for(int i = 1; i <= m; i++) {
            out[++oucnt].x = 0; out[oucnt].y = i;
            out[++oucnt].x = n + 1; out[oucnt].y = i;
        }
        S = 0; T = 2 * lzcnt + 2 * picnt + oucnt + 1;
        for(int i = 1; i <= lzcnt; i++) Add(S, i, 1), Add(i, i + lzcnt, 1); // 源点和蜥蜴,蜥蜴拆点
        for(int i = 1; i <= oucnt; i++) Add(2 * lzcnt + 2 * picnt + i, T, INF); // 边界点和汇点
        for(int i = 1; i <= picnt; i++) Add(2 * lzcnt + i, 2 * lzcnt + picnt + i, w[i]); // 跳跃点拆点
        for(int i = 1; i <= lzcnt; i++) {
            for(int j = 1; j <= picnt; j++) {
                if(Cal(lizard[i], pil[j]) <= d && Cal(lizard[i], pil[j]) != 0) {
                    Add(i + lzcnt, j + 2 * lzcnt, w[j]); // 蜥蜴的第二个点和跳跃点第一个点
                }
            }
            for(int j = 1; j <= oucnt; j++) {
                if(Cal(lizard[i], out[j]) <= d) Add(i + lzcnt, j + lzcnt * 2 + picnt * 2, INF);
            }
        }
        for(int i = 1; i <= picnt; i++) {
            for(int j = i + 1; j <= picnt; j++) {
                if(Cal(pil[i], pil[j]) <= d) {
                    Add(i + 2 * lzcnt + picnt, j + 2 * lzcnt, INF); // 跳跃点
                    Add(j + 2 * lzcnt + picnt, i + 2 * lzcnt, INF);
                }
            }
            for(int j = 1; j <= oucnt; j++) {
                if(Cal(pil[i], out[j]) <= d) Add(i + lzcnt * 2 + picnt, j + lzcnt * 2 + picnt * 2, INF);
            }
        }
        int ans = lzcnt - ISAP(T + 1);
        printf("Case #%d: ", ++cas);
        if(ans < 2) {
            if(ans <= 0) printf("no lizard was ");
            else printf("1 lizard was ");
        } else {
            printf("%d lizards were ", ans);
        }
        puts("left behind.");
    }
    return 0;
}

 #看了一下别人的思路，一开始自己也想的差不多那样，但是硬是调不出来，就用了这么复杂方法，觉得自己没救了，好简单的思路。

S->pil1->pil2->T，如果柱子上有蜥蜴就将这个点和S连，如果在该柱子可以跳出去，那么就将这个点和T相连，然后和能够相连的柱子连边就好了。再写一遍

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <set>
using namespace std;
#define INF 0x3f3f3f3f
#define N 100010
typedef long long LL;
struct Edge {
    int v, nxt, cap;
    Edge () {}
    Edge (int v, int cap, int nxt) : v(v), cap(cap), nxt(nxt) {}
} edge[N];
struct Node {
    int x, y, w, flag;
} pil[N];
int head[N], tot, cur[N], gap[N], pre[N], dis[N], S, T;

void Add(int u, int v, int cap) {
    edge[tot] = Edge(v, cap, head[u]); head[u] = tot++;
    edge[tot] = Edge(u, 0, head[v]); head[v] = tot++;
}

int Cal(Node a, Node b) {
    return abs(a.x - b.x) + abs(a.y - b.y);
}

void BFS() {
    memset(dis, -1, sizeof(dis));
    memset(gap, 0, sizeof(gap));
    queue<int> que; que.push(T);
    dis[T] = 0; gap[0]++;
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = head[u]; ~i; i = edge[i].nxt) {
            Edge& e = edge[i];
            if(~dis[e.v]) continue;
            dis[e.v] = dis[u] + 1;
            que.push(e.v);
            gap[dis[e.v]]++;
        }
    }
}

int ISAP(int n) {
    BFS();
    memcpy(cur, head, sizeof(cur));
    int ans = 0, i, u = pre[S] = S;
    while(dis[S] < n) {
        if(u == T) {
            int flow = INF, index;
            for(i = S; i != T; i = edge[cur[i]].v)
                if(edge[cur[i]].cap < flow) flow = edge[cur[i]].cap, index = i;
            for(i = S; i != T; i = edge[cur[i]].v)
                edge[cur[i]].cap -= flow, edge[cur[i]^1].cap += flow;
            ans += flow; u = index;
        }
        for(i = cur[u]; ~i; i = edge[i].nxt)
            if(dis[edge[i].v] + 1 == dis[u] && edge[i].cap > 0) break;
        if(~i) {
            pre[edge[i].v] = u; cur[u] = i;
            u = edge[i].v;
        } else {
            if(--gap[dis[u]] == 0) break;
            int md = n;
            for(int i = head[u]; ~i; i = edge[i].nxt)
                if(dis[edge[i].v] < md && edge[i].cap > 0)
                    md = dis[edge[i].v], cur[u] = i;
            gap[dis[u] = md + 1]++;
            u = pre[u];
        }
    }
    return ans;
}

int main() {
    int t, cas = 0;
    cin >> t;
    while(t--) {
        int n, d, m; char mp[50][50], s[50][50];
        scanf("%d%d", &n, &d);
        memset(head, -1, sizeof(head)); tot = 0;
        int cnt = 0, tol = 0;
        for(int i = 1; i <= n; i++) {
            scanf("%s", s[i] + 1);
            m = strlen(s[i] + 1);
            for(int j = 1; j <= m; j++)
                if(s[i][j] != '0') pil[++cnt].x = i, pil[cnt].y = j, pil[cnt].w = s[i][j] - '0';
        }
        for(int i = 1; i <= n; i++) {
            scanf("%s", mp[i] + 1);
            for(int j = 1; j <= m; j++) {
                for(int k = 1; k <= cnt; k++) {
                    if(pil[k].x == i && pil[k].y == j) {
                        if(mp[i][j] == 'L') pil[k].flag = 1, tol++;
                        else pil[k].flag = 0;
                        break;
                    }
                }
            }
        }
        S = 0, T = 2 * cnt + 1;
        for(int i = 1; i <= cnt; i++) {
            Add(i, i + cnt, pil[i].w);
            if(pil[i].flag == 1) Add(S, i, 1);
            for(int j = i + 1; j <= cnt; j++) {
                if(Cal(pil[i], pil[j]) <= d) {
                    Add(i + cnt, j, INF);
                    Add(j + cnt, i, INF);
                }
            }
            if(pil[i].x <= d || pil[i].y <= d || n - pil[i].x < d || m - pil[i].y < d)
                Add(i + cnt, T, INF);
        }

        int ans = tol - ISAP(T + 1);
        printf("Case #%d: ", ++cas);
        if(ans < 2) {
            if(ans <= 0) printf("no lizard was ");
            else printf("1 lizard was ");
        } else {
            printf("%d lizards were ", ans);
        }
        puts("left behind.");
    }
    return 0;
}