【算法学习笔记】45. 二分答案 BFS路径 SJTU OJ 1031 二哥在黄山

1031. 二哥在黄山

Description

二哥与女朋友到黄山旅行。他们在山上玩了一整天，发现天色已晚，该回家了。而突然又开始下起了雨，二哥的女朋友表示非常不爽：“都是你搞的，早知道就不和你来了。”

二哥当然不能抛下女朋友不管，并且二哥也不想露宿在山上。于是他摊开被雨淋湿的地图。

黄山地图是一个N*N的矩阵，矩阵中的每一项表示那个地方的高度。二哥与女朋友处在左上角，他们的住处在右下角。在矩阵中可以朝上下左右走，但不能沿着对角线行走。二哥的女朋友不喜欢颠簸，所以二哥需要找到一条回到住处的路径，使得路径上的最高点与最低点之差尽量小，而不需要管这条路径有多长。

Input Format

第一行：N 接下来N行 N*N的整数矩阵，(0≤每点的高度≤110 )。 (2≤N≤100)

Output Format

一个整数，表示颠簸最小的路径中最高点与最低点的高度差。

Sample Input

5
1 1 3 6 8
1 2 2 5 5
4 4 0 3 3
8 0 2 3 4
4 3 0 2 1

Sample Output

2

Source

USACO 2003 U S Open Mountain Walking

乍一看以为可以DP，设置DP[i][j]为从(1,1)到(i,j)的路径中高度差最小时的最低点和最高点，然后通过状态转移得到答案。但是发现状态转移的过程中由于可以绕弯，所以最后只得了10分。。。

仔细想想，这个题没法DP的原因是，无法找到一种顺序来完成每一次填充时，子问题都已经解决了。

DP错误代码在此：

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;
struct Interval
{
    int min;
    int max;
};

int M[105][105];      //原始地图
Interval D[105][105]; //DP地图
int N;//边长

int main(int argc, char const *argv[])
{
    
    cin>>N;//输入边长
    for (int i = 1; i <= N; ++i)    //输入原始数据
        for (int j = 1; j <= N; ++j)
            scanf("%d", &M[i][j]);


    //在D的外侧铺一层边界点 使程序更简单
    Interval boundary;
    boundary.min = 10000;
    boundary.max = -10000;
    //铺第0排 和 第0列
    for (int i = 0; i <= N; ++i)
        D[i][0]  = D[0][i] = boundary;

    //开始动态规划

    for (int i = 1; i <= N; ++i){ //从上到下 第i排
        for (int j=1; j <= N; ++j){ //从左到右 第j列

            Interval& up = D[i-1][j];
            Interval& left = D[i][j-1];

            Interval from_up , from_left;
            
            //如果从上边过来
            from_up.min = min( M[i][j], up.min );
            from_up.max = max( M[i][j], up.max );
            int len_up = from_up.max - from_up.min;
            
            //如果从左边过来
            from_left.min = min( M[i][j], left.min );
            from_left.max = max( M[i][j], left.max );
            int len_left = from_left.max - from_left.min;
            
            //决策
            D[i][j] = (len_up < len_left) ? from_up : from_left;
        }
    }

    cout<<D[N][N].max - D[N][N].min<<endl;
    return 0;
}

/*
0≤每点的高度≤110

想法如下:
构建一个和M等大地图 D
这个地图的每一个空格存储两个数 min,max 指的是 从左上角到此位置的路径中最低点和最高点 差值最小时 的 最低点和最高点
从左上角开始更新这个地图D

首先有一个假设 所有点 只能从左和上的状态过来
这样的话
我们只要从上到下,从左到右 更新即可
其中 D[i][j]是 来自left = D[i][j-1]和 up = D[i-1][j]的 
转移方程就是 如果M[i][j]的值 
//if from up then 算出一个区间和区间长度
//if from left then 算出一个区间和区间长度
选择长度较小的那个

from x 的计算过程就是
min = min(x.min,M[i][j])
max = max(x.max,M[i][j])

以上想法是错误的...= = 因为绕过来的情况没考虑


*/

正确的想法是这样的：

这个问题本质还是搜索问题，但是搜索的对象可以有两种选择。

一种是正向的思考，搜索每一条从起点到终点的路径，记录最小差值。暴力搜索的策略里可以选择回溯，贪心顺序等等方法来优化，但是总体还是很麻烦的，效率也一定很低。

另一种就是逆向思考，我们这个题最终的答案是有固定范围的，一定是[0,Max-Min]中的某一个数。Max和Min指的是整个地图里所有山的高度极值。

它的长度明显比路径数要小很多，所以我们考虑用第二种思想。

我们来遍历[0,Max-Min]时，也可以再一次思考，如何降低复杂度。如果我们从0到Max-Min遍历 复杂度是O(n)

但是我们用二分法的时候就降低为了O(lgn)。

这个问题能用二分来搜索时，是因为我们有一个方法来判断猜测值比真实值是大还是小。也就是有一个比较函数可以确定二分的下一步决策。

（类比二分法查名字那个经典的案例）。

在这个问题里，我们的比较函数就是要在给定的高度范围内（根据遍历的最低高度和二分出来的猜测高度差确定） 去寻找一条从起点到终点的路径。如果可以找到，则说明真实高度差<=猜测高度差。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;
const int MaxN = 101;

int MAP[MaxN][MaxN];//存储地图
int n;//地图的边长
int Max=-1,Min=120;//记录整个地图的最高点和最低点
bool vis[MaxN][MaxN];//bfs中用来标识是否走过
struct Point    //点结构 用来存储在队列中
{
    int x;
    int y;
    Point(int a,int b){//构造函数
        x = a;
        y = b;
    }
};
//用于转换方向
int to_x[4] = {-1,+1,0,0};
int to_y[4] = {0,0,-1,+1};

queue<Point> q;//队列 BFS的数据结构基础

bool bfs(int low_bd, int up_bd){
    if(MAP[1][1]>up_bd or MAP[1][1]<low_bd or MAP[n][n]>up_bd or MAP[n][n]<low_bd)
        return false;
    memset(vis,false,sizeof(vis));//重置所有的山都没有走过
    //初始化
    Point start(1,1);//起点是(1,1)
    while(!q.empty())
        q.pop();
    q.push(start);
    //BFS搜索路径
    while(!q.empty()){//队列中还有元素
        Point cur =  q.front();
        q.pop();//出队
        vis[cur.x][cur.y] = true; //访问过

        for (int i = 0; i < 4; ++i)//四个延伸方向 
        {
            int x = cur.x + to_x[i];
            int y = cur.y + to_y[i];
            if(x<1 or x>n or y<1 or y>n)
                continue;//出了边界
            if(vis[x][y])
                continue;//放问过
            if(MAP[x][y]<low_bd or MAP[x][y]>up_bd)//此点不在规定的区间范围内
                continue;//不符合既定范围
            Point nxt(x,y);
            q.push(nxt);
            vis[x][y] = true;
            if(vis[n][n])
                return true;//如果到达了终点 说明存在这种路径
        }
        
    }
    return false;
}


void init(){
    cin>>n;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j){
            cin>>MAP[i][j];
            //更新最高点和最低点记录
            Max = max(Max,MAP[i][j]);
            Min = min(Min,MAP[i][j]);
        }
}

int BinaryFind(){
    //整个答案所在的区间是 [0,Max-Min]
    int L = 0, R = Max - Min;
    int mid;    //mid有两个作用 第一是 二分法的中间变量 第二是 代表当前的猜测答案
    
    while(L<R){    //直到L==R时退出
        mid = (L + R) / 2;//猜测 mid就是最终的答案
        //但是mid只是差值 真正的区间需要枚举
        bool isOK = false;//没找到答案
        for (int i = Min; i <= Max-mid ; ++i) //枚举左端点为i
        {     //此时确定的区间是 [i,i+mid]
            
            if(bfs(i,i+mid)){//如果找到了一条路径符合答案
                isOK = true;
                break;
            }
        }

        if(isOK)    R = mid;
        else        L = mid + 1;
        //cout<<"L:"<<L<<" R:"<<R<<endl;
    }
    //此时L==R==Mid==delta 即最后的答案
    return L;
}

int main(int argc, char const *argv[])
{
    init();
    cout<<BinaryFind()<<endl;
    return 0;
}

/*
 首先 记录Min Max 
 所以 答案必定是 0 到 Max-Min 之间的某一个数
 逆向思维 直接搜索答案! 
 搜索的方法用二分法来搜索
 
 对于每一个猜测, 这个猜测确定了 整个路径的上界和下届的差值 delta
 但是没有确定这个区间.
 而这个区间需要枚举!
 这个区间的枚举方法即是 [i,i+delta] i : Min ~ (Max-delta) 因为delta最大是Max-Min
 
 然后通过BFS的方法 去找 在这个确定的区间里 可否找到一个路径从起点可以走到终点,
 如果找到了 说明真实的答案比猜测值小 二分向左
 如果没找到 说明真实的答案比猜测值大 二分向右搜索
 直到左右边界相同 说明 答案就是那时候的delta
 */