引水入城（dfs的做法）洛谷p1514

在这道题中，

由于每个点所能到达的地方是一定的，并且若底层能够填满，那么到达底层的位置一定

所以我们可以把每个点所到达的最底层记录下来，若访问到某一之前到达过的点，直接用这个点所到达的底层的点更新即可。

这样每个点我们只会访问一次，时间复杂度是O（n^2）的。

然后我们就得到了最上层能够到达下层的范围，这样，就可以抽象成为线段覆盖，然后我们用尽可能少的线段填满这个数轴，具体做法是先将线段从小到大排一遍序，记录上一次的终点，在不产生间隙的前提下选择终点最大的作为下一条线段。

代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN = 505;
const int X[] = {1,0,-1,0};
const int Y[] = {0,1,0,-1};
int n,m,cnt = 0,ma[MAXN][MAXN];
struct zt
{
int l,r;
bool hav;
}ji[MAXN][MAXN];
bool can(int x,int y,int x1,int y1)
{
if(x < 1||x > n)    return false;
if(y < 1||y > m)    return false;
if(ma[x][y] >= ma[x1][y1])    return false;
return true;
}
bool comp(zt a,zt b)
{
return a.l == b.l ? a.r < b.r : a.l < b.l;
}
void dfs(int x,int y)
{
if(ji[x][y].hav)
return;
for(int i = 0;i < 4;i ++)
{
int x1 = x + X[i],y1 = y + Y[i];
if(can(x1,y1,x,y))
{
dfs(x1,y1);
ji[x][y].l = min(ji[x][y].l,ji[x1][y1].l);
ji[x][y].r = max(ji[x][y].r,ji[x1][y1].r);
}
}
ji[x][y].hav = 1;
if(x == n)
{
ji[x][y].l = min(ji[x][y].l,y);
ji[x][y].r = max(ji[x][y].r,y);
}
return;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i = 1;i <= n;i ++)
for(int j = 1;j <= m;j ++)
{
scanf("%d",&ma[i][j]);
ji[i][j].hav = 0;
ji[i][j].l = 505;
ji[i][j].r = 0;
}
for(int i = 1;i <= m;i ++)
dfs(1,i);
for(int i = 1;i <= m;i ++)
if(!ji
[i].hav)
cnt ++;
if(cnt)
printf("0\n%d",cnt);
else
{
sort(ji[1] + 1,ji[1] + 1 + m,comp);
int a = 1,b = 0;cnt = 0;
for(int i = 1;i <= m;i ++)
{
if(i != m&&ji[1][i + 1].l <= a)
{
b = max(b,ji[1][i].r);
continue;
}
b = max(b,ji[1][i].r);
if(a > m)
break;
cnt ++;a = b + 1;
}
printf("1\n%d",cnt);
}
}