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

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(,));

 }

巴特西