結果

問題 No.399 動的な領主
コンテスト
ユーザー roaris
提出日時 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
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 19
権限があれば一括ダウンロードができます

ソースコード

diff #
raw source code 

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