Cerința

Zoli și D’Umbră s-au pierdut într-un labirint cu n x n camere dispuse pe cate n linii și n coloane. D’umbră se află în camera (1, 1), iar Zoli se află în camera (n, n). Aceștia vor trebui să parcurgă labirintul pentru a se regăsi. Dacă unul dintre ei se aflâ în camera (i, j), acesta se poate deplasa spre una din camerele aflate la pozițiile (i + 1, j), (i, j + 1), (i - 1, j) sau (i, j - 1), fără a părăsi labirintul.

Camerele nu pot fi accesate ușor. La fiecare cameră se află câte o ușă având o rezistență R care poate fi spartă cu un baros cu o putere P ≥ R. Unul dintre cei doi (nu contează care) va avea acces la un arsenal de barosuri cu puteri între 0 și 100.000.

Determinați puterea minimă pe care o poate avea barosul ce trebuie folosit astfel încât Zoli și D’Umbră să se poată întâlni.

Date de intrare

Fișierul de intrare labirint.in conține pe prima linie numărul n, iar pe următoarele n linii n numere, al j -lea număr de pe linia i + 1 reprezintă rezistența ușii de la camera aflată în (i, j).

Date de ieșire

Fișierul de ieșire labirint.out va conține pe prima linie numărul Pmin, reprezentând puterea minimă pe care o poate avea un baros folosit pentru a sparge anumite uși și a conecta camerele (1, 1) și (n, n).

Restricții și precizări

• 1 ≤ n ≤ 1.000
• 0 ≤ rezistența unei uși ≤ 100.000
• pentru 50% din punctaj, Pmin ≤ 600 și n ≤ 500

Exemplu

labirint.in

4
1 2 3 4 
2 3 1 4 
2 1 2 3
3 3 1 1 

labirint.out

2

Explicație

(1, 1) -> (2, 1) -> (3, 1) -> (3, 2) -> (3, 3) -> (4, 3) -> (4, 4)
Se evită camerele cu rezistență mai mare decât 2.

#include <bits/stdc++.h>


using namespace std;
ifstream cin("labirint.in");
ofstream cout("labirint.out");

int a[1001][1001] , b[1001][1001] , n , g;

int di[] = {-1 ,  0 , 0 , 1};
int dj[] = { 0 , -1 , 1 , 0};

struct poz
{
    int i,j;
};

queue<poz> q;

bool inside(int i,int j)
{
    return i > 0 && j > 0 && i <= n && j <= n;
}

int lee(poz start, int v)
{
    if(a[1][1] > v) return 0;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            b[i][j] = 0;
    q.push(start);
    b[1][1] = 1;
    while(!q.empty())
    {
        poz x = q.front();
        for(int d = 0; d < 4; d++)
        {
            int inou = x.i + di[d];
            int jnou = x.j + dj[d];
            if(inside(inou,jnou) && b[inou][jnou] == 0 && a[inou][jnou] <= v)
            {
                    b[inou][jnou] = b[x.i][x.j]+1;
                    q.push({inou , jnou});
            }
        }
        q.pop();
    }
    return b[n][n];
}

void cautabin(int st , int dr)
{
    poz x;
    x.i = 1;
    x.j = 1;
    while(st <= dr)
        {
            int mij = (st + dr)/2;
            if(lee(x , mij)) dr = mij - 1;
            else st = mij + 1;
        }
    cout << st;
}
int main()
{
    cin >> n;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            cin >> a[i][j];
    cautabin(1 , 100000);
    return 0;
}