HDU-2732 Leapin's Lizards

题目链接：Leapin’s Lizards

题目大意：有若干蜥蜴要逃离所给的矩阵，矩阵上有若干柱子。蜥蜴只能从有柱子的地方开始跳跃，只能跳跃到其他柱子上或界外。柱子有自己的耐久度，每跳一次耐久度就会减1，耐久度为0的时候就不能再跳了。求最后有多少蜥蜴不能逃离矩阵。

解题思路：由于有耐久度的设定，这道题可以用最大流来解决。将源点和所以蜥蜴人所在的位置建边，权值为1；将互相可以抵达的柱子间建边，权值为正无穷；将每个柱子拆成两个店，权值为耐久度；将可以逃离的柱子和汇点建边，权值为耐久度。这道题的输出也要特别注意，就是因为这个无故WA两发，简直心累。

代码如下：

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int inf  = 0x3f3f3f3f;
const int maxn = 1e3 + 15;
const int maxm = 1e6 + 15;

struct Edge {
    int to, cap, next;
};

int ecnt, st, ed, m, n;
Edge es[maxm];
int cur[maxn], dep[maxn], head[maxn], cost[30][30]; 

class Dinic {
public:
    void init(){
        memset(head, -1, sizeof head);
        ecnt = 0;
    }

    void add_edge(int u, int v, int cap) {
        es[ecnt].to = v;
        es[ecnt].next = head[u];
        es[ecnt].cap = cap;
        head[u] = ecnt++;
    }

    void add_double(int u, int v, int w1, int w2 = 0) {
        add_edge(u, v, w1);
        add_edge(v, u, w2);
    }

    bool BFS() {
        queue<int> q; q.push(st);
        memset(dep, 0x3f, sizeof dep); dep[st] = 0;
        while(q.size() && dep[ed] == inf) {
            int u = q.front(); q.pop();
            for(int i = head[u]; ~i; i = es[i].next) {
                Edge& e = es[i];
                if(e.cap > 0 && dep[e.to] == inf) {
                    dep[e.to] = dep[u] + 1;
                    q.push(e.to);
                }
            }
        }
        return dep[ed] < inf;
    }

    int DFS(int u, int maxflow) {
        if(u == ed) return maxflow;
        int res = 0;
        for(int i = cur[u]; ~i; i = es[i].next) {
            Edge& e = es[i];
            if(dep[e.to] == dep[u] + 1 && e.cap > 0) {
                int flow = DFS(e.to, min(maxflow, e.cap));  
                cur[u] = i; 
                res += flow; maxflow -= flow;
                es[i].cap -= flow; 
                es[i ^ 1].cap += flow;
                if(!maxflow) return res;
            }
        }       
        dep[u] = inf;
        return res;
    }

    int MaxFlow(){
        int ans = 0;    
        while(BFS()) {   
            for(int i = st; i <= ed; i++) cur[i] = head[i];
            ans += DFS(st, inf);
        }
        return ans;
    }
};

inline int read() {
    char c = getchar();
    while(!isdigit(c)) c = getchar();
    int x = 0;
    while(isdigit(c)) {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x;
}

int main(){
#ifdef NEKO
    freopen("Nya.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false); cin.tie(0);
    int t, leap, cnt, kase = 1; 
    cin >> t; Dinic dic;
    while(t--) {
        vector<P> pill;
        cin >> n >> leap; string s;
        for(int i = 1; i <= n; i++) { 
            cin >> s; m = s.size(); 
            for(int j = 1; j <= m; j++) {
                cost[i][j] = s[j - 1] - '0';    
                if(cost[i][j]) pill.push_back(P(i, j));
            }
        }
        dic.init(); 
        st = 0, ed = 2 * n * m + 1; cnt = 0;
        for(int i = 1; i <= n; i++) { 
            cin >> s;   
            for(int j = 1; j <= m; j++) {
                if(s[j - 1] == 'L') {
                    cnt++;
                    dic.add_double(st, (i - 1) * m + j, 1);
                }
            }
        }       
        for(int i = 0; i < pill.size() - 1; i++) {
            for(int j = i + 1; j < pill.size(); j++) {
                int x = (pill[i].first - pill[j].first) * (pill[i].first - pill[j].first);
                int y = (pill[i].second - pill[j].second) * (pill[i].second - pill[j].second);
                int l = (pill[i].first - 1) * m + pill[i].second;
                int r = (pill[j].first - 1) * m + pill[j].second;
                if(leap * leap >= x + y) {
                    dic.add_double(l + n * m, r, inf);  
                    dic.add_double(r + n * m, l, inf);  
                }
            }
        }

        for(int i = 0; i < pill.size(); i++) {
            int x = pill[i].first, y = pill[i].second;
            int index = (x - 1) * m + y;
            dic.add_double(index, index + n * m, cost[x][y]);
            if(x - leap <= 0 || y - leap <= 0 || x + leap > n || y + leap > m)
                dic.add_double(index + n * m, ed, cost[x][y]);
        }

        int ans = dic.MaxFlow();
        cout << "Case #" << kase++ << ": ";
        if(!(cnt - ans)) cout << "no";
        else cout << cnt - ans; 
        if(cnt - ans < 2) cout << " lizard was left behind.\n";
        else cout << " lizards were left behind.\n";
    }
    return 0;
}