[BZOJ1066][SCOI2007]蜥蜴-网络流

蜥蜴

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

Source

Pku 2711 Leapin’ Lizards

---

网络流大水题……
然而咱忘记了初始化源汇……
居然这还过了样例……

---

思路:
简单粗暴的一个拆点。
只需要，把每个柱子拆成两个点分别表示跳入和跳出，跳入往跳出连一条流量为该柱子高度的边代表这根柱子只能被跳高度次。
然后，柱子与它可到达的柱子连Inf边，有蜥蜴的柱子与源点连1的边，可以出去的与汇点连Inf边。
然后，做完了……

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

const int P=109;
const int M=100009;
const int N=1009;
const int Inf=1e9;

int r,c,d,ans;
int f[P][P],id[P][P];

int s,t,n,nn;
int to[M],nxt[M],cap[M],beg[N],tot=1;
int dis[N];
queue<int> q;

inline int maxx(int a,int b){if(a>b)return a;return b;}
inline int minn(int a,int b){if(a<b)return a;return b;}

inline void adde(int u,int v,int w)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    cap[tot]=w;
    beg[u]=tot;
}

inline void add(int u,int v,int w)
{
    adde(u,v,w);
    adde(v,u,0);
}

inline bool bfs()
{
    while(!q.empty())q.pop();
    for(int i=0;i<=t;i++)
        dis[i]=Inf;

    q.push(s);
    dis[s]=1;

    while(!q.empty())
    {
        int u=q.front();q.pop();

        for(int i=beg[u],v;i;i=nxt[i])
            if(dis[v=to[i]]==Inf && cap[i])
            {
                dis[v]=dis[u]+1;
                q.push(v);
            }
    }

    return dis[t]!=Inf;
}

inline int dfs(int u,int mflow)
{
    if(!mflow || u==t)
        return mflow;

    int cost=0;
    for(int i=beg[u],v,f;i;i=nxt[i])
    {
        if(dis[v=to[i]]==dis[u]+1 && cap[i])
        {
            f=dfs(v,minn(cap[i],mflow-cost));
            cap[i]-=f;
            cap[i^1]+=f;
            cost+=f;

            if(cost==mflow)break;
        }
    }

    if(cost==0)
        dis[u]=0;

    return cost;
}

inline int dinic(int ss,int tt)
{
    s=ss;t=tt;
    int ans=0;
    while(bfs())
        ans+=dfs(ss,Inf);
    return ans;
}

inline int sqr(int x)
{
    return x*x;
}

inline bool judge(int i,int j,int k,int l)
{
    if(i==k && j==l)
        return 0;
    if(!f[i][j] || !f[k][l])
        return 0;
    if(sqr(i-k)+sqr(j-l)>sqr(d))
        return 0;
    return 1;
}

inline bool can(int i,int j)
{
    return minn(i,minn(r-i+1,minn(j,c-j+1)))<=d;
}

int main()
{
    scanf("%d%d%d",&r,&c,&d);

    char ch[100];
    for(int i=1;i<=r;i++)
    {
        scanf("%s",ch+1);
        for(int j=1;j<=c;j++)
        {
            f[i][j]=ch[j]-'0';
            if(f[i][j])
                id[i][j]=n++;
        }
    }

    s=2*r*c+1,t=s+1;
    for(int i=1;i<=r;i++)
    {
        scanf("%s",ch+1);
        for(int j=1;j<=c;j++)
        {
            if(f[i][j]!=0)
            {
                add(id[i][j],id[i][j]+n,f[i][j]);

                for(int k=maxx(i-d,1),ek=minn(i+d,r);k<=ek;k++)
                    for(int l=maxx(j-d,1),el=minn(j+d,c);l<=el;l++)
                        if(judge(i,j,k,l))
                            add(id[i][j]+n,id[k][l],Inf);

                if(can(i,j))
                    add(id[i][j]+n,t,Inf);
            }

            if(ch[j]=='L')
            {
                add(s,id[i][j],1);
                ans++;
            }
        }
    }

    ans-=dinic(s,t);
    printf("%d\n",ans);

    return 0;
}