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
[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
*/