【解题报告】 Leapin' Lizards HDU 2732 网络流

【解题报告】 Leapin' Lizards HDU 2732 网络流

题外话

　　在正式讲这个题目之前我想先说几件事
　　1. 如果大家要做网络流的题目，我在网上看到一个家伙，他那里列出了一堆网络流的题目，而且还给他们分门别类，并且标注了难度，感觉挺好的，网址是[夏天的风](https://blog.csdn.net/shahdza/article/details/7779537)
　　2. 这道题有个坑点！！！！

正题

　　首先，当然是直接贴上[题目](http://acm.hdu.edu.cn/showproblem.php?pid=2732)的链接,题号是2732。
　　然后接下来是CSDN的链接(https://blog.csdn.net/Liang_Si_FFF/article/details/84992526)。

题目大意

* 现在给你一个n*m的矩阵，每一个点表示一根柱子，柱子之间没有道路。

* 在某些柱子上面，会有蜥蜴，（每一个柱子上面最多一个蜥蜴），现在他们被困在那里了。但是每个蜥蜴都可以跳，跳的距离为d，所以只要两根柱子的距离不超过d，他们就可以跳到相邻的柱子上面。如果一个蜥蜴可以跳出矩阵外面，那么它就得救了。坑点来了！不知道是我题目没有看清楚的缘故，还是题目没有明说的缘故，这里的距离指的是曼哈顿距离。要不是我看了别人的题解，我还会一直困在样例数据呢

* 但是，每一根柱子的质量都不是很好，都有一个寿命值（整数）。每当有一个蜥蜴从这跟柱子起跳，这跟柱子的寿命值就会减一，减到0之后柱子就断了。（只有起跳的时候会减，如果有一个蜥蜴跳到这上面，是不会有事的）

* 现在问你，不能获救的蜥蜴最少是多少了？

* 坑点二：输出数据的时候，不仅要注意有和没有，而且还要注意单复数。不过还好，我一开始就注意到了。比如下面：

Case #1: 2 lizards were left behind.
Case #2: no lizard was left behind.
Case #3: 3 lizards were left behind.
Case #4: 1 lizard was left behind.

构图方法

1. 拆点，将每一个点拆成两个点，分别叫做start和end，start，然后再start之间连一条容量为寿命值的边，表示这个柱子最多只能跳几次。

2. 如果一个蜥蜴可以从柱子u跳到柱子v上面，则从u~end~连一条边到v~start~，（容量随意，只要大于u的寿命值就行）表示蜥蜴能够从这个柱子跳到另一个柱子。

3. 如果一个蜥蜴能够从柱子u跳出这个矩阵，那么就从u~end~连一条边到汇点T（同样容量随意，只要大于u的寿命值就行）

4. 如果某一个柱子u上面在初始状态下是有蜥蜴的，那么从头源点S连一条边到u~start~,容量为1，表示这个柱子上面只有一个蜥蜴（毕竟题目里面说了嘛，每根柱子上面最多只有一个蜥蜴）

5. 这个图的最大流就是能够逃出去的蜥蜴的数量。所以提前算出有多少了蜥蜴之后，减去最大流，就是不能获救的蜥蜴的个数。

AC代码

 #include<cstdio>
 #include<cstring>
 #include<queue>
 using namespace std;
 const int INF=;
 const int N=;
 const int M=N*N;
 int Head[N],Next[M],Ver[M],Edge[M],tot=;//利用前向星储存
 int D[N];//dinic算法需要用到的深度值
 int map[][];//用来存每一个柱子的寿命值
 int mark[][];//给每一个柱子标号
 int S=,T=;
 char temp[];//由于题目用字符串输入，所以弄一个字符数组
 void add(int,int,int);//连边函数
 bool bfs(void);//dinic算法数深度函数
 int dinic(int,int);//就是dinic
 int min(int,int);
 int max(int,int);
 int abs(int);
 int main()
 {
     int Case;
     scanf("%d",&Case);//总共要Case组数据
     for(int cnt=;cnt<=Case;cnt++)
     {
         memset(Head,,sizeof(Head));
         int n,d,m=;
         scanf("%d%d",&n,&d);
         getchar();
         for(int i=;i<=n;i++)
         {
             fgets(temp,,stdin);
             if(!m) m=strlen(temp)-;
             for(int j=;j<=m;j++)
                 map[i][j]=temp[j-]-'';
         }
         int k=;
         for(int i=;i<=n;i++)
             for(int j=;j<=m;j++)
                 mark[i][j]=k++;//这个地方就是给每一根柱子都标一个号
                 //然后就用这个号码来标注柱子u的u_start,用u_start+T表示
                 //u_end
         for(int i=;i<=n;i++)
             for(int j=;j<=m;j++)
             {
                 if(map[i][j])
                 {
                     add(mark[i][j],mark[i][j]+T,map[i][j]);
                     if(i-d<||i+d>n||j-d<||j+d>m)
                         add(mark[i][j]+T,T,map[i][j]);
                     int L=min(m,j+d),U=min(n,i+d);
                     for(int I=max(,i-d);I<=U;I++)
                         for(int J=max(,j-d);J<=L;J++)
                             if(map[I][J]&&(I!=i||J!=j)&&(abs(I-i)+abs(J-j)<=d))
                                 add(mark[i][j]+T,mark[I][J],map[i][j]);
 
                 }
             }
         int sum=;
         for(int i=;i<=n;i++)
         {
             fgets(temp,,stdin);
             for(int j=;j<=m;j++)
                 if(temp[j-]=='L')
                 {
                     add(S,mark[i][j],);
                     sum++;
                 }
         }
         int max_flow=;
         while(bfs()) max_flow+=dinic(S,INF);
         int left=sum-max_flow;
         if(left==)
             printf("Case #%d: no lizard was left behind.\n",cnt);
         else if(left==)
             printf("Case #%d: 1 lizard was left behind.\n",cnt);
         else printf("Case #%d: %d lizards were left behind.\n",cnt,left);
     }
     return ;
 }
 int dinic(int x,int flow)
 {
     if(x==T) return flow;
     int rest=flow;
     for(int p=Head[x];rest&&p;p=Next[p])
     {
         if(D[Ver[p]]==D[x]+&&Edge[p])
         {
             int k=dinic(Ver[p],min(rest,Edge[p]));
             if(!k) D[Ver[p]]=;
             Edge[p]-=k;
             Edge[p^]+=k;
             rest-=k;
         }
     }
     return flow-rest;
 }
 bool bfs(void)
 {
     memset(D,,sizeof(D));
     queue <int> q;
     q.push(S);
     D[S]=;
     while(!q.empty())
     {
         int x=q.front();
         q.pop();
         for(int p=Head[x];p;p=Next[p])
             if(!D[Ver[p]]&&Edge[p])
             {
                 D[Ver[p]]=D[x]+;
                 if(Ver[p]==T) return ;
                 q.push(Ver[p]);
             }
     }
     return ;
 }
 void add(int u,int v,int c)
 {
     Next[++tot]=Head[u],Head[u]=tot,Edge[tot]=c,Ver[tot]=v;
     Next[++tot]=Head[v],Head[v]=tot,Edge[tot]=,Ver[tot]=u;
 }
 inline int min(int a,int b)
 {
     return a<b?a:b;
 }
 inline int max(int a,int b)
 {
     return a>b?a:b;
 }
 inline int abs(int x)
 {
     return x<?-x:x;
 }