LCA binary lifting

#include <bits/stdc++.h>

using namespace std;

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

const int lg = 20;
vector < vector < int > > G, ancestor;
vector < int > level;

void dfs(int node, int parent) {
    ancestor[node][0] = parent;
    for(int i = 1; i <= lg; ++i)
        ancestor[node][i] = ancestor[ancestor[node][i - 1]][i - 1];
    for(int next : G[node])
        if(next != parent) {
            level[next] = level[node] + 1;
            dfs(next, node);
        }
}

int lca(int u, int v) {
    if(level[u] < level[v])
        swap(u, v);
    for(int i = lg; i >= 0; --i)
        if(level[u] - (1 << i) >= level[v])
            u = ancestor[u][i];
    if(u == v)
        return u;
    for(int i = lg; i >= 0; --i)
        if(ancestor[u][i] != ancestor[v][i]) {
            u = ancestor[u][i];
            v = ancestor[v][i];
        }
    return ancestor[u][0];
}

int main() {
    int N, Q;
    fin >> N >> Q;
    G.resize(N + 1);
    for(int i = 2; i <= N; ++i) {
        int parent;
        fin >> parent;
        G[parent].emplace_back(i);
    }
    ancestor = vector < vector < int > >(N + 1, vector < int >(lg + 1));
    level.resize(N + 1);
    dfs(1, 0);
    while(Q--) {
        int u, v;
        fin >> u >> v;
        fout << lca(u, v) << '\n';
    }
}