結果

問題 No.399 動的な領主
ユーザー roarisroaris
提出日時 2020-11-19 01:06:37
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 1,563 ms / 2,000 ms
コード長 3,543 bytes
コンパイル時間 326 ms
コンパイル使用メモリ 86,860 KB
実行使用メモリ 106,660 KB
最終ジャッジ日時 2023-09-30 15:24:21
合計ジャッジ時間 10,054 ms
ジャッジサーバーID
（参考情報） 		judge14 / judge15
このコードへのチャレンジ（β）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 74 ms
71,152 KB
testcase_01 AC 74 ms
71,404 KB
testcase_02 AC 82 ms
75,680 KB
testcase_03 AC 83 ms
75,620 KB
testcase_04 AC 153 ms
78,700 KB
testcase_05 AC 256 ms
81,476 KB
testcase_06 AC 1,493 ms
100,372 KB
testcase_07 AC 1,480 ms
100,568 KB
testcase_08 AC 1,466 ms
100,704 KB
testcase_09 AC 1,462 ms
100,684 KB
testcase_10 AC 158 ms
78,552 KB
testcase_11 AC 214 ms
80,888 KB
testcase_12 AC 1,158 ms
101,916 KB
testcase_13 AC 1,144 ms
101,496 KB
testcase_14 AC 287 ms
106,660 KB
testcase_15 AC 327 ms
99,176 KB
testcase_16 AC 566 ms
101,116 KB
testcase_17 AC 1,563 ms
101,736 KB
testcase_18 AC 1,485 ms
100,880 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()
        self.in_order = [-1]*N #行きがけ順
        self.in_order_now = 0
        self.top = [-1]*N #分解後の連結成分の中で最も浅い頂点
        self.dfs2()
    
    def dfs1(self):
        stack = [(0, -1, 0)]
        
        while stack:
            v, pv, d = stack.pop()

            self.depth[v] = d
            
            for nv in self.G[v]:
                if nv==pv:
                    continue
                
                stack.append((nv, v, d+1))
                self.par[nv] = v
        
        vs = [(self.depth[i], i) for i in range(N)]
        vs.sort(reverse=True)   
        
        for _, v in vs:
            for nv in G[v]:
                if nv!=self.par[v]:
                    self.size[v] += self.size[nv]
    
    def dfs2(self):
        stack = [(0, -1, 0)]
        
        while stack:
            v, pv, top_node = stack.pop()
            self.in_order[v] = self.in_order_now
            self.in_order_now += 1
            self.top[v] = top_node
        
            if self.size[v]==1:
                continue
        
            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
            
            for nv in self.G[v]:
                if nv==pv:
                    continue
                
                if nv!=heavy_node:
                    stack.append((nv, v, nv))
                 
            stack.append((heavy_node, v, top_node))
    
    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