結果

問題 No.399 動的な領主
ユーザー roarisroaris
提出日時 2020-11-19 00:47:08
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 1,433 ms / 2,000 ms
コード長 3,049 bytes
コンパイル時間 188 ms
コンパイル使用メモリ 82,304 KB
実行使用メモリ 259,932 KB
最終ジャッジ日時 2024-07-23 09:23:12
合計ジャッジ時間 15,899 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 39 ms
54,596 KB
testcase_01 AC 39 ms
53,156 KB
testcase_02 AC 47 ms
61,684 KB
testcase_03 AC 48 ms
62,272 KB
testcase_04 AC 121 ms
78,268 KB
testcase_05 AC 243 ms
80,988 KB
testcase_06 AC 1,425 ms
100,124 KB
testcase_07 AC 1,376 ms
98,280 KB
testcase_08 AC 1,325 ms
98,452 KB
testcase_09 AC 1,370 ms
98,292 KB
testcase_10 AC 117 ms
78,352 KB
testcase_11 AC 167 ms
78,940 KB
testcase_12 AC 1,018 ms
96,620 KB
testcase_13 AC 989 ms
97,308 KB
testcase_14 AC 750 ms
259,932 KB
testcase_15 AC 779 ms
250,236 KB
testcase_16 AC 805 ms
214,156 KB
testcase_17 AC 1,433 ms
98,648 KB
testcase_18 AC 1,353 ms
97,356 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5+10)

class HLD:
    def __init__(self, N, G):
        self.G = G
        self.par = [-1]*N #親ノード
        self.size = [1]*N #部分木のサイズ
        self.depth = [-1]*N #深さ
        self.dfs1(0, -1, 0)
        self.in_order = [-1]*N #行きがけ順
        self.in_order_now = 0
        self.top = [-1]*N #分解後の連結成分の中で最も浅い頂点
        self.dfs2(0, -1, 0)
    
    def dfs1(self, v, pv, d):
        self.depth[v] = d
        
        for nv in self.G[v]:
            if nv==pv:
                continue
            
            self.dfs1(nv, v, d+1)
            self.par[nv] = v
            self.size[v] += self.size[nv]
    
    def dfs2(self, v, pv, top_node):
        self.in_order[v] = self.in_order_now
        self.in_order_now += 1
        self.top[v] = top_node
        
        if self.size[v]==1:
            return
        
        M = 0
        heavy_node = -1
        
        for nv in self.G[v]:
            if nv==pv:
                continue
            
            if self.size[nv]>M:
                M = self.size[nv]
                heavy_node = nv
        
        self.dfs2(heavy_node, v, top_node)
        
        for nv in self.G[v]:
            if nv==pv:
                continue
            
            if nv!=heavy_node:
                self.dfs2(nv, v, nv)
    
    def query(self, u, v):
        res = []
        
        while self.top[u]!=self.top[v]:
            if self.depth[self.top[u]]<=self.depth[self.top[v]]:
                res.append((self.in_order[self.top[v]], self.in_order[v]))
                v = self.par[self.top[v]]
            else:
                res.append((self.in_order[self.top[u]], self.in_order[u]))
                u = self.par[self.top[u]]
        
        res.append((min(self.in_order[u], self.in_order[v]), max(self.in_order[u], self.in_order[v])))
        return res

class BIT:
    def __init__(self, n):
        self.n = n
        self.bit = [0]*(n+1)
    
    def add(self, i, x):
        i += 1
        
        while i<=self.n:
            self.bit[i] += x
            i += i&(-i)

    def acc(self, i):
        s = 0
        
        while i>0:
            s += self.bit[i]
            i -= i&(-i)
        
        return s

class RAQ_RSQ:
    def __init__(self, n):
        self.p = BIT(n)
        self.q = BIT(n)
    
    def add(self, s, t, x):
        self.p.add(s, -x*s)
        self.p.add(t, x*t)
        self.q.add(s, x)
        self.q.add(t, -x)
    
    def get_sum(self, s, t):
        return self.p.acc(t)+self.q.acc(t)*t-self.p.acc(s)-self.q.acc(s)*s

N = int(input())
G = [[] for _ in range(N)]

for _ in range(N-1):
    u, v = map(int, input().split())
    G[u-1].append(v-1)
    G[v-1].append(u-1)

hdl = HLD(N, G)
raq_rsq = RAQ_RSQ(N)
Q = int(input())
ans = 0

for _ in range(Q):
    A, B = map(int, input().split())
    
    for l, r in hdl.query(A-1, B-1):
        ans += raq_rsq.get_sum(l, r+1)+r-l+1
        raq_rsq.add(l, r+1, 1)

print(ans)
0