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

在这道题中，
由于每个点所能到达的地方是一定的，并且若底层能够填满，那么到达底层的位置一定
所以我们可以把每个点所到达的最底层记录下来，若访问到某一之前到达过的点，直接用这个点所到达的底层的点更新即可。

但是我们不可能将每一个点记下来，我们可以记录左右端点

假设中间会有断点，我们可以直接判断该点无法到达，也就没看有必要求水站的个数了
故可以直接假设可以覆盖的范围为一段
这样每个点我们只会访问一次，时间复杂度是O（n^2）的。
然后我们就得到了最上层能够到达下层的范围，这样，就可以抽象成为线段覆盖，然后我们用尽可能少的线段填满这个数轴，具体做法是先将线段从小到大排一遍序，记录上一次的终点，在不产生间隙的前提下选择终点最大的作为下一条线段。

代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define re register 
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];//记忆化 
inline int read()//手读 
{
	int x = 0,f = 1;
	char c = getchar();
	while(c < '0'||c > '9') {if(c == '-') f = -1;c = getchar();}
	while(c >= '0'&&c <= '9') x = (x << 3) + (x << 1) + c - '0',c = getchar();
	return x * f;
}
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(re 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()
{
	n = read();m = read();
    for(re int i = 1;i <= n;i ++)
        for(re int j = 1;j <= m;j ++)
        {
        	ma[i][j] = read();
            ji[i][j].hav = 0;
            ji[i][j].l = 505;
            ji[i][j].r = 0;
         }
    for(re int i = 1;i <= m;i ++)
        dfs(1,i);
    for(re int i = 1;i <= m;i ++)
        if(!ji[n][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;//a为上一次放的终点，b为能够找到的最大的下个终点 
        for(re 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);
            cnt ++;a = b + 1;
            if(a > m) break;
        }
        printf("1\n%d",cnt);
    }
}