Description

　　在一个r行c列的网格地图中有一些高度不同的石柱，一些石柱上站着一些蜥蜴，你的任务是让尽量多的蜥蜴逃
到边界外。 每行每列中相邻石柱的距离为1，蜥蜴的跳跃距离是d，即蜥蜴可以跳到平面距离不超过d的任何一个石
柱上。石柱都不稳定，每次当蜥蜴跳跃时，所离开的石柱高度减1（如果仍然落在地图内部，则到达的石柱高度不
变），如果该石柱原来高度为1，则蜥蜴离开后消失。以后其他蜥蜴不能落脚。任何时刻不能有两只蜥蜴在同一个
石柱上。
Input

　　输入第一行为三个整数r，c，d，即地图的规模与最大跳跃距离。以下r行为石竹的初始状态，0表示没有石柱
，1~3表示石柱的初始高度。以下r行为蜥蜴位置，“L”表示蜥蜴，“.”表示没有蜥蜴。
Output

　　输出仅一行，包含一个整数，即无法逃离的蜥蜴总数的最小值。
Sample Input
5 8 2

00000000

02000000

00321100

02000000

00000000

……..

……..

..LLLL..

……..

……..
Sample Output
1
HINT

100%的数据满足：1<=r, c<=20, 1<=d<=4

解题方法： 题目要求无法逃离的蜥蜴的最小值，即求可以逃离的蜥蜴的最大值。选择使用最大流，当然重点在构图。

对于每一个石柱，我们可以拆成两个点，分别为入点和出点。

对于所有石柱，从入点到出点连边，容量为高度。这里等于限制了每一个石柱的跳跃次数。

对于最初有蜥蜴的石柱，从源点向这些点的入点连边，容量为1。因为每一个石柱只有一个蜥蜴。

对于任意一对可以相互到达的石柱，分别从彼此的出点到入点连边，容量为正无穷。等于假设可以有尽可能多的蜥蜴跳过。

对于可以跳到边界外的石柱，从出点向汇点连边，容量为正无穷。原理同上。 然后最后答案就是蜥蜴的个数减去 最大流。。(我才不会说把汇点和邻接表计数变量都写成T调试一天的SB是谁呢)

复杂度： O(Dinic)

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 400010;
const int maxm = 1000010;
#define rep(i, a, b) for(int i = a; i <= b; i++)
struct G
{
    int v, cap, next;
    G() {}
    G(int v, int cap, int next) : v(v), cap(cap), next(next) {}
} E[maxm];
int p[maxn], T;
int d[maxn], temp_p[maxn], qw[maxn]; //d顶点到源点的距离标号,temp_p当前狐优化，qw队列
void init()
{
    memset(p, -1, sizeof(p));
    T = 0;
}
void add(int u, int v, int cap)
{
    E[T] = G(v, cap, p[u]);
    p[u] = T++;
    E[T] = G(u, 0, p[v]);
    p[v] = T++;
}
bool bfs(int st, int en, int n)
{
    int i, u, v, head, tail;
    for(i = 0; i <= n; i++) d[i] = -1;
    head = tail = 0;
    d[st] = 0;
    qw[tail] = st;
    while(head <= tail)
    {
        u = qw[head++];
        for(i = p[u]; i + 1; i = E[i].next)
        {
            v = E[i].v;
            if(d[v] == -1 && E[i].cap > 0)
            {
                d[v] = d[u] + 1;
                qw[++tail] = v;
            }
        }
    }
    return (d[en] != -1);
}
int dfs(int u, int en, int f)
{
    if(u == en || f == 0) return f;
    int flow = 0, temp;
    for(; temp_p[u] + 1; temp_p[u] = E[temp_p[u]].next)
    {
        G& e = E[temp_p[u]];
        if(d[u] + 1 == d[e.v])
        {
            temp = dfs(e.v, en, min(f, e.cap));
            if(temp > 0)
            {
                e.cap -= temp;
                E[temp_p[u] ^ 1].cap += temp;
                flow += temp;
                f -= temp;
                if(f == 0)  break;
            }
        }
    }
    return flow;
}
int dinic(int st, int en, int n)
{
    int i, ans = 0;
    while(bfs(st, en, n))
    {
        for(i = 0; i <= n; i++) temp_p[i] = p[i];
        ans += dfs(st, en, INF);
    }
    return ans;
}
int st, en, n, m, dd, stone[220][220];
bool escape(int x, int y){
    if(x <= dd || y <= dd || x > n - dd || y > m - dd) return true;
    else return false;
}
bool check(int x1, int y1, int x2, int y2){
    int x = (x1 - x2);
    int y = (y1 - y2);
    return (x * x + y * y) <= dd * dd;
}
int num(int x, int y){ //点标号
    return (x - 1) * m + y;
}
int main(){
    cin >> n >> m >> dd;
    st = 0; en = 80001;
    init();
    int ans2 = 0;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            char ch;
            cin >> ch;
            if(escape(i, j)) add(n * m + num(i, j), en, INF);
            if(ch == '0') continue;
            stone[i][j] = (int)(ch - '0');
        }
    }
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            char ch;
            cin >> ch;
            if(ch == 'L'){
                add(st, num(i, j), 1);
                ans2++;
            }
        }
    }
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            if(stone[i][j]) add(num(i, j), n * m + num(i, j), stone[i][j]);
            for(int k = 1; k <= n; k++){
                for(int l = 1; l <= m; l++){
                    if(!stone[k][l] || (k == i && l == j)) continue;
                    if(!check(i, j, k, l)) continue;
                    add(n * m + num(i, j), num(k, l), INF);
                }
            }
        }
    }
    int ans = dinic(st, en, en );
//    printf("%d\n", ans2);
//    printf("%d\n", ans);
    printf("%d\n", ans2 - ans);
    return 0;
}