AI

#include <iostream>
#include <fstream>
#include <queue>
#include <stack>
#include <bitset>
#include <cstring>

using namespace std;

ifstream fin("ai.in");
ofstream fout("ai.out");

int n, ti, tj, s1i, s1j, r1i, r1j, s2i, s2j, r2i, r2j, k;
int mat[1001][1001];

int r1Time[1001][1001];
int r2Time[1001][1001];

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

queue < pair < int, int > > q;


/**
-de cine protejeaza
-in ce timp ajunge acolo
*/

struct R{
    int timp;
    bool cine[2];

    /// 1 -> poate proteja
    /// 2 -> nu poate
};

R roboti[2];

void LeeR1(int i, int j)
{
    r1Time[i][j] = 1;
    r2Time[i][j] = 1;

    q.push({i, j});

    bool p1 = false, p2 = false;
    int t1, t2;

    while(!q.empty())
    {
        i = q.front().first;
        j = q.front().second;

        q.pop();

        for(int k = 0; k < 4; k++)
        {
            int nexti = i + di[k];
            int nextj = j + dj[k];

            if(r1Time[nexti][nextj] == -10 && !p1)
            {
                p1 = true;
                t1 = r1Time[i][j] + 1;
            }
            else if(r2Time[nexti][nextj] == -10 && !p2)
            {
                p2 = true;
                t2 = r1Time[i][j] + 1;
            }

            if(p1 && p2)
            {
                if(t1 == t2)
                {
                    roboti[0].timp = t1;
                    roboti[0].cine[0] = roboti[0].cine[1] = 1;
                }
                else if(t1 > t2)
                {
                    roboti[0].timp = t1;
                    roboti[0].cine[0] = 1;
                }
                else
                {
                    roboti[0].timp = t2;
                    roboti[0].cine[1] = 1;
                }

                return;
            }


            if(r1Time[nexti][nextj] == 0 && mat[nexti][nextj] != -1 && r2Time[nexti][nextj] == 0)
            {
                r1Time[nexti][nextj] = r1Time[i][j] + 1;
                r2Time[nexti][nextj] = r2Time[i][j] + 1;
                q.push({nexti, nextj});
            }

        }
    }
}

int LeeR2(int i, int j)
{
    memset(r1Time, 0, sizeof(r1Time));
    memset(r2Time, 0, sizeof(r2Time));

    r2Time[i][j] = 1;
    r2Time[i][j] = 1;

    q = queue < pair < int, int > >();


    bool p1 = false, p2 = false;
    int t1, t2;


    q.push({i, j});

    while(!q.empty())
    {
        i = q.front().first;
        j = q.front().second;

        q.pop();

        for(int k = 0; k < 4; k++)
        {
            int nexti = i + di[k];
            int nextj = j + dj[k];

            if(r1Time[nexti][nextj] == -10)
            {
                p1 = true;
                t1 = r1Time[i][j] + 1;
            }
            else if(r2Time[nexti][nextj] == -10)
            {
                p2 = true;
                t2 = r1Time[i][j] + 1;
            }

            if(p1 && p2)
            {
                if(t1 == t2)
                {
                    roboti[0].timp = t1;
                    roboti[0].cine[0] = roboti[0].cine[1] = 1;
                }
                else if(t1 > t2)
                {
                    roboti[0].timp = t1;
                    roboti[0].cine[0] = 1;
                }
                else
                {
                    roboti[0].timp = t2;
                    roboti[0].cine[1] = 1;
                }
            }


            if(r1Time[nexti][nextj] == 0 && mat[nexti][nextj] != -1 && r2Time[nexti][nextj] == 0)
            {
                r1Time[nexti][nextj] = r1Time[i][j] + 1;
                r2Time[nexti][nextj] = r2Time[i][j] + 1;
                q.push({nexti, nextj});
            }
        }
    }

    return 0;
}

void Gard()
{
    for(int i = 0; i <= n + 1; i++)
        mat[i][0] = mat[i][n + 1] = mat[0][i] = mat[n + 1][i] = -1;
}

int main()
{
    fin >> n >> ti >> tj >> s1i >> s1j >> s2i >> s2j >> r1i >> r1j >> r2i >> r2j >> k;


    int a, b;

    for(int i = 0; i < k; i++)
    {
        fin >> a >> b;
        mat[a][b] = -1;
    }

    /// CERINTA 1

    int maxP = 0;

    for(int i = 1; i <= n; i++)
    {
        int c = 0;

        for(int j = 1; j <= n; j++)
        {
            if(mat[i][j] == -1)
                c++;
            else
            {
                maxP = max(maxP, c);
                c = 0;
            }
        }

        maxP = max(maxP, c);
    }

    for(int i = 1; i <= n; i++)
    {
        int c = 0;

        for(int j = 1; j <= n; j++)
        {
            if(mat[j][i] == -1)
                c++;
            else
            {
                maxP = max(maxP, c);
                c = 0;
            }
        }

        maxP = max(maxP, c);
    }

    fout << maxP << '\n';

    /// CERINTA 2

    Gard();

    int starti = min(r1i, ti);
    int stopi = max(r1i, ti);

    int startj = min(r1j, tj);
    int stopj = max(r1j, tj);

    for(int i = starti; i <= stopi; i++)
        for(int j = startj; j <= stopj; j++)
            if((i - starti) * (startj - stopj) == (starti - stopi) * (j - starti))
            {
                cout << "SAlut";
                r1Time[i][j] = -10;
            }

    LeeR1(r1i, r1j);

    starti = min(r2i, ti);
    startj = max(r2i, ti);

    startj = min(r2j, tj);
    stopj = max(r2j, tj);

     for(int i = starti; i <= stopi; i++)
        for(int j = startj; j <= stopj; j++)
            if((i - starti) * (startj - stopj) == (starti - stopi) * (j - starti))
                r2Time[i][j] = -10;

    LeeR2(r2i, r2j);




    fin.close();
    fout.close();
    return 0;
}