BZOJ 1066 蜥蜴 （拆点网络流）

1066: [SCOI2007]蜥蜴

Time Limit: 1 Sec Memory Limit: 162 MB
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的边。
然后对于到边界距离小于d的石柱，连一条边到汇点。
对于曼哈顿距离小于d的a和b，在这两个石柱拆出的每一对出点和入点上连边，流量为INF。

#include <cstdio>  
#include <iostream> 
#include <cstring> 
#define inf 0x7fffffff  
using namespace std; 

const int N = 810, M = 80010;  

int read(){  
    int v=0; char ch=getchar();  
    while (ch<'0'||ch>'9') ch=getchar();  
    while (ch<='9'&&ch>='0') { v=v*10+ch-'0'; ch=getchar();}  
    return v;  
}  

char hgt[25][25], pos[25][25];  
int S,T,n,m,idc=1,d,cnt;  
int head[N+M],last[N+M];

struct Edge {  
    int next, to, w;
}ed[2*M];  

inline void adde(int u, int v, int w){
    ed[++idc].to = v; 
    ed[idc].w = w;
    ed[idc].next = head[u];
    last[u]= head[u] = idc;
    ed[++idc].to = u; 
    ed[idc].w = 0;
    ed[idc].next = head[v];
    last[v]= head[v] = idc;  
}  
int ans, q[N+M], l, r, dis[N+M], inq[N+M];  

bool bfs(){
    memset(dis, -1, sizeof(dis));
    int l=0, r=1;  
    q[1]=S; dis[S]=0;  
    while(l < r){
        int u = q[++l];  
        for(int k=head[u]; k; k=ed[k].next) {
            int v = ed[k].to;
            if(ed[k].w && dis[v] == -1){  
                dis[v] = dis[u] + 1;
                q[++r] = v;
                if(v == T) break;//到达 
            }
        }
    }
    for(int i=S; i<=T; i++){//i=s~t
        last[i] = head[i];
    }
    return dis[T] != -1;//能否到达 
}  

int find(int u, int low){
    if (u==T || low==0) return low;  
    int totflow = 0;
    for(int k=last[u]; k; last[u]=k=ed[k].next){//当前弧优化 
        int v = ed[k].to;
        if(ed[k].w && dis[v] == dis[u] + 1){
            int f = find(v, min(low,ed[k].w));  
            ed[k].w -= f; ed[k^1].w += f;  
            totflow += f; low -= f;
            //if(ed[k].w) last[u]=k;
            if(low == 0) return totflow;//满流
        }
    }
    if( !totflow ) dis[u] = -1;//满流
    return totflow;  
} 

int dinic(){  
    ans = 0;
    while (bfs()) ans+=find(S,inf);  
    return ans;  
}  

int main(){  
    //1~n*m 蜥蜴位置（入度石柱） 1+n*m~n*m+n*m 出度石柱 
    n=read(), m=read(); d=read();   
    S=0; T=2*n*m+1;
    for(int i=1; i<=n; i++) scanf("%s", hgt[i]+1);  
    for(int i=1; i<=n; i++) scanf("%s", pos[i]+1);  
    for(int i=1; i<=n; i++) 
        for(int j=1; j<=m; j++){ 
            int pit = (i - 1) * m + j;//蜥蜴 
            if(pos[i][j] == 'L') adde(S, pit, 1), ++cnt;  
            if(hgt[i][j] != '0'){
                adde(pit, pit+n*m, hgt[i][j]-'0');//可以过点的流量 
                if(i<=d || j<=d || i+d>n || j+d>m)//可以跳出边界 
                    adde(pit+n*m, T, inf);//石柱 
                for(int k=max(i-d,1); k<=min(i+d,n); k++)//可以到达的横坐标范围 
                    for(int t=max(j-d+max(i-k,k-i),1); t<=min(j+d-max(i-k,k-i),m); t++)//可以到达的纵坐标范围 
                        if(hgt[k][t] > '0') adde(pit+n*m, (k-1)*m+t, inf);//出度石柱到入度石柱inf 
            }  
        }  
    dinic();
    printf("%d\n", cnt-ans);  
    return 0;  
}