結果

問題 No.399 動的な領主
ユーザー roarisroaris
提出日時 2020-11-19 00:47:08
言語 PyPy3
(7.3.15)
結果
MLE  
実行時間 -
コード長 3,049 bytes
コンパイル時間 733 ms
コンパイル使用メモリ 87,048 KB
実行使用メモリ 499,252 KB
最終ジャッジ日時 2023-09-30 15:23:54
合計ジャッジ時間 16,097 ms
ジャッジサーバーID
（参考情報） 		judge14 / judge15
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 71 ms
71,292 KB
testcase_01 AC 74 ms
71,356 KB
testcase_02 AC 80 ms
75,696 KB
testcase_03 AC 81 ms
75,648 KB
testcase_04 AC 147 ms
79,644 KB
testcase_05 AC 263 ms
86,980 KB
testcase_06 AC 1,287 ms
122,320 KB
testcase_07 AC 1,218 ms
105,352 KB
testcase_08 AC 1,205 ms
103,184 KB
testcase_09 AC 1,177 ms
105,240 KB
testcase_10 AC 142 ms
79,648 KB
testcase_11 AC 189 ms
82,604 KB
testcase_12 AC 892 ms
99,648 KB
testcase_13 AC 850 ms
99,404 KB
testcase_14 AC 787 ms
267,000 KB
testcase_15 AC 927 ms
258,852 KB
testcase_16 MLE -
testcase_17 AC 1,404 ms
110,928 KB
testcase_18 AC 1,164 ms
102,896 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