hdu 2732 最大流 **

题意:题目是说一个n*m的迷宫中,有每个格子有柱子。柱子高度为0~3,高度为0的柱子是不能站的(高度为0就是没有柱子)在一些有柱子的格子上有一些蜥蜴,一次最多跳距离d,相邻格子的距离是1,只要跳出迷宫就是安全的。这个距离是曼哈顿距离(好像是的)。蜥蜴一次最多跳距离d,但是起跳的地方的柱子高度会减一,一个柱子同一时间只能有一个蜥蜴要求最少几个不能逃出迷宫。

链接:点我

看懂了,明天拍

  1 //============================================================================
  2 // Name        : HDU.cpp
  3 // Author      :
  4 // Version     :
  5 // Copyright   : Your copyright notice
  6 // Description : Hello World in C++, Ansi-style
  7 //============================================================================
  8
  9 #include <iostream>
 10 #include <string.h>
 11 #include <stdio.h>
 12 #include <algorithm>
 13 using namespace std;
 14
 15 const int MAXN=2200;
 16 const int MAXM=200020;
 17 const int INF=0x3f3f3f3f;
 18 struct Node
 19 {
 20     int to,next,cap;
 21 }edge[MAXM];//注意是MAXM
 22 int tol;
 23 int head[MAXN];
 24 int gap[MAXN],dis[MAXN],pre[MAXN],cur[MAXN];
 25
 26 void init()
 27 {
 28     tol=0;
 29     memset(head,-1,sizeof(head));
 30 }
 31 void addedge(int u,int v,int w,int rw=0)
 32 {
 33     edge[tol].to=v;edge[tol].cap=w;edge[tol].next=head[u];head[u]=tol++;
 34     edge[tol].to=u;edge[tol].cap=rw;edge[tol].next=head[v];head[v]=tol++;
 35 }
 36 int sap(int start,int end,int nodenum)
 37 {
 38     memset(dis,0,sizeof(dis));
 39     memset(gap,0,sizeof(gap));
 40     memcpy(cur,head,sizeof(head));
 41     int u=pre[start]=start,maxflow=0,aug=-1;
 42     gap[0]=nodenum;
 43     while(dis[start]<nodenum)
 44     {
 45         loop:
 46         for(int &i=cur[u];i!=-1;i=edge[i].next)
 47         {
 48             int v=edge[i].to;
 49             if(edge[i].cap&&dis[u]==dis[v]+1)
 50             {
 51                 if(aug==-1||aug>edge[i].cap)
 52                     aug=edge[i].cap;
 53                 pre[v]=u;
 54                 u=v;
 55                 if(v==end)
 56                 {
 57                     maxflow+=aug;
 58                     for(u=pre[u];v!=start;v=u,u=pre[u])
 59                     {
 60                         edge[cur[u]].cap-=aug;
 61                         edge[cur[u]^1].cap+=aug;
 62                     }
 63                     aug=-1;
 64                 }
 65                 goto loop;
 66             }
 67         }
 68         int mindis=nodenum;
 69         for(int i=head[u];i!=-1;i=edge[i].next)
 70         {
 71             int v=edge[i].to;
 72             if(edge[i].cap&&mindis>dis[v])
 73             {
 74                 cur[u]=i;
 75                 mindis=dis[v];
 76             }
 77         }
 78         if((--gap[dis[u]])==0)break;
 79         gap[dis[u]=mindis+1]++;
 80         u=pre[u];
 81     }
 82     return maxflow;
 83 }
 84
 85 char g1[30][30];
 86 char g2[30][30];
 87 int mat[30][30];
 88
 89 int main()
 90 {
 91     //freopen("in.txt","r",stdin);
 92     //freopen("out.txt","w",stdout);
 93     int T;
 94     int n,d;
 95     int iCase=0;
 96     scanf("%d",&T);
 97     while(T--)
 98     {
 99         iCase++;
100         scanf("%d%d",&n,&d);
101         init();
102         int tol=0;
103         for(int i=0;i<n;i++)
104             scanf("%s",&g1[i]);
105         int m=strlen(g1[0]);
106         memset(mat,0,sizeof(mat));
107         for(int i=0;i<n;i++)
108             for(int j=0;j<m;j++)
109                 if(g1[i][j]>‘0‘)
110                 {
111                     mat[i][j]=++tol;
112                     addedge(2*tol-1,2*tol,g1[i][j]-‘0‘);
113                 }
114
115         int start=0,end=2*tol+1,nodenum=2*tol+2;
116         //进行拆点,加上源点和汇点,共2*tol+2个点。
117         int sum=0;//总数
118         for(int i=0;i<n;i++)
119         {
120             scanf("%s",&g2[i]);
121             for(int j=0;j<m;j++)
122                 if(g2[i][j]==‘L‘)
123                 {
124                     sum++;
125                     addedge(start,2*mat[i][j]-1,1);
126                 }
127         }
128         for(int i=0;i<n;i++)
129             for(int j=0;j<m;j++)
130                 if(mat[i][j])
131                 {
132                     for(int x=-d;x<=d;x++)
133                         for(int y=abs(x)-d;y<=d-abs(x);y++)
134                         {
135                             int newi=i+x;
136                             int newj=j+y;
137                             if(newi<0||newi>=n||newj<0||newj>=m)continue;
138                             if(mat[newi][newj]==0)continue;
139                             if(newi==i&&newj==j)continue;
140                             addedge(2*mat[i][j],2*mat[newi][newj]-1,INF);
141                         }
142                     if(i<d||j<d||n-i<=d||m-j<=d)
143                         addedge(2*mat[i][j],end,INF);
144                 }
145         int ans=sum-sap(start,end,nodenum);
146         if(ans==0)printf("Case #%d: no lizard was left behind.\n",iCase);
147         else if(ans==1)printf("Case #%d: 1 lizard was left behind.\n",iCase);
148         else printf("Case #%d: %d lizards were left behind.\n",iCase,ans);
149     }
150     return 0;
151 }

2015/5/26

时间: 2024-10-26 07:04:56

hdu 2732 最大流 **的相关文章

Leapin&#39; Lizards (hdu 2732 最大流)

Leapin' Lizards Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1433    Accepted Submission(s): 586 Problem Description Your platoon of wandering lizards has entered a strange room in the labyr

K - Leapin&#39; Lizards - HDU 2732(最大流)

题意:在一个迷宫里面有一些蜥蜴,这个迷宫有一些柱子组成的,并且这些柱子都有一个耐久值,每当一只蜥蜴跳过耐久值就会减一,当耐久值为0的时候这个柱子就不能使用了,每个蜥蜴都有一个最大跳跃值d,现在想知道有多少蜥蜴不能离开迷宫(跳出迷宫就可以离开了.) 输入描述:输入矩阵的行M和跳跃值D,接着输入两个矩阵(列数自己求),第一个矩阵是每个柱子的耐久值,下面一个矩阵有'L'的表示这个柱子上有一只蜥蜴. 分析:题目明白还是比较容易的,矩阵的点数是20*20,也就400个点,对每个有耐久值的柱子进行拆点,然后

hdu 2732 Leapin&#39; Lizards(最大流)Mid-Central USA 2005

废话: 这道题不难,稍微构造一下图就可以套最大流的模板了.但是我还是花了好久才解决.一方面是最近确实非常没状态(托词,其实就是最近特别颓废,整天玩游戏看小说,没法静下心来学习),另一方面是不够细心,输出格式错了大意没有发现死一只和死多只之间的区别,卡在那里动不了. 题意: 在一张n*m的地图中,有一群蜥蜴,这群蜥蜴每次可以跳跃曼哈顿距离d(曼哈顿距离——dis(a, b) = |ax-bx|+|ay-by|,之后所有的距离都是曼哈顿距离),这些蜥蜴只能在地图上的一些柱子上跳跃.柱子i最多可以支持

HDU 2732 Leapin&#39; Lizards(最大流)

Leapin' Lizards Problem Description Your platoon of wandering lizards has entered a strange room in the labyrinth you are exploring. As you are looking around for hidden treasures, one of the rookies steps on an innocent-looking stone and the room's

HDU 2732 Leapin&amp;#39; Lizards(拆点+最大流)

HDU 2732 Leapin' Lizards 题目链接 题意:有一些蜥蜴在一个迷宫里面,有一个跳跃力表示能跳到多远的柱子,然后每根柱子最多被跳一定次数,求这些蜥蜴还有多少是不管怎样都逃不出来的. 思路:把柱子拆点建图跑最大流就可以,还是挺明显的 代码: #include <cstdio> #include <cstring> #include <cmath> #include <queue> #include <algorithm> usin

HDU 2732 Leapin&#39; Lizards(拆点+最大流)

题目意思是有一些蜥蜴在一个迷宫里面,求这些蜥蜴还有多少是无论如何都逃不出来的.题目只给定一个行数n,一个最远能够跳跃的距离d.每只蜥蜴有一个初始的位置,题目保证这些位置都有一些柱子,但是它每离开一根柱子,柱子的高度就会降低1m,问最多能有多少只跳不出去. 将每个柱子在的点进行拆点,把每一个点拆完之后连一条容量为所在点柱子高度的边.从原点连一条容量为1的边,然后找到每个可以直接跳出的点,将这些点与汇点 相连容量为无穷.每个柱子与它可以到达的点的容量也为无穷. Leapin' Lizards Tim

HDU 2732 Leapin&#39; Lizards(拆点+最大流)

HDU 2732 Leapin' Lizards 题目链接 题意:有一些蜥蜴在一个迷宫里面,有一个跳跃力表示能跳到多远的柱子,然后每根柱子最多被跳一定次数,求这些蜥蜴还有多少是无论如何都逃不出来的. 思路:把柱子拆点建图跑最大流即可,还是挺明显的 代码: #include <cstdio> #include <cstring> #include <cmath> #include <queue> #include <algorithm> using

HDU 2732 Leapin&#39; Lizards(拆点法+最大流)

该题是一道比较简单拆点+最大流的题目,因为每个柱子都有一定的寿命,很容易将其对应成流量,那么处理结点容量的一般方法当然是拆点法 .该题反而对边的容量没有要求,为保险起见可以设成无穷大.   该题的思路很好想,建议独立编写代码 . 推荐题目: 点击打开链接    结点法的一些见解 也可以看这里. 细节参见代码: #include<bits/stdc++.h> using namespace std; typedef long long ll; const int INF = 100000000;

hdu 4888 最大流给出行列和求矩阵

第一步,考虑如何求是否有解.使用网络流求解,每一行和每一列分别对应一个点,加上源点和汇点一共有N+M+2个点.有三类边: 1. 源点 -> 每一行对应的点,流量限制为该行的和 2. 每一行对应的点 -> 每一列对应的点,流量限制为 K 3. 每一列对应的点 -> 汇点,流量限制为该列的和 对上图做最大流,若源点出发的边和到达汇点的边全都满流,则有解,否则无解.若要求构造方案,则 (i,j) 对应的整数就是行 i–> 列 j 的流量. 第二步,考虑解是否唯一.显然,解唯一的充分必要条