結果

問題 No.1094 木登り / Climbing tree
ユーザー lloyzlloyz
提出日時 2022-10-14 00:27:56
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 1,488 ms / 2,000 ms
コード長 3,257 bytes
コンパイル時間 422 ms
コンパイル使用メモリ 86,920 KB
実行使用メモリ 136,332 KB
最終ジャッジ日時 2023-09-08 19:20:41
合計ジャッジ時間 36,122 ms
ジャッジサーバーID
（参考情報） 		judge12 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 92 ms
71,132 KB
testcase_01 AC 1,481 ms
125,884 KB
testcase_02 AC 441 ms
136,332 KB
testcase_03 AC 511 ms
83,176 KB
testcase_04 AC 583 ms
100,924 KB
testcase_05 AC 825 ms
119,788 KB
testcase_06 AC 835 ms
95,340 KB
testcase_07 AC 1,445 ms
126,496 KB
testcase_08 AC 1,389 ms
125,748 KB
testcase_09 AC 1,404 ms
126,144 KB
testcase_10 AC 1,372 ms
126,768 KB
testcase_11 AC 1,455 ms
126,328 KB
testcase_12 AC 1,488 ms
126,340 KB
testcase_13 AC 1,477 ms
126,808 KB
testcase_14 AC 1,378 ms
126,332 KB
testcase_15 AC 665 ms
92,056 KB
testcase_16 AC 851 ms
121,480 KB
testcase_17 AC 740 ms
103,540 KB
testcase_18 AC 719 ms
98,160 KB
testcase_19 AC 799 ms
114,088 KB
testcase_20 AC 1,392 ms
126,400 KB
testcase_21 AC 769 ms
105,980 KB
testcase_22 AC 1,394 ms
126,596 KB
testcase_23 AC 1,462 ms
126,208 KB
testcase_24 AC 1,439 ms
125,900 KB
testcase_25 AC 1,379 ms
126,748 KB
testcase_26 AC 1,414 ms
126,408 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

class HeavyLightDecomposition:
    # HL 分解 (HLD)
    def __init__(self, E, root=1):
        # E は双方向に辺を張った木で、破壊的に有向グラフに変更される
        # O(N)
        self.E = E
        self.root = root
        self.N = N = len(E)  # 頂点数
        self.Parent = [-1] * N  # 頂点番号 v -> 親ノード
        self.Size = [-1] * N  # 頂点番号 v -> 部分木のサイズ
        self.dfs1()

        self.Mapping = [-1] * N  # 頂点番号 v -> 内部インデックス
        self.Head = list(range(N))  # 頂点番号 v -> v を含む heavy path の左端の頂点番号
        self.Depth = [0] * N  # 頂点番号 v -> 深さ（root から v までの距離）
        self.dfs2()

    def dfs1(self):
        E = self.E
        Parent, Size = self.Parent, self.Size
        Path = [self.root]
        Idx_edge = [0]
        while Path:
            v = Path[-1]
            idx_edge = Idx_edge[-1]
            Ev = E[v]
            if idx_edge != len(Ev):
                # 行きがけ・通りがけ 辺の数だけ実行される
                u, c = Ev[idx_edge]
                Idx_edge[-1] += 1
                E[u].remove((v, c))  # 有向グラフならここをコメントアウトする
                Parent[u] = v
                Path.append(u)
                Idx_edge.append(0)
            else:
                # 帰りがけ 頂点の数だけ実行される
                if len(Ev) >= 2:
                    ma = -1
                    argmax = None
                    for i, (u, _) in enumerate(Ev):
                        if Size[u] > ma:
                            ma = Size[u]
                            argmax = i
                    Ev[0], Ev[argmax] = Ev[argmax], Ev[0]
                Size[v] = sum(Size[u] for u, _ in Ev) + 1
                Path.pop()
                Idx_edge.pop()
    
    def dfs2(self):
        E = self.E
        Mapping = self.Mapping
        Head = self.Head
        Depth = self.Depth
        k = 0
        St = [self.root]
        while St:
            v = St.pop()
            Mapping[v] = k
            k += 1
            Ev = E[v]
            if Ev:
                Head[Ev[0][0]] = Head[v]
                St += [u for u, _ in Ev[::-1]]
                for u, c in Ev:
                    Depth[u] = Depth[v] + c  # distance を使わないのならここをコメントアウトする
    
    def lca(self, v, u):
        # O(logN)
        Parent = self.Parent
        Mapping = self.Mapping
        Head = self.Head
        while True:
            if Mapping[v] > Mapping[u]:
                v, u = u, v  # v の方を根に近くする
            if Head[v] == Head[u]:
                return v
            u = Parent[Head[u]]
    
    def distance(self, v, u):
        # O(logN)
        Depth = self.Depth
        return Depth[v] + Depth[u] - 2 * Depth[self.lca(v, u)]

from collections import deque

n = int(input())
E = [[] for _ in range(n + 1)]
EC = [[] for _ in range(n + 1)]
for _ in range(n - 1):
    a, b, c = map(int, input().split())
    E[a].append((b, c))
    E[b].append((a, c))
HL = HeavyLightDecomposition(E)

q = int(input())
for _ in range(q):
    s, t = map(int, input().split())
    print(HL.distance(s, t))
0