UCF Local Programming Contest 2016 J题（二分+bfs）

题目链接如下：

https://nanti.jisuanke.com/t/43321

思路：

显然我们要采用二分的方法来寻找答案，给定一个高度如果能确定在这个高度时是否可以安全到达终点，那我们就可以很快二分出最大可行的高度。在判断一个高度是否可行时，搜索从起点开始，在限制的高度下所有可以到达的坐标位置，检验是否经过终点即可。

/************************************************
┆  ┏┓　　　┏┓ ┆
┆┏┛┻━━━┛┻┓ ┆
┆┃　　　　　　　┃ ┆
┆┃　　　━　　　┃ ┆
┆┃　┳┛　┗┳　┃ ┆
┆┃　　　　　　　┃ ┆
┆┃　　　┻　　　┃ ┆
┆┗━┓　  　┏━┛ ┆
┆　　┃　  　┃　　┆　　　　　　
┆　　┃　  　┗━━━┓ ┆
┆　　┃　 AC代马 　　┣┓┆
┆　　┃　        　　┏┛┆
┆　　┗┓┓┏━┳┓┏┛ ┆
┆　　　┃┫┫　┃┫┫ ┆
┆　　　┗┻┛　┗┻┛ ┆
************************************************ */
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <queue>
#include <string>
#include <sstream>
#include <cstdio>
#include <cstring>
#include<cctype>
#include <math.h>
#include <cmath>
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define lb long double
#define LINF 0x3f3f3f3f3f3f3f3f
#define ull unsigned long long
#define random(x) (rand()%x)
#define sgn(x) (fabs(x) < eps ? 0 : ((x) < 0 ? -1 : 1))
#define rep(i, a, b) for(int i=a;i<b;i++)
#define req(j, a, b) for(int j=a;j<b;j++)
#define mem(a, b) memset(a, b, sizeof(a))
#define PI 3.141592653589793
#define K 20

using namespace std;
typedef long long ll;
const int maxn = 1e5 + ;
const double eps =1e-;
const double pi = acos(-);
const ll mod = 1e9 + ;
const int hash_mod = ;

inline int read()
{
    int X=,w=; char ch=;
    while(!isdigit(ch)) {w|=ch=='-';ch=getchar();}
    while(isdigit(ch)) X=(X<<)+(X<<)+(ch^),ch=getchar();
    return w?-X:X;
}

inline double dbread()
{
    double X=,Y=1.0; int w=; char ch=;
    while(!isdigit(ch)) {w|=ch=='-';ch=getchar();}
    while(isdigit(ch)) X=X*+(ch^),ch=getchar();
    ch=getchar();//读入小数点
    while(isdigit(ch)) X+=(Y/=)*(ch^),ch=getchar();
    return w?-X:X;
}

inline void write(int x)
{
    if(x<) putchar('-'),x=-x;
    if(x>) write(x/);
    putchar(x%+'');
}

ll gcd(ll a,ll b)//辗转相除法（欧几里德算法）求最大公约数
{
    return b ? gcd(b,a%b) : a;
}
ll lcm(ll a,ll b)
{
    return a*b/gcd(a,b);//最小公倍数
}
ll q_pow(ll base, ll p)
{
    ll result = ;
    while(p > )
    {
        if(p&)
        {//此处等价于if(power%2==1)
            result = result * base % ;
        }
        p >>= ;//此处等价于power=power/2
        base = (base * base) % ;
    }
    return result;
}

const int N = ;
int fri[N];

void  init()
{
    for(int i = ; i <= N; i++)
        fri[i] = i;
}
int find(int a)        //查找根节点
{
    int tem1 = a,tem2;
    while(a != fri[a])
        a = fri[a];
    while(tem1 != a)
    {
        tem2 = fri[tem1];
        fri[tem1] = a;
        tem1 = tem2;
    }
    return a;
}
void Union(int a,int b)
{
    int fri_a = find(a);
    int fri_b = find(b);
    if(fri_a != fri_b)
    {
        fri[fri_a] = fri_b;
    }
    return ;
}

int eval(char c)
{
    if(c==' ')
        return ;
    if(c=='\'')
        return ;
    return c - 'A' + ;
}

double pointSegDist(double cx, double cy, double px1, double py1, double px2, double py2)
{
    cx -= px1;
    px2 -= px1;
    cy -= py1;
    py2 -= py1;

    double len = sqrt(px2*px2 + py2*py2);
    double ux = px2 / (len * 1.0);
    double uy = py2/ (len * 1.0);
    uy = -uy;
    double nx = cx * ux - cy * uy;
    double ny = cx * uy + cy * ux;

    if(nx>= && nx <= len)
        return abs(ny);

    if(nx > len)
        nx -= len;
    return sqrt(nx*nx + ny*ny);
}

bool f(ll n)
{
    for(ll i=;i<=n;i++)
    {
        if(n % (i * i) == )
            return false;
    }
    return true;
}

bool judgeStr(string s)
{
    int len = s.size();
    int i,j;
    for(i=,j=len-;i<=len/;i++,j--)
    {
        if(s[i]!=s[j])
            return ;
    }
    return ;
}

ll f(ll n, ll d)
{
    ll ans = ;
    while(n >  && n % d == )
    {
        n /= d;
        ans++;
    }
    return ans;
}

ll power(ll a, ll b)
{
    long long ans = ;
    for (int i=;i<b;i++)
        ans *= a;
    return ans;
}

const int maxnn = 1e5+;

int dx[]={, , -, };

int dy[]={, , , -};

int vis[][];

int w[][];

int r, c;

int bfs(int h)
{
    mem(vis, );
    vis[][] = ;
    queue<int> q;
    //x,y,dis
    q.push();
    q.push();
    q.push();
    while(q.size() > )
    {
        int x = q.front();
        q.pop();
        int y = q.front();
        q.pop();
        int dis = q.front();
        q.pop();
        if(w[x][y] - dis >= h)
        {
            if(x == r- && y == c-)
            {
                return true;
            }
            for(int i=;i<;i++)
            {
                int a = x + dx[i];
                int b = y + dy[i];
                if(a >=  && a < r && b >=  && b < c && !vis[a][b])
                {
                    vis[a][b] = ;
                    q.push(a);
                    q.push(b);
                    q.push(dis+);
                }
            }
        }
    }
    return false;
}

int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        cin >> r >> c;
        for(int i=;i<r;i++)
        {
            for(int j=;j<c;j++)
            {
                cin >> w[i][j];
            }
        }
        int left = ;
        int right = INF;
        while(left < right)
        {
            int mid = (left + right + ) / ;
            if(bfs(mid))
            {
                left = mid;
            } else
            {
                right = mid - ;
            }
        }
        if(left > )
            cout << left << endl;
        else
            cout << "impossible" << endl;
    }
    return ;
}