bzoj1066 蜥蜴

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

 

虽然它需要每个蜥蜴不能同时在同一石柱上，但是实际上我们可以让蜥蜴按一定顺序一个一个走，不同时走。那这些排列顺序里一定有一种方案是最优的。

为什么呢？因为最优解不可能出现蜥蜴A跳出去的路径中经过蜥蜴B的初始位置（标记为A->B），并且蜥蜴B跳出去的路径中经过蜥蜴A的初始位置（标记为B->A）。

也就是说要么蜥蜴A跳出去的路径中经过蜥蜴B的初始位置，那么蜥蜴B应该排在蜥蜴A前面走；要么蜥蜴B跳出去的路径中要经过蜥蜴A的初始位置，那么蜥蜴A应该排在蜥蜴B前走。

同样更不会出现A->B且B->C且C->A的情况、A->B且B->C且C->D且D->A的情况，等等。也就是说这个一定是有拓扑序的，不会有环。

那么我们在跑网络流的时候可以不用管它的顺序，直接跑最大流，只要是可行流就一定是可行解，因为一定会有一个蜥蜴的排列顺序满足这个可行流。每个石柱拆成两个点，这两个点间连一条最大流量为石柱高度的点，从S向每个蜥蜴所在石柱连一条最大流量为1的边。T与每个能跳出地图的石柱连一条最大流量为INF的边。石柱与石柱间若距离<=d也相互连最大流量为INF的边。

所以就拆点Dinic。

//Serene
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxn=400*2+10,maxm=maxn*maxn,INF=0x3f3f3f3f;
int n,r,c,d,tot_col,tot_m,sz,S,T;
int bh[maxn][maxn];
char kk;
 
struct Col{
    int x,y,h;
}col[maxn];
 
int aa,ff;char cc;
int read() {
    aa=0;ff=1;cc=getchar();
    while(cc<'0'||cc>'9') {
        if(cc=='-') ff=-1;
        cc=getchar();
    }
    while(cc>='0'&&cc<='9') aa=aa*10+cc-'0',cc=getchar();
    return aa*ff;
}
 
struct Node{
    int x,y,flow,cap;
    Node(){}
    Node(int x,int y,int cap):x(x),y(y),cap(cap){flow=0;}
}node[2*maxm];
 
int cur[maxn],fir[maxn],nxt[2*maxm],e=1;
void add(int x,int y,int z) {
    node[++e]=Node(x,y,z); nxt[e]=fir[x];fir[x]=e;
    node[++e]=Node(y,x,0); nxt[e]=fir[y];fir[y]=e;
}
 
int dis[maxn],zz[maxn];
bool BFS() {
    int s=1,t=0,x,y,z;
    memset(dis,-1,sizeof(dis));
    dis[S]=0;zz[++t]=S;
    while(s<=t) {
        x=zz[s]; 
        for(y=fir[x];y;y=nxt[y]) {
            z=node[y].y;
            if(dis[z]!=-1||node[y].flow>=node[y].cap) continue;
            dis[z]=dis[x]+1;
            zz[++t]=z;
        }
        s++;
    }
    return dis[T]!=-1;
}
 
int DFS(int pos,int maxf) {
    if(pos==T||!maxf) return maxf;
    int now,z,rs=0;
    for(int &y=cur[pos];y;y=nxt[y]) {
        z=node[y].y;
        if(dis[z]!=dis[pos]+1||node[y].flow>=node[y].cap) continue;
        now=DFS(z,min(maxf,node[y].cap-node[y].flow));
        node[y].flow+=now; node[y^1].flow-=now;
        maxf-=now; rs+=now;
    }
    if(!rs) dis[pos]=-1;
    return rs;
}
 
int Dinic() {
    int rs=0;
    while(BFS()) {
        memcpy(cur,fir,sizeof(fir));
        rs+=DFS(S,INF);
    }
    return rs;
}
 
bool ok(int x,int y) {
    return sqrt((double)(col[x].x-col[y].x)*(col[x].x-col[y].x)+(double)(col[x].y-col[y].y)*(col[x].y-col[y].y))<=(double)d;
}
 
int main() {
    r=read();c=read();d=read(); int x;
    for(int i=1;i<=r;++i) {
        kk=getchar();
        while(kk<'0'||kk>'9') kk=getchar();
        x=kk-'0';
        for(int j=1;j<=c;++j) {
            if(x) {
                col[++tot_col].x=i;
                col[tot_col].y=j;
                col[tot_col].h=x;
                bh[i][j]=tot_col;
            }
            kk=getchar();x=kk-'0';
        }
    }
    S=2*tot_col+1;T=S+1;
    for(int i=1;i<=tot_col;++i) {
        add(i,i+tot_col,col[i].h);
        if(min(col[i].x,r-col[i].x+1)<=d||min(col[i].y,c-col[i].y+1)<=d) add(i+tot_col,T,INF);
        for(int j=1;j<=tot_col;++j){
            if(i==j) continue;
            else if(ok(i,j)) add(i+tot_col,j,INF);
        }
    }
    for(int i=1;i<=r;++i) {
        kk=getchar();
        while(kk!='.'&&kk!='L') kk=getchar();
        for(int j=1;j<=c;++j) {
            if(kk=='L') 
                add(S,bh[i][j],1),n++;
            kk=getchar();
        }
    }
    printf("%d",n-Dinic());
    return 0;
}