Şoricelul Jerry este (pentru a câta oară ?) în labirint. Labirintul poate fi codificat ca o matrice cu n linii şi m coloane formată din n*m celule pătratice identice. Liniile se numerotează de la 1 la n, iar coloanele de la 1 la m. Labirintul este format din celule libere şi din celule ocupate de pereţii labirintului.

La momentul iniţial, Jerry se găseşte într-o anumită celulă liberă şi misiunea lui este să ajungă la destinaţie într-o altă celulă liberă precizată. Șoricelul se poate deplasa din celula curentă în oricare dintre cele patru celule cu care aceasta are în comun o latură şi nu poate ieşi în afara labirintului. Este posibil ca el să nu poată să ajungă de la poziţia iniţială la cea finală trecând doar prin celule libere. În această situație el este nevoit să sfărâme peretele în anumite celule. Jerry şi-a pregătit dinamită în acest scop, pentru că nu i se pare optim să roadă peretele cu dinţii.

Cerința

Cunoscând dimensiunile n şi m ale labirintului, coordonatele celulei de plecare şi ale celulei destinaţie, precum şi coordonatele celulelor ocupate de pereţi, să se determine numărul minim de celule ocupate, pe care Jerry trebuie să le dinamiteze pentru a putea să ajungă la destinaţie.

Date de intrare

Fişierul de intrare labir.in conţine pe prima linie două numere naturale n şi m separate printr-un spaţiu, reprezentând numărul de linii, respectiv numărul de coloane ale matricei care codifică labirintul.

Pe linia a doua se găsesc patru numere naturale xi yi xf yf separate prin câte un spaţiu, reprezentând poziţia de plecare, respectiv poziţia destinaţie.

Pe linia a treia se găseşte un număr natural k, reprezentând numărul de celule ocupate.

Pe fiecare dintre următoarele k linii se vor găsi câte două numere x şi y separate printr-un spaţiu, reprezentând linia şi coloana unei celule ocupate.

Date de ieșire

Pe prima linie a fişierului labir.out se va scrie un singur număr natural D, reprezentând numărul minim de celule pe care Jerry trebuie să le dinamiteze pentru a ajunge la destinaţie.

Restricții și precizări

• 2 ≤ n, m ≤ 5000
• 1 ≤ k ≤ 50 000
• Se garantează că pentru toate testele există cel puţin n/2 linii şi/sau m/2 coloane formate numai din celule neocupate.
• Pentru 30% dintre teste n,m ≤ 1000.

Exemplu

labir.in

7 8
1 1 7 8
6
2 1
1 2
3 1
6 7
6 8
6 2

labir.out

1

Explicație

Celulele ocupate au fost colorate în gri. Șoricelul pleacă din celula notată cu P și sosește în celula S. Pentru aceasta el dinamitează celula (1, 2) și ajunge în S dinamitând un număr minim D = 1, de celule ocupate.

#include <bits/stdc++.h>


using namespace std;
ifstream cin("labir.in");
ofstream cout("labir.out");
const int di[] = {0 , 0 , -1 , 1};
const int dj[] = {-1 , 1 , 0 , 0};
int n , m , k , ip , jp , is , js , x , y;
int X[5002] , Y[5002] , C1[5002] , C2[5002];
unsigned short b[5001][5001];
bitset <5002>a[5002];
struct poz
{
    int i , j;
};
poz v[50002];
bool inside(int i ,  int j)
{
    return i >= 1 && i <= n && j >= 1 && j <= m;
}
int comprimare(int i , int j)
{

}
deque <poz> D;
int lee(poz str)
{
    poz p;
    p.i = str.i , p.j = str.j;
    D.push_back(p);
    b[ip][jp] = 1;
    while(! D.empty())
    {
        p = D.front();
        D.pop_front();
        for(int i = 0 ; i < 4 ; i ++)
        {
            int inou = p.i + di[i];
            int jnou = p.j + dj[i];
            if(inside(inou , jnou) && b[inou][jnou] == 0)
            {
                if(a[inou][jnou] == 1)
                {
                    b[inou][jnou] = b[p.i][p.j] + 1;
                    D.push_back({inou , jnou});
                }
                else
                {
                    b[inou][jnou] = b[p.i][p.j];
                    D.push_front({inou , jnou});
                }
            }
        }
    }
    return b[is][js] - 1;
}
int main()
{
    cin >> n >> m;
    cin >> ip >> jp >> is >> js;
    cin >> k;
    for(int i = 1 ; i <= k ; i++)
    {
        cin >> x >> y;
        X[x] = 1;
        Y[y] = 1;
        v[i] = {x , y};
    }

    for(int i = 1 ; i <= n ; i++)
    {
        if(X[i] == 0 && (X[i-1] == 0 || X[i-1] == -1) && i != ip && i != is)
        {
            X[i] = -1;
            C1[i] = 1;
        }
    }
    for(int i = 1 ; i <= m ; i++)
    {
        if(Y[i] == 0 && (Y[i-1] == 0 || Y[i-1] == -1) && i != jp && i != js)
        {
            Y[i] = -1;
            C2[i] = 1;
        }
    }

    for(int i = 1 ; i <= n ; i++)
        C1[i] = C1[i] + C1[i-1];
    for(int i = 1 ; i <= m ; i++)
        C2[i] = C2[i] + C2[i-1];
    n -= C1[n];
    m -= C2[m];
    ip -= C1[ip];
    is -= C1[is];
    jp -= C2[jp];
    js -= C2[js];

    for(int i = 1 ; i <= k ; i++)
    {
        a[v[i].i - C1[v[i].i]][v[i].j - C2[v[i].j]] = 1;
    }
    poz str;
    str.i = ip , str.j = jp;
    cout << lee(str);

}