Submission #5897806

---

Source Code Expand

class Lca:
    def __init__(self, E, root):
        import sys
        sys.setrecursionlimit(500000)
        self.root = root
        self.E = E  # V<V>
        self.n = len(E)  # 頂点数
        self.logn = 1
        while self.n >= (1<<self.logn):
            self.logn += 1

        self.parent = [[-1]*self.n for _ in range(self.logn)]

        self.depth = [0] * self.n
        self.dfs(root, -1, 0)
        for k in range(self.logn-1):
            for v in range(self.n):
                p_ = self.parent[k][v]
                if p_ >= 0:
                    self.parent[k+1][v] = self.parent[k][p_]

    def dfs(self, v, p, dep):
        self.parent[0][v] = p
        self.depth[v] = dep
        for e in self.E[v]:
            if e != p:
                self.dfs(e, v, dep+1)

    def get(self, u, v):
        if self.depth[u] > self.depth[v]:
            u, v = v, u
        dep_diff = self.depth[v]-self.depth[u]
        for k in range(self.logn):
            if dep_diff >> k & 1:
                v = self.parent[k][v]
        if u==v:
            return u
        for k in range(self.logn-1, -1, -1):
            if self.parent[k][u] != self.parent[k][v]:
                u = self.parent[k][u]
                v = self.parent[k][v]
        return self.parent[0][u]

 N = int(input())
xy = {}
for i in range(N):
    xy[i] = []

for i in range(N-1):
    x,y = map(int,input().split())
    xy[x-1].append(y-1)
    xy[y-1].append(x-1)

lca = Lca(xy,0)

Q = int(input())
for i in range(Q):
    a,b = map(int,input().split())
    q = lca.get(a-1,b-1)
    print(lca.depth[a-1] + lca.depth[b-1] - 2*lca.depth[q] + 1)

Submission Info

Judge Result