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*];
 int Depth[MAXN],q[MAXN];
 int head[MAXN],num_edge;
 int n,m,s,e,d,INF;
 int a[][];
 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=,Tail=;
     memset(Depth,,sizeof(Depth));
     Depth[s]=;
     q[]=s;
     while (Head<Tail)
     {
         ++Head;
         int x=q[Head];
         for (int i=head[x]; i!=; i=edge[i].next)
             if (!Depth[edge[i].to] && edge[i].Flow>)
             {
                 Depth[edge[i].to]=Depth[x]+;
                 q[++Tail]=edge[i].to;
             }
     }
     if (Depth[e]>) return true;
     return false;
 }

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

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

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