結果
| 問題 |
No.235 めぐるはめぐる (5)
|
| コンテスト | |
| ユーザー |
 norioc
|
| 提出日時 | 2025-11-15 08:11:02 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 11,529 bytes |
| コンパイル時間 | 324 ms |
| コンパイル使用メモリ | 82,660 KB |
| 実行使用メモリ | 331,164 KB |
| 最終ジャッジ日時 | 2025-11-15 08:11:26 |
| 合計ジャッジ時間 | 24,023 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge4 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| other | TLE * 1 -- * 2 |
ソースコード
from collections.abc import Callable
from collections import defaultdict
import typing
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None) -> None:
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
self._d[k] = self._mapping(f, self._d[k])
if k < self._size:
self._lz[k] = self._composition(f, self._lz[k])
def _push(self, k: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
class HLD:
def __init__(self, n: int, adj: dict[int, list[int]], root=0):
"""
n: 頂点数
adj: {頂点: [隣接頂点, ...]}
root: 根
"""
self.n = n
self.vid = [-1] * n
self.inv = [0] * n
self.par = [-1] * n
self.depth = [0] * n
self.subsize = [1] * n
self.head = [0] * n
self.prev = [-1] * n
self.next = [-1] * n
self.types = [0] * n
self._build([root], adj)
def _build(self, roots, adj):
pos = 0
for i, root in enumerate(roots):
self._decide_heavy_edge(root, adj)
pos = self._reconstruct(root, i, pos, adj)
def _decide_heavy_edge(self, root: int, adj):
"""部分木サイズを計算し、heavy edge を決定"""
st = [(root, 0)]
self.par[root] = -1
self.depth[root] = 0
while st:
v, i = st[-1]
if i < len(adj[v]):
to = adj[v][i]
st[-1] = (v, i+1)
if to == self.par[v]: continue
self.par[to] = v
self.depth[to] = self.depth[v] + 1
st.append((to, 0))
else:
st.pop()
maxsize = 0
for to in adj[v]:
if to == self.par[v]: continue
self.subsize[v] += self.subsize[to]
if self.subsize[to] > maxsize:
maxsize = self.subsize[to]
self.prev[to] = v
self.next[v] = to
def _reconstruct(self, root: int, curtype: int, pos: int, adj):
"""heavy-pathごとに Euler順 vid を割り当てる"""
st = [root]
while st:
start = st.pop()
v = start
while v != -1:
self.types[v] = curtype
self.vid[v] = pos
self.inv[pos] = v
self.head[v] = start
pos += 1
# 軽辺の子はあとでstackに積む
for to in adj[v]:
if to != self.par[v] and to != self.next[v]:
st.append(to)
v = self.next[v]
return pos
def foreach_nodes(self, u: int, v: int, f: Callable[[int, int], None]):
"""頂点 u, v 間の頂点区間に対してコールバック [l, r] を呼ぶ"""
while True:
if self.vid[u] > self.vid[v]:
u, v = v, u
f(max(self.vid[self.head[v]], self.vid[u]), self.vid[v])
if self.head[u] != self.head[v]:
v = self.par[self.head[v]]
else:
break
# u-v間の辺区間に対してコールバックを呼ぶ
def foreach_edges(self, u: int, v: int, f: Callable[[int, int], None]):
"""頂点 u, v 間の辺区間に対してコールバック [l, r] を呼ぶ"""
while True:
if self.vid[u] > self.vid[v]:
u, v = v, u
if self.head[u] != self.head[v]:
f(self.vid[self.head[v]], self.vid[v])
v = self.par[self.head[v]]
else:
if u != v:
f(self.vid[u]+1, self.vid[v])
break
def lca(self, u: int, v: int) -> int:
while True:
if self.vid[u] > self.vid[v]:
u, v = v, u
if self.head[u] == self.head[v]:
return u
v = self.par[self.head[v]]
# 値データ
class Data:
def __init__(self, val: int, coef: int):
self.val = val # 区間全体の和
self.coef = coef # 係数
# 遅延データ
Lazy = int
# 値データを合成
def op(a: Data, b: Data) -> Data:
val = (a.val + b.val) % MOD
coef = (a.coef + b.coef) % MOD
return Data(val, coef)
# 遅延データを値データに反映 : f(x)
def mapping(f: Lazy, x: Data) -> Data:
val = (x.val + x.coef * f) % MOD
return Data(val, x.coef)
# 遅延データを伝搬
# 二つの遅延データを合成 : (f . g)
def composition(f: Lazy, g: Lazy) -> Lazy:
return (f + g) % MOD
MOD = 10**9 + 7
N = int(input())
S = list(map(int, input().split()))
C = list(map(int, input().split()))
adj = defaultdict(list)
for _ in range(N-1):
A, B = map(lambda x: int(x)-1, input().split())
adj[A].append(B)
adj[B].append(A)
hld = HLD(N, adj, root=0)
xs = [Data(s, c) for s, c in zip(S, C)]
d = {}
for i in range(N):
d[hld.vid[i]] = i
segt = LazySegTree(
op=op,
e=Data(0, 0),
mapping=mapping,
composition=composition,
id_=0,
v=[xs[v] for _, v in sorted(d.items())])
Q = int(input())
for _ in range(Q):
qs = list(map(int, input().split()))
match qs:
case (0, x, y, z):
x -= 1
y -= 1
def f(l, r):
segt.apply(l, r+1, z)
pass
hld.foreach_nodes(x, y, f)
case (1, x, y):
x -= 1
y -= 1
res = [0]
def f(l, r):
res[0] += segt.prod(l, r+1).val
pass
hld.foreach_nodes(x, y, f)
print(res[0])