1066. [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

辣鸡BZOJ……别的OJ都A了就它A不了……
一开始看到高度不超过三，以为是什么炒鸡神奇的拆点操作……
后来想不出来神奇的拆点操作
就随便把点拆成了一个入点一个出点
两点间的容量为柱子的高度
再增设一个超级源点0和各个起点链接，容量为1（1只蜥蜴）
然后其他的边就全部INF好了……
瞎搞搞就过了

UPDATE:改过了……luogu不加优化0ms，BZOJ加了优化还88ms……emmm……

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#define MAXM (1000000+10)
#define MAXN (100000+10)
using namespace std;

struct node
{
    int Flow;
    int next;
    int to;
} edge[MAXM*2];
int Depth[MAXN],q[MAXN];
int head[MAXN],num_edge;
int n,m,s,e,d,INF;
int a[101][101];
char ch;

void add(int u,int v,int l)
{
    edge[++num_edge].to=v;
    edge[num_edge].Flow=l;
    edge[num_edge].next=head[u];
    head[u]=num_edge;
}

bool Bfs(int s,int e)
{
    int Head=0,Tail=1;
    memset(Depth,0,sizeof(Depth));
    Depth[s]=1;
    q[1]=s;
    while (Head<Tail)
    {
        ++Head;
        int x=q[Head];
        for (int i=head[x]; i!=0; i=edge[i].next)
            if (!Depth[edge[i].to] && edge[i].Flow>0)
            {
                Depth[edge[i].to]=Depth[x]+1;
                q[++Tail]=edge[i].to;
            }
    }
    if (Depth[e]>0) return true;
    return false;
}

int Dfs(int x,int low)
{
    int Min,f=0;
    if (x==e || low==0)
        return low;
    for (int i=head[x]; i!=0; i=edge[i].next)
        if (edge[i].Flow>0 && Depth[edge[i].to]==Depth[x]+1 && (Min=Dfs(edge[i].to , min(low,edge[i].Flow) )))
        {
            edge[i].Flow-=Min;
            edge[((i-1)^1)+1].Flow+=Min;
            f+=Min;
            low-=Min;
            if (low==0) break;
        }
    if (!f) Depth[x]=-1;
    return f;
}

int Dinic(int s,int e)
{
    int Ans=0;
    while (Bfs(s,e))
        Ans+=Dfs(s,0x7fffffff);
    return Ans;
}

int main()
{
    s=0,e=520;
    int Sum=0;
    memset(&INF,0x7f,sizeof(INF));
    scanf("%d%d%d",&n,&m,&d);
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
        {
            cin>>ch;
            a[i][j]=ch-48;
        }
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
        {
            add((i-1)*m+j,(i-1)*m+j+999,a[i][j]);
            add((i-1)*m+j+999,(i-1)*m+j,a[i][j]);
        }
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
        {
            cin>>ch;
            if (ch=='L')
            {
                ++Sum;
                add(0,(i-1)*m+j,1);
                add((i-1)*m+j,0,0);
            }
        }
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
            if (a[i][j]!=0 && (i<=d || j<=d || m-j<d || n-i<d))
            {
                add((i-1)*m+j+999,520,INF);
                add(520,(i-1)*m+j+999,0);
            }
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
            for (int k=1; k<=n; ++k)
                for (int l=1; l<=m; ++l)
                    if (!(i==k && j==l) && a[i][j]!=0 && a[k][l]!=0 && sqrt((i-k)*(i-k)+(j-l)*(j-l))<=d)
                    {
                        add((i-1)*m+j+999,(k-1)*m+l,INF);
                        add((k-1)*m+l,(i-1)*m+j+999,0);
                    }
    printf("%d",Sum-Dinic(0,520));
}