結果

問題 No.2337 Equidistant
ユーザー gew1fw
提出日時 2025-06-12 12:53:50
言語 PyPy3
(7.3.15)
結果
WA  
実行時間 -
コード長 2,959 bytes
コンパイル時間 273 ms
コンパイル使用メモリ 82,292 KB
実行使用メモリ 372,576 KB
最終ジャッジ日時 2025-06-12 12:57:33
合計ジャッジ時間 34,268 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 1
other AC * 3 WA * 18 TLE * 1 -- * 6
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
from sys import stdin
sys.setrecursionlimit(1 << 25)

def main():
    input = sys.stdin.read
    data = input().split()
    idx = 0
    N, Q = int(data[idx]), int(data[idx+1])
    idx +=2
    
    edges = [[] for _ in range(N+1)]
    for _ in range(N-1):
        a = int(data[idx])
        b = int(data[idx+1])
        edges[a].append(b)
        edges[b].append(a)
        idx +=2
    
    LOG = 20
    parent = [[-1]*(N+1) for _ in range(LOG)]
    depth = [0]*(N+1)
    size = [1]*(N+1)
    
    from collections import deque
    q = deque()
    q.append(1)
    parent[0][1] = -1
    visited = [False]*(N+1)
    visited[1] = True
    while q:
        u = q.popleft()
        for v in edges[u]:
            if not visited[v] and v != parent[0][u]:
                parent[0][v] = u
                depth[v] = depth[u] +1
                visited[v] = True
                q.append(v)
    
    for k in range(1, LOG):
        for v in range(1, N+1):
            if parent[k-1][v] != -1:
                parent[k][v] = parent[k-1][parent[k-1][v]]
    
    def dfs(u, p):
        for v in edges[u]:
            if v != p:
                dfs(v, u)
                size[u] += size[v]
    dfs(1, -1)
    
    def lca(u, v):
        if depth[u] < depth[v]:
            u, v = v, u
        for k in range(LOG-1, -1, -1):
            if depth[u] - (1 <<k) >= depth[v]:
                u = parent[k][u]
        if u == v:
            return u
        for k in range(LOG-1, -1, -1):
            if parent[k][u] != -1 and parent[k][u] != parent[k][v]:
                u = parent[k][u]
                v = parent[k][v]
        return parent[0][u]
    
    def get_kth_ancestor(u, k):
        for i in range(LOG):
            if k & (1 <<i):
                u = parent[i][u]
                if u == -1:
                    break
        return u
    
    def find_ancestor_by_depth(u, target_d):
        if depth[u] < target_d:
            return -1
        for k in range(LOG-1, -1, -1):
            if depth[u] - (1 <<k) >= target_d:
                u = parent[k][u]
        return u
    
    children = [[] for _ in range(N+1)]
    for v in range(2, N+1):
        p = parent[0][v]
        children[p].append(v)
    
    for _ in range(Q):
        S = int(data[idx])
        T = int(data[idx+1])
        idx +=2
        
        l = lca(S, T)
        a = depth[S] - depth[l]
        b = depth[T] - depth[l]
        D = a + b
        if D %2 !=0:
            print(0)
            continue
        k = D //2
        if k <= a:
            M = get_kth_ancestor(S, k)
        else:
            target_d = depth[l] + (k -a)
            M = find_ancestor_by_depth(T, target_d)
        
        sum_size =0
        for c in children[M]:
            lca_cs = lca(c, S)
            lca_ct = lca(c, T)
            if lca_cs == c or lca_ct == c:
                sum_size += size[c]
        ans = size[M] - sum_size
        print(ans)

if __name__ == "__main__":
    main()
0