Codevs 1066 引水入城 2010年NOIP全国联赛提高组 BFS + 贪心

Codevs 1066 引水入城

题目上没有给出样例二，只给出了样例二的图，真是奇怪（丧心病狂）。

Input2：

3 6 
8 4 5 6 4 4 
7 3 4 3 3 3 
3 2 2 1 1 2 

Output2：

1 
3 

思路：

从第一行能建造蓄水站的每个点 搜索一遍， 结果有2种：

1.到不了最后一行。
2.到的地方为最后一行的某个区间。

2的证明（待补）：

所以说我在搜索的时候加了一个 ans[i] 数组，表示 能否到 最后一行 i 这个点， 搜索完了之后，遍历一遍 ans 数组， 如果有到不了的点，输出 0 和 个数。

如果都能到达，开始考虑 最少蓄水站：

因为一个蓄水站到达的最低层的点一定是连续的（区间）， 那我们可以抽象成有 tot 个区间，从 tot 个区间中选出最少的 个数能把 最后一行全覆盖。这里太弱了，没想出来，于是去了黄学长博客，和DQS学长的博客， 结合着DQS的解释，看了一下，勉强看懂。

DQS的解释

还有一个重要的剪枝：

试想， 在第一行时， 如果某节点 不用建造蓄水站， 别的节点建了蓄水站，直接能把水引到这个节点来， 那这个节点能够到达的节点肯定 <= 能引水到这个节点的更高的蓄水站，由此剪枝。

代码：（由于最后WA的不行了，于是采取 与 zhx安利的小黄鸭调试法 类似的打注释，终于AC）

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 500 + 5;
const int dx[] = {0,1,0,-1,0};
const int dy[] = {0,0,-1,0,1};
int n, m, tot = 0;
int h[MAXN][MAXN], dp[MAXN];
bool vis[MAXN][MAXN], can[MAXN], ans[MAXN], tp[MAXN];
struct U{
    int x, y;
};

U Seg[MAXN];
queue <U> q;
void bfs(int sx, int sy)
{
    q.push((U){sx,sy});
    vis[sx][sy] = 1;
    while(q.size())
    {
        int x = q.front().x;
        int y = q.front().y;//上一个点的节点。 
        q.pop();
        for(int i = 1; i <= 4; i ++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];// 开始扩展. 
            if((nx >= 1) && (nx <= n) && (ny >= 1) && (ny <= m) && (h[nx][ny] < h[x][y]) && !vis[nx][ny])
            {//不出界，上一个点比现在的点高，没有别访问过。 
                vis[nx][ny] = 1;
                q.push((U){nx,ny});
            }
        }
    }
    tot ++;// 新增一个区间。 
    Seg[tot] = (U){0,0};//清零。 
    for(int i = 1; i <= m; i ++)
    {
        if(vis[n][i])// 遍历最低行 
        {
            ans[i] = 1;// 如果最低行被走到过， 转移到 ans 数组 
            if(!Seg[tot].x) // 如果第一次遇到 1 
                Seg[tot].x = i; // 新区间的左端等于第一个1 的位置 
            else Seg[tot].y = i; // 否则区间的右端等于最后一个 1 的位置 
        }
    }
    if(!Seg[tot].x && !Seg[tot].y) // 如果最后一行没有被遍历到， 那么删除这个空区间 
        tot--;
}

bool cmp(U a, U b)
{
    if(a.x != b.x) // 如果左端点不相等 
        return a.x < b.x; // 左端点升序. 
    return a.y > b.y; // 左端点相等， 右端点降序。  测试发现降序升序无所谓。 
}

int main()
{
    cin >> n >> m;
    memset(h,0x3f,sizeof(h)); //初始化所有的地方为无限高。 
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            scanf("%d", &h[i][j]);
    for(int i = 1; i <= m; i ++)
        if((h[1][i] < h[1][i-1] && (i != 1)) || (h[1][i] < h[1][i+1] && (i != m)))
            can[i] = 1;// 当 某个节点左边比它高，且这个点是第一个点， 
            //或者 某个节点右边比它高， 且这个点不是最后一个点时，不搜这个点； 
    for(int i = 1; i <= m; i ++)
    {
        if(!can[i])// 剪枝 
        {
            memset(vis,0,sizeof(vis));// 初始化从每个点开始搜时能到达的点。 
            bfs(1,i);
        }
    }
    int cnt = 0;
    for(int i = 1; i <= m; i ++)//ans[i] 为是否能到达这个点， 如果不能到达， 那么cnt ++； （这里我写成了 <= n ->WA） 
        if(!ans[i])
            cnt ++;
    if(cnt)
    {
        printf("0\n%d\n", cnt);
        return 0;
    }
    sort(Seg+1, Seg+tot+1, cmp); 
    int now = 0, to = 0, ans = 0;
    for(int i = 1; i <= tot; i ++)
    {
        if(Seg[i].x <= now+1)
            to = max(to, Seg[i].y);
        else {
            now = to;
            to=max(to,Seg[i].y);
            ans ++;
        }
    }
    if(now != m)
        ans ++;
    printf("1\n%d", ans);
    return 0;
}


/*
2 5
9 1 5 4 3
8 7 6 1 2

1
*/

/*
3 6 
8 4 5 6 4 4
7 3 4 3 3 3 
3 2 2 1 1 2 

1
3
*/

/*
8
2 6
3 6
3 7
1 4
2 4
3 5
6 8
*/