洛谷 1514 [NOIP2010]引水入城 bfs+贪心

题目：
https://www.luogu.org/problem/show?pid=1514

这个题注重考验思维； 暴力出奇迹

思路：
对于一个蓄水站能到达的干旱城市是连续的，可以抽象为一个区间做区间覆盖问题；

为什么？

可以用反证法证明；

蓄水站 ：A B C

干旱区： 1 2 3 4

假设B无法扩展到2，只能扩展1,3，存在一个A可以扩展到2;
因为B可以扩展到1，则B到1的路径与A到2的路径必有一个交点；
则B也可以扩展到2；
与假设相悖；
所以一个蓄水站能到达的干旱城市必然是连续的

贪心区间覆盖；
注意：[1,3]+[4,5]=[1,5];
贪心策略：
每次只选一个区间
满足：
1.与上一段区间（或起点）相接；
2.在1的基础上尽量覆盖更多的区间；
这样一个区间一个区间地选，当所选的区间第一次到达终点时，就是此时的最优解；

贪心原因：
我们可以nlogn排序，满足，以起点下标为第一关键字从小到大；
以终点下标为第二关键字从大到到小；
实际复杂度远小于n^2，比DP更快；

总结：

注意题的某些性质，多写多画，大开脑洞；

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN=1001;
int n,m,tot,ans,cnt;
int ma[MAXN][MAXN];
bool vis[MAXN][MAXN],f[MAXN][MAXN];
struct hh
{
    int x,y;
};
struct ss
{
    int sx,sy;
}lin[MAXN];
queue<hh>q;
int X[]={0,1,0,-1,0};
int Y[]={0,0,-1,0,1};
void bfs(int s)
{
    memset(f,0,sizeof(f));//注意初始化；
    while(!q.empty()) q.pop();
    q.push((hh){1,s});
    vis[1][s]=1;
    f[1][s]=1;//当前蓄水站可以覆盖的城市
    while(!q.empty())
    {
        int fx,fy;
        hh u=q.front();
        q.pop();
        for(int i=1;i<=4;i++)
        {
            fx=X[i]+u.x;
            fy=Y[i]+u.y;
            if(fx<1 || fx>n || fy<1 || fy>m) continue;
            if(!f[fx][fy] && ma[fx][fy]<ma[u.x][u.y])
            {
                vis[fx][fy]=1;
                q.push((hh){fx,fy});
                f[fx][fy]=1;
            }
        }
    }
    tot++;
    for(int i=m;i>=1;i--)//将区间起点找出；
    {
        if(f[n][i])
        {
            lin[tot].sy=i;
            break;
        }
    }
    for(int i=1;i<=m;i++)//终点;
    {
        if(f[n][i])
        {
            lin[tot].sx=i;
            break;
        }
    }
    if(lin[tot].sx==0 && lin[tot].sy==0) tot--;//若无法构成区间就删去；
    return;
}
bool cmp(ss aa,ss bb)//排序;
{
    if(aa.sx>bb.sx) return false;//从小到大；
    if(aa.sy>bb.sy) return true;//从大到小;
    else return false;
}
void solve()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            scanf("%d",&ma[i][j]);
    for(int i=1;i<=m;i++)
        if(!vis[1][i] && ma[1][i]>=ma[1][i-1] && ma[1][i]>=ma[1][i+1]) bfs(i);// 优化
    for(int i=1;i<=m;i++)
        if(vis[n][i]) ans++; 
    if(ans==m)
    {
        int xx=1,yy=0,cnt=0;
        cout<<1<<endl;
        sort(lin+1,lin+tot+1,cmp);
        while(true)
        {
            int ss=0;
            for(int i=1;i<=tot;i++)
            {
                if(xx<=lin[i].sx && lin[i].sx<=yy+1 && lin[i].sy>ss)
                ss=lin[i].sy;
            }
            yy=ss;
            cnt++;
            if(yy==m) break;//提前跳出；
        }
        cout<<cnt;
    }
    else 
    {
        cout<<0<<endl<<m-ans<<endl;
        return;
    }
    return;
}
int main()
{
    solve();
    return 0;
}