Company Queries II

import sys
sys.setrecursionlimit(300000)

def preprocess_lca(n, boss):
    LOG = 18  # log base 2 of 2 * 10^5
    up = [[-1] * LOG for _ in range(n + 1)]
    depth = [0] * (n + 1)
    adj = [[] for _ in range(n + 1)]

    # Build adjacency list for the tree
    for i in range(2, n + 1):
        adj[boss[i - 2]].append(i)

    # DFS to compute depth and 2^j ancestors
    def dfs(v, parent):
        up[v][0] = parent
        for j in range(1, LOG):
            if up[v][j - 1] != -1:
                up[v][j] = up[up[v][j - 1]][j - 1]
        for u in adj[v]:
            if u != parent:
                depth[u] = depth[v] + 1
                dfs(u, v)

    # Start DFS from node 1 (general director)
    dfs(1, -1)

    return up, depth

def lca(a, b, up, depth):
    # If b is deeper, swap a and b
    if depth[a] < depth[b]:
        a, b = b, a
    
    LOG = len(up[0])

    # Lift a to the same depth as b
    for j in range(LOG - 1, -1, -1):
        if depth[a] - (1 << j) >= depth[b]:
            a = up[a][j]

    if a == b:
        return a

    # Lift both a and b simultaneously
    for j in range(LOG - 1, -1, -1):
        if up[a][j] != up[b][j]:
            a = up[a][j]
            b = up[b][j]

    # Now a and b are children of LCA
    return up[a][0]

def main():
    # Input reading
    n, q = map(int, input().split())
    boss = list(map(int, input().split()))

    # Preprocess LCA
    up, depth = preprocess_lca(n, boss)

    # Process queries
    for _ in range(q):
        a, b = map(int, input().split())
        print(lca(a, b, up, depth))

if __name__ == "__main__":
    main()

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: TIME LIMIT EXCEEDED

Test 7

Verdict: TIME LIMIT EXCEEDED

Test 8

Verdict: TIME LIMIT EXCEEDED

Test 9

Verdict: TIME LIMIT EXCEEDED

Test 10

Verdict: TIME LIMIT EXCEEDED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: TIME LIMIT EXCEEDED