題目意思是有一些蜥蜴在一個迷宮裡面，求這些蜥蜴還有多少是無論如何都逃不出來的。題目只給定一個行數n，一個最遠能夠跳躍的距離d。每隻蜥蜴有一個初始的位置，題目保證這些位置都有一些柱子，但是它每離開一根柱子，柱子的高度就會降低1m，問最多能有多少隻跳不出去。

將每個柱子在的點進行拆點，把每一個點拆完之後連一條容量為所在點柱子高度的邊。從原點連一條容量為1的邊，然後找到每個可以直接跳出的點，將這些點與匯點 相連容量為無窮。每個柱子與它可以到達的點的容量也為無窮。

Leapin' Lizards

#include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define eps 1e-12
///#define M 1000100
#define LL __int64
///#define LL long long
///#define INF 0x7ffffff
#define INF 0x3f3f3f3f
#define PI 3.1415926535898
#define zero(x) ((fabs(x)<eps)?0:x)

using namespace std;

const int maxn = 1100;

int cnt;
int n, m;
int cur[maxn], head[maxn];
int dis[maxn], gap[maxn];
int aug[maxn], pre[maxn];
int num[maxn];

struct node
{
    int v, w;
    int next;
} f[2010000];

void init()
{
    cnt = 0;
    memset(head, -1, sizeof(head));
}

void add(int u, int v, int w)
{
    f[cnt].v = v;
    f[cnt].w = w;
    f[cnt].next = head[u];
    head[u] = cnt++;

    f[cnt].v = u;
    f[cnt].w = 0;
    f[cnt].next = head[v];
    head[v] = cnt++;
}

int SAP(int s, int e, int n)
{
    int max_flow = 0, v, u = s;
    int id, mindis;
    aug[s] = INF;
    pre[s] = -1;
    memset(dis, 0, sizeof(dis));
    memset(gap, 0, sizeof(gap));
    gap[0] = n;
    for (int i = 0; i <= n; ++i)  cur[i] = head[i];/// 初始化當前弧為第一條弧
    while (dis[s] < n)
    {
        bool flag = false;
        if (u == e)
        {
            max_flow += aug[e];
            for (v = pre[e]; v != -1; v = pre[v]) /// 路徑回溯更新殘留網路
            {
                id = cur[v];
                f[id].w -= aug[e];
                f[id^1].w += aug[e];
                aug[v] -= aug[e]; /// 修改可增廣量，以後會用到
                if (f[id].w == 0) u = v; /// 不回退到源點，僅回退到容量為0的弧的弧尾
            }
        }
        for (id = cur[u]; id != -1; id = f[id].next)/// 從當前弧開始查詢允許弧
        {
            v = f[id].v;
            if (f[id].w > 0 && dis[u] == dis[v] + 1) /// 找到允許弧
            {
                flag = true;
                pre[v] = u;
                cur[u] = id;
                aug[v] = min(aug[u], f[id].w);
                u = v;
                break;
            }
        }
        if (flag == false)
        {
            if (--gap[dis[u]] == 0) break; ///gap優化，層次樹出現斷層則結束演算法
            mindis = n;
            cur[u] = head[u];
            for (id = head[u]; id != -1; id = f[id].next)
            {
                v = f[id].v;
                if (f[id].w > 0 && dis[v] < mindis)
                {
                    mindis = dis[v];
                    cur[u] = id; /// 修改標號的同時修改當前弧
                }
            }
            dis[u] = mindis + 1;
            gap[dis[u]]++;
            if (u != s) u = pre[u]; /// 回溯繼續尋找允許弧
        }
    }
    return max_flow;
}

char map1[maxn][maxn], map2[maxn][maxn];
int vis[maxn][maxn];

double dist(int x1, int y1, int x2, int y2)
{
    double a = x1, b = y1, c = x2, d = y2;
    return sqrt((a-c)*(a-c)+(b-d)*(b-d));
}
int main()
{
    int Case = 1;
    int d;
    int K;
    cin >>K;
    while(K--)
    {
        scanf("%d %d",&n, &d);
        init();
        memset(vis, 0, sizeof(vis));
        for(int i = 0; i < n; i++) cin >>map1[i];
        for(int j = 0; j < n; j++) cin >>map2[j];
        int len = strlen(map1[0]);
        int k = 0;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < len; j++) if(map1[i][j]-'0' > 0) vis[i][j] = ++k;
        int S = 0;
        int T = 2*k+1;
        int en = T+1;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < len; j++)
            {
                if(map1[i][j]-'0' > 0)
                {
                    add(vis[i][j], vis[i][j]+k, map1[i][j]-'0');
                    for(int ii = 0; ii < n; ii++)
                    {
                        for(int jj = 0; jj < len; jj++)
                        {
                            if(i == ii && j == jj) continue;
                            double s = dist(i, j, ii, jj);
                            if(vis[ii][jj] && (double)d >= s) add(vis[i][j]+k, vis[ii][jj], INF-10);
                        }
                    }
                }
            }
        }
        int kk = 0;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < len; j++)
            {
                if(map2[i][j] == 'L')
                {
                    kk++;
                    add(S, vis[i][j], 1);
                }
            }
        }
        for(int i = 0; i < n; i++)
            for(int j = 0; j < len; j++)
                if(map1[i][j]-'0' > 0) if(i+1<=d || j+1<=d || n-i<=d || len-j<=d) add(vis[i][j]+k, T, INF-10);
        int ans = SAP(S, T, en);
        cout<<"Case #"<<Case++<<": ";
        if(kk-ans == 0) cout<<"no lizard was left behind."<<endl;
        else if(kk-ans == 1) cout<<"1 lizard was left behind."<<endl;
        else cout<<kk-ans<<" lizards were left behind."<<endl;
    }
    return 0;
}