4
1 3
1 4
2 4
1
2 4

The correct answer is 1.

Use sparse tables

cin.sync_with_stdio(false);

Ignore the notes. G++ is faster than Clang++, while Visual C++ 2017 gives TL.

Insert this magic line before the code

#pragma comment(linker, "/STACK:36777216")

And it works!

main {

prepare_lca();
if (N!=-1) {
 build_segement_tree(1,0,N-2); //a[0..n-1]
}
int Q=read();
while(Q-->0) {
 int j=x;
 int x=read()-1;
 int y=read()-1;
 if (x!=y) {
   J= get(1, 0, N-2, x, y-1);
 }
 println(j);
}

}

in build_segement_tree
..
if (tl==tr) t[v]=lca(tl,tl+1);

n=1

#include<iostream>
using namespace std;
int main()
{
    int CityCount, RoutesCount;

    cin >> CityCount;
    int *Road = new int[(CityCount - 1)*2];
    //Roads
    for (int i = 0; i < (CityCount - 1)*2; i++)
    {
        cin >> Road[i];
    }

    cin >> RoutesCount;
    int *Route = new int[RoutesCount*2];
    //Routes
    for (int i = 0; i < RoutesCount*2; i++)
    {
        cin >> Route[i];
    }
    //Road Matrix
    int j = 0;
    int **RMatrix= new int*[CityCount];
    for (int i = 0; i < CityCount; i++)
    {
        int *LineofMatrix = new int[CityCount];
        for (int i = 0; i < (CityCount - 1) * 2; i += 2)
        {
            if (Road[i] == j + 1)
                LineofMatrix[Road[i + 1] - 1] = 1;
            if (Road[i + 1] == j + 1)
                LineofMatrix[Road[i] - 1] = 1;
        }
        j++;
        RMatrix[i] = LineofMatrix;
    }
    //Output Road Matrix
    /*
    cout << endl;
    for (int i = 0; i < CityCount; i++)
    {
        for (int j = 0; j < CityCount; j++)
            if (RMatrix[i][j]>0)
                cout << RMatrix[i][j] << ' ';
            else
            {
                RMatrix[i][j] = 0;
                cout << 0 << ' ';
            }

        cout << endl;
    }
    cout << endl;
    */
    // alghoritm
    int *Value = new int[CityCount];
    int Vl = 0;
    int *Locked = new int[CityCount];
    int Lock = 0;
    bool BLock = false;

    int Bu = 0;
    int Final;
    int Cur;
    int PreCur=-1;
    int Iter=0;
    int min = INT_MAX;
    for (int i = 0; i < RoutesCount * 2; i+=2)
    {
        int *Buff = new int[CityCount * 2];
        Cur = Route[i] - 1;
        Final = Route[i + 1] - 1;
        Buff[Bu++] = Cur;
        Buff[Bu++] = Final;
        if (RMatrix[Cur][Final] == 1)
        {
            goto fin;
        }
        else
        {
            for (int j = 0; j < CityCount; j++)
            {
                if ((RMatrix[Cur][j] == 1) && (j != PreCur))
                {
                    PreCur = Cur;
                    Buff[Bu++] = j;
                    Iter++;
                    Cur = j;
                    j = -1;
                }
                if (RMatrix[Cur][Final] == 1)
                {
                    goto fin;
                }
                if (j == CityCount - 1)
                {
                    j = Cur;
                    Cur = PreCur;
                    Bu -= Iter;
                    Iter = 0;
                }
            }
        }
        fin:
        for (int z = 0; z < Bu; z++)
        {
            if (min > Buff[z])
            {
                min = Buff[z];
            }
        }
        Bu = 0;
        Iter = 0;
        cout << min+1 << endl;
        min = INT_MAX;
        delete[] Buff;
    }




    //system("pause");
    return 0;
}

I think many people can not solve this problem because they do not have enough knowledge.
You should know "Problem LCA" and "Segment Tree" that to solve the problem.
My algo is O(n*sqrt(n)+m*log(n)), but i can solve for O(n+m*log(n)) (LCA can be solved for O(1) with preprocess or sqrt(n) without preprocess).

P.S. What is the optimal asymptotic behavior?

Edited by author 20.11.2016 23:27

Edited by author 20.11.2016 23:27

Edited by author 20.11.2016 23:28