input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# dp[n][i][j]=(頂点iから頂点jへ行く長さnのパスの個数)
# dp[n][i][j]=sum(dp[n-1][i][k]*a[k][j])⇒DP[n]=DP[n-1]*A DP[0]=Eより DP[n]=A^n
n,k=list(map(int,input().split()))
a=[list(map(int,input().split())) for i in range(n)]
dp=[[0]*n for i in range(n)]
mod=10**9+7
for i in range(n):
for j in range(n):
dp[i][i]=1
def dot(A,B):
C=[[0]*n for i in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
C[i][j]+=A[i][k]*B[k][j]
C[i][j]%=mod
return C
while k:
if k&1:
dp=dot(dp,a)
a=dot(a,a)
k>>=1
ans=0
for i in dp:
ans+=sum(i)
print((ans%mod))
| # dp[n][i][j]=(頂点iから頂点jへ行く長さnのパスの個数)
# dp[n][i][j]=sum(dp[n-1][i][k]*a[k][j])⇒DP[n]=DP[n-1]*A DP[0]=Eより DP[n]=A^n
import sys
input = sys.stdin.readline
def dot(A,B,MOD=1000000007):
N,M,L = len(A),len(A[0]),len(B[0])
res = [[0]*L for i in range(N)]
for i in range(N):
for j in range(L):
s = 0
for k in range(M):
s = (s + A[i][k]*B[k][j]) % MOD
res[i][j] = s
return res
def matPow(A,x,MOD=1000000007):
N = len(A)
res = [[0]*N for i in range(N)]
for i in range(N):
res[i][i] = 1
for i in range(x.bit_length()):
if (x>>i) & 1:
res = dot(res,A)
A = dot(A,A)
return res
def main():
n,k = list(map(int,input().split()))
mod = 10**9+7
a = [list(map(int,input().split())) for i in range(n)]
dp = matPow(a,k)
ans = 0
for i in range(n):
for j in range(n):
ans += dp[i][j]
print((ans%mod))
main() | p03177 |
def matDot(A,B,MOD):
N,M,L = len(A),len(A[0]),len(B[0])
res = [[0]*L for i in range(N)]
for i in range(N):
for j in range(L):
s = 0
for k in range(M):
s = (s + A[i][k]*B[k][j]) % MOD
res[i][j] = s
return res
def matPow(A,x,MOD):
N = len(A)
res = [[0]*N for i in range(N)]
for i in range(N):
res[i][i] = 1
for i in range(x.bit_length()):
if (x>>i) & 1:
res = matDot(res,A,MOD)
A = matDot(A,A,MOD)
return res
n,k = list(map(int,input().split()))
mod = 10**9+7
a = [list(map(int,input().split())) for i in range(n)]
a = list(map(list, list(zip(*a))))
b = matPow(a,k,mod)
ans = 0
for i in range(n):
for j in range(n):
ans = (ans+b[i][j])%mod
print(ans) | def matDot(A,B,MOD):
N,M,L = len(A),len(A[0]),len(B[0])
res = [[0]*L for i in range(N)]
for i in range(N):
for j in range(L):
s = 0
for k in range(M):
s = (s + A[i][k]*B[k][j]) % MOD
res[i][j] = s
return res
def matPow(A,x,MOD):
N = len(A)
res = [[0]*N for i in range(N)]
for i in range(N):
res[i][i] = 1
for i in range(x.bit_length()):
if (2**i) & x:
res = matDot(res,A,MOD)
A = matDot(A,A,MOD)
return res
n,k = list(map(int,input().split()))
mod = 10**9+7
a = [list(map(int,input().split())) for i in range(n)]
b = matPow(a,k,mod)
ans = 0
for i in range(n):
for j in range(n):
ans = (ans+b[i][j])%mod
print(ans) | p03177 |
def solve():
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
Ass = [tuple(map(int, input().split())) for _ in range(N)]
maxD = K.bit_length() - 1
dp = [[[0]*(N) for j in range(N)] for i in range(maxD+1)]
for v, As in enumerate(Ass):
nums = [0] * N
for v2, A in enumerate(As):
if A == 1:
nums[v2] += 1
dp[0][v] = nums
for d in range(1, maxD+1):
for v in range(N):
nums = [0] * N
for v2, num2 in enumerate(dp[d-1][v]):
for v3, num3 in enumerate(dp[d-1][v2]):
nums[v3] += num2 * num3
nums[v3] %= MOD
dp[d][v] = nums
anss = [1] * N
for d in range(maxD+1):
if K & (1<<d):
ans2s = [0] * N
for v in range(N):
for v2, num in enumerate(dp[d][v]):
ans2s[v2] += anss[v] * num
ans2s[v2] %= MOD
anss = ans2s
print((sum(anss) % MOD))
solve()
| from operator import mul
def solve():
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
Ass = [tuple(map(int, input().split())) for _ in range(N)]
def getMatrixProduct(Ass, Bss, MOD):
BssTr = list(map(list, list(zip(*Bss))))
Ax = len(Ass)
By = len(Bss[0])
ansss = [[0]*(By) for _ in range(Ax)]
for y, Bs in enumerate(BssTr):
for x, As in enumerate(Ass):
ansss[x][y] = sum(map(mul, As, Bs)) % MOD
return ansss
def getMatrixPower(Ass, n, MOD):
sizeA = len(Ass)
ansss = [[0]*(sizeA) for _ in range(sizeA)]
for i in range(sizeA):
ansss[i][i] = 1
while n:
if n & 1:
ansss = getMatrixProduct(ansss, Ass, MOD)
Ass = getMatrixProduct(Ass, Ass, MOD)
n //= 2
return ansss
Pss = getMatrixPower(Ass, K, MOD)
ans = 0
for Ps in Pss:
for P in Ps:
ans += P
ans %= MOD
print(ans)
solve()
| p03177 |
N, K = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
MOD = 10**9+7
def dot(A, B):
N = len(A)
K = len(A[0])
assert len(B) == K
M = len(B[0])
C = [[0] * M for _ in range(N)]
for i in range(N):
for j in range(M):
for k in range(K):
C[i][j] += A[i][k] * B[k][j]
C[i][j] %= MOD
return C
def mp(A, n):
assert len(A) == len(A[0])
B = [[0] * len(A) for _ in range(len(A))]
for i in range(len(A)):
B[i][i] = 1
while n:
n, i = divmod(n, 2)
if i:
B = dot(A, B)
A = dot(A, A)
return B
ans = sum([sum(r) % MOD for r in mp(A, K)]) % MOD
print(ans)
| N, K = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
MOD = 10**9+7
def dot(A, B):
N = len(A)
K = len(A[0])
assert len(B) == K
M = len(B[0])
C = [[0] * M for _ in range(N)]
for i in range(N):
for j in range(M):
C[i][j] = sum(A[i][k] * B[k][j] for k in range(K)) % MOD
return C
def mp(A, n):
assert len(A) == len(A[0])
B = [[0] * len(A) for _ in range(len(A))]
for i in range(len(A)):
B[i][i] = 1
while n:
n, i = divmod(n, 2)
if i:
B = dot(A, B)
A = dot(A, A)
return B
ans = sum([sum(r) % MOD for r in mp(A, K)]) % MOD
print(ans)
| p03177 |
N, K = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
MOD = 10**9+7
def dot(A, B):
N = len(A)
K = len(A[0])
assert len(B) == K
M = len(B[0])
C = [[0] * M for _ in range(N)]
for i in range(N):
for j in range(M):
for k in range(K):
C[i][j] += (A[i][k] * B[k][j]) % MOD
C[i][j] % + MOD
return C
def mp(A, n):
assert len(A) == len(A[0])
B = [[0] * len(A) for _ in range(len(A))]
for i in range(len(A)):
B[i][i] = 1
while n:
n, i = divmod(n, 2)
if i:
B = dot(A, B)
A = dot(A, A)
return B
ans = sum([sum(r) % MOD for r in mp(A, K)]) % MOD
print(ans)
| N, K = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
MOD = 10**9+7
def dot(A, B):
N = len(A)
K = len(A[0])
assert len(B) == K
M = len(B[0])
C = [[0] * M for _ in range(N)]
for i in range(N):
for j in range(M):
for k in range(K):
C[i][j] += (A[i][k] * B[k][j]) % MOD
C[i][j] %= MOD
return C
def mp(A, n):
assert len(A) == len(A[0])
B = [[0] * len(A) for _ in range(len(A))]
for i in range(len(A)):
B[i][i] = 1
while n:
n, i = divmod(n, 2)
if i:
B = dot(A, B)
A = dot(A, A)
return B
ans = sum([sum(r) % MOD for r in mp(A, K)]) % MOD
print(ans)
| p03177 |
import sys
input = sys.stdin.readline
def dot(a, b):
c = [[0] * n for _ in range(n)]
for i, ai in enumerate(a):
for j, bj in enumerate(zip(*b)):
ck = 0
for ak, bk in zip(ai, bj):
ck += ak * bk
c[i][j] = ck % md
return c
def pwr(a, k):
c = None
while c == None:
if k & 1:
c = a
a = dot(a, a)
k >>= 1
while k > 0:
if k & 1:
c = dot(a, c)
a = dot(a, a)
k >>= 1
return c
md = 10 ** 9 + 7
n, k = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
print((sum([sum(pk) % md for pk in pwr(a, k)]) % md))
| import sys
input = sys.stdin.readline
def dot(a, b):
c = [[0] * n for _ in range(n)]
for i, ai in enumerate(a):
for j, bj in enumerate(zip(*b)):
c[i][j] = sum(ak * bk for ak, bk in zip(ai, bj)) % md
return c
def pwr(a, k):
c = None
while c == None:
if k & 1:
c = a
a = dot(a, a)
k >>= 1
while k > 0:
if k & 1:
c = dot(a, c)
a = dot(a, a)
k >>= 1
return c
md = 10 ** 9 + 7
n, k = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
print((sum([sum(pk) % md for pk in pwr(a, k)]) % md))
| p03177 |
import sys
sys.setrecursionlimit(10**9)
N,K=list(map(int,input().strip().split(' ')))
A=[]
for _ in range(N):
A+=[list(map(int,input().strip().split(' ')))]
dic={}
MOD=10**9+7
def findout(i,j,k):
if k==1:
if A[i][j]==1:
return 1
else:
return 0
if (i,j,k) in dic:
return dic[(i,j,k)]
N=len(A)
a1=k//2
a2=k-a1
ans=0
for node in range(N):
ans+=(findout(i,node,a1)*findout(node,j,a2))%MOD
dic[(i,j,k)]=ans
return ans
ans=0
for i in range(N):
for j in range(N):
ans+=findout(i,j,K)
ans%=MOD
print(ans) | N,K=list(map(int,input().strip().split(' ')))
A=[]
for _ in range(N):
A+=[list(map(int,input().strip().split(' ')))]
dic={}
MOD=10**9+7
power=1
while 2**power<=K:
power+=1
dp=[[[0 for j in range(N)] for i in range(N)] for p in range(power+1) ]
for p in range(0,power+1):
if p==0:
for i in range(N):
for j in range(N):
if A[i][j]==1:
dp[p][i][j]=1
else:
for i in range(N):
for j in range(N):
for k in range(N):
dp[p][i][j]+=(dp[p-1][i][k]*dp[p-1][k][j])%MOD
dp[p][i][j]%=MOD
rep=bin(K)[2:][::-1]
final_ans=[[0 for i in range(N)] for j in range(N)]
need=[]
for i in range(len(rep)):
if rep[i]=="1":
need+=[i]
final=[[dp[need[0]][i][j] for j in range(N)] for i in range(N)]
for i in range(1,len(need)):
##start*dp[need[i]]
temp_ans=[[0 for i in range(N)] for j in range(N)]
for x in range(N):
for y in range(N):
temp=0
for z in range(N):
temp+=final[x][z]*dp[need[i]][z][y]
temp%=MOD
temp_ans[x][y]=temp
final=[[temp_ans[i][j] for j in range(N)] for i in range(N)]
ans=0
for i in range(N):
for j in range(N):
ans+=final[i][j]
ans%=MOD
print(ans)
| p03177 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
sys.setrecursionlimit(10**7)
n,k = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(n)]
def calc(A,B):
res = [[0]*n for i in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
res[i][j] += A[i][k] * B[k][j]
res[i][j] %= mod
return res
def power(A,k):
if k == 1:
return A
elif k % 2 == 0:
tmp = power(A,k//2)
return calc(tmp,tmp)
elif k % 2 == 1:
return calc(A,power(A,k-1))
result = power(A,k)
print((sum(map(sum,result))%mod))
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,k = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(n)]
def calc(A,B):
res = [[0]*n for i in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
res[i][j] += A[i][k] * B[k][j]
res[i][j] %= mod
return res
def power(A,k):
if k == 1:
return A
elif k % 2 == 0:
tmp = power(A,k//2)
return calc(tmp,tmp)
elif k % 2 == 1:
return calc(A,power(A,k-1))
result = power(A,k)
print((sum(map(sum,result))%mod))
| p03177 |
MOD = 10**9 + 7
def mul(a, b):
return [
[sum(aij * bij for aij, bij in zip(ai, bi)) % MOD for bi in zip(*b)]
for ai in a]
def pow(b, k):
if k == 1:
return b
i = 0
while 2 ** (i + 1)<= k:
i += 1
k -= 2 ** i
if k > 0:
t = pow(b, k)
for j in range(i):
b = mul(b, b)
if k > 0:
b = mul(b, t)
return b
def main():
N, K = (int(i) for i in input().split())
A = []
for i in range(N):
A.append([int(j) for j in input().split()])
A = [i for i in zip(*A)]
v = [[1] * N]
return sum(mul(v, pow(A, K))[0]) % MOD
print((main()))
| MOD = 10**9 + 7
def mul(a, b):
return [
[sum(aij * bij for aij, bij in zip(ai, bi)) % MOD for bi in zip(*b)]
for ai in a]
def pow(b, k):
r = [[1 if i == j else 0 for i in range(len(b))] for j in range(len(b))]
while k:
if k & 1:
r = mul(r, b)
k >>= 1
b = mul(b, b)
return r
def main():
N, K = (int(i) for i in input().split())
A = []
for i in range(N):
A.append([int(j) for j in input().split()])
A = [i for i in zip(*A)]
v = [[1] * N]
return sum(mul(v, pow(A, K))[0]) % MOD
print((main()))
| p03177 |
# coding: utf-8
# Your code here!
MOD=10**9+7
def dot(a, b):
res = [[0] * n for _ in range(n)]
for i in range(n):
for k, aik in enumerate(a[i]):
for j,bkj in enumerate(b[k]):
res[i][j] += aik*bkj
res[i][j] %= MOD
return res
n,k = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(n)]
ans = [[0] * n for _ in range(n)]
for i in range(n):
ans[i][i] = 1
while k:
k, i = divmod(k, 2)
if i:
ans = dot(ans, A)
A = dot(A, A)
res = 0
for i in range(n):
for j in range(n):
res += ans[i][j]
res %= MOD
print(res) | # coding: utf-8
# Your code here!
MOD=10**9+7
def matmul(A, B, mod): # A,B: 行列
res = [[0] * len(B[0]) for _ in range(len(A))]
for i, resi in enumerate(res):
for k, aik in enumerate(A[i]):
for j,bkj in enumerate(B[k]):
resi[j] += aik*bkj
resi[j] %= mod
return res
def matpow(A, p, M): #A^p mod M
if p % 2 == 1:
return matmul(A, matpow(A, p - 1, M), M)
elif p > 0:
b = matpow(A, p // 2, M)
return matmul(b, b, M)
else:
return [[1 if i == j else 0 for j in range(len(A))] for i in range(len(A))]
n,k = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(n)]
ans = matpow(A,k,MOD)
print((sum(sum(r) % MOD for r in ans) % MOD)) | p03177 |
# @author
import sys
class RWalk:
def solve(self):
MOD = 10 ** 9 + 7
def mult(A, B):
n, m, p = len(A), len(A[0]), len(B[0])
assert(len(B) == m)
C = [[0] * p for _ in range(n)]
for i in range(n):
for j in range(p):
for k in range(m):
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD
return C
def pow(A, k):
n, m = len(A), len(A[0])
if k == 0:
return [[1 if i == j else 0 for j in range(m)] for i in range(n)]
if k % 2 == 0:
return pow(mult(A, A), k // 2)
return mult(A, pow(A, k - 1))
n, k = [int(_) for _ in input().split()]
a = []
for i in range(n):
a.append([int(_) for _ in input().split()])
print((sum([sum(line) for line in pow(a, k)]) % MOD))
solver = RWalk()
input = sys.stdin.readline
solver.solve()
| # @author
import sys
class RWalk:
def solve(self):
MOD = 10 ** 9 + 7
def mult(A, B):
n, m, p = len(A), len(A[0]), len(B[0])
assert(len(B) == m)
C = [[0] * p for _ in range(n)]
for i in range(n):
for k in range(m):
a = A[i][k]
row = B[k]
for j in range(p):
C[i][j] = (C[i][j] + a * row[j]) % MOD
return C
def pow(A, k):
n, m = len(A), len(A[0])
if k == 0:
return [[1 if i == j else 0 for j in range(m)] for i in range(n)]
if k % 2 == 0:
return pow(mult(A, A), k // 2)
return mult(A, pow(A, k - 1))
n, k = [int(_) for _ in input().split()]
a = []
for i in range(n):
a.append([int(_) for _ in input().split()])
print((sum([sum(line) for line in pow(a, k)]) % MOD))
solver = RWalk()
input = sys.stdin.readline
solver.solve()
| p03177 |
N, K = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
MOD = 10**9 + 7
def dot(M1, M2, mod=10**9+7):
n = len(M1)
res = [[0]*n for _ in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
res[i][j] += M1[i][k] * M2[k][j] % MOD
return res
def power(M, k, mod=10**9+7):
if k == 1:
return M
elif k%2 == 0:
return power(dot(M, M, mod), k//2)
else:
return dot(M, power(dot(M, M, mod), k//2), mod)
trans = power(A, K)
ans = 0
for t in trans:
ans += sum(t)%MOD
ans %= MOD
print(ans) | N, K = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
MOD = 10**9 + 7
def dot(M1, M2, mod=10**9+7):
n = len(M1)
res = [[0]*n for _ in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
res[i][j] = (res[i][j] + M1[i][k] * M2[k][j]) % MOD
return res
def power(M, k, mod=10**9+7):
if k == 1:
return M
elif k%2 == 0:
return power(dot(M, M, mod), k//2, mod)
else:
return dot(M, power(dot(M, M, mod), k//2), mod)
trans = power(A, K)
ans = 0
for t in trans:
ans += sum(t)%MOD
ans %= MOD
print(ans) | p03177 |
import sys
sys.setrecursionlimit(10 ** 6)
def main():
N, Q = list(map(int, input().split()))
G = []
for i in range(N):
G.append([False] * N)
for i in range(N-1):
a, b = list(map(int, input().split()))
G[a-1][b-1] = True
G[b-1][a-1] = True
c = [0] * N
for i in range(Q):
p, x = list(map(int, input().split()))
c[p-1] += x
visited = [False] * N
def dfs(v, d):
if visited[v]:
return
c[v] += d
visited[v] = True
val = c[v]
for i, n in enumerate(G[v]):
if n:
dfs(i, val)
dfs(0, 0)
print((" ".join([str(i) for i in c])))
if __name__ == "__main__":
main() | import sys
sys.setrecursionlimit(10 ** 6)
def main():
N, Q = list(map(int, input().split()))
G = []
for i in range(N):
G.append([])
for i in range(N-1):
a, b = list(map(int, input().split()))
# G[a-1][b-1] = True
# G[b-1][a-1] = True
G[a-1].append(b-1)
G[b-1].append(a-1)
c = [0] * N
for i in range(Q):
p, x = list(map(int, input().split()))
c[p-1] += x
visited = [False] * N
def dfs(v, d):
if visited[v]:
return
c[v] += d
visited[v] = True
val = c[v]
for child in G[v]:
dfs(child, val)
dfs(0, 0)
print((" ".join([str(i) for i in c])))
if __name__ == "__main__":
main() | p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5 * 2)
N, Q = list(map(int, input().split()))
V = {i: [] for i in range(1,N+1)}
for _ in range(N-1):
a, b = list(map(int, input().split()))
V[a].append(b)
V[b].append(a)
C = {i: 0 for i in range(1,N+1)}
for _ in range(Q):
p, x = list(map(int, input().split()))
C[p] += x
def propagate(u, p):
for v in V[u]:
if v == p:
continue
C[v] += C[u]
propagate(v, u)
propagate(1, 0)
print((' '.join(str(C[i]) for i in range(1,N+1))))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, Q = list(map(int, input().split()))
V = {i: [] for i in range(1,N+1)}
for _ in range(N-1):
a, b = list(map(int, input().split()))
V[a].append(b)
V[b].append(a)
C = {i: 0 for i in range(1,N+1)}
for _ in range(Q):
p, x = list(map(int, input().split()))
C[p] += x
def propagate(u, p):
for v in V[u]:
if v == p:
continue
C[v] += C[u]
propagate(v, u)
propagate(1, 0)
print((' '.join(str(C[i]) for i in range(1,N+1))))
| p02936 |
import copy
n,q=list(map(int,input().split()))
l=[]
for i in range(n-1):
l.append(list(map(int,input().split())))
l2=[]
for i in range(q):
l2.append(list(map(int,input().split())))
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
L4=[]
for i in range(n):
L4.append(0)
for i in range(q):
L4[l2[i][0]-1]+=l2[i][1]
distance=[0 for i in range(n)]
distance[0]=L4[0]
ans=[0 for i in range(n)]
ans[0]=L4[0]
L=[0]
L2=[]
L3=[]
while len(L2)!=n and len(L)!=0:
for j in range(len(L)):
for k in range(len(connection[L[j]])):
distance[connection[L[j]][k]]=distance[L[j]]+L4[connection[L[j]][k]]
L3.append(connection[L[j]][k])
L2.append(L[j])
L=copy.copy(L3)
L3=[]
for i in range(len(distance)):
distance[i]=str(distance[i])
print((' '.join(distance))) | n,q=list(map(int,input().split()))
l=[]
for i in range(n-1):
l.append(list(map(int,input().split())))
l2=[]
for i in range(q):
l2.append(list(map(int,input().split())))
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
L4=[]
for i in range(n):
L4.append(0)
for i in range(q):
L4[l2[i][0]-1]+=l2[i][1]
distance=[0 for i in range(n)]
distance[0]=L4[0]
ans=[0 for i in range(n)]
ans[0]=L4[0]
L=[0]
L2=[]
L3=[]
while len(L2)!=n and len(L)!=0:
for j in range(len(L)):
for k in range(len(connection[L[j]])):
distance[connection[L[j]][k]]=distance[L[j]]+L4[connection[L[j]][k]]
L3.append(connection[L[j]][k])
L2.append(L[j])
L=L3
L3=[]
for i in range(len(distance)):
distance[i]=str(distance[i])
print((' '.join(distance))) | p02936 |
n,q=list(map(int,input().split()))
l=[]
for i in range(n-1):
l.append(list(map(int,input().split())))
l2=[]
for i in range(q):
l2.append(list(map(int,input().split())))
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
L4=[]
for i in range(n):
L4.append(0)
for i in range(q):
L4[l2[i][0]-1]+=l2[i][1]
distance=[0 for i in range(n)]
distance[0]=L4[0]
ans=[0 for i in range(n)]
ans[0]=L4[0]
L=[0]
L2=[]
L3=[]
while len(L2)!=n and len(L)!=0:
for j in range(len(L)):
for k in range(len(connection[L[j]])):
distance[connection[L[j]][k]]=distance[L[j]]+L4[connection[L[j]][k]]
L3.append(connection[L[j]][k])
L2.append(L[j])
L=L3
L3=[]
for i in range(len(distance)):
distance[i]=str(distance[i])
print((' '.join(distance))) | import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
l=[]
for i in range(n-1):
l.append(list(map(int,input().split())))
l2=[]
for i in range(q):
l2.append(list(map(int,input().split())))
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
L4=[]
for i in range(n):
L4.append(0)
for i in range(q):
L4[l2[i][0]-1]+=l2[i][1]
distance=[0 for i in range(n)]
distance[0]=L4[0]
ans=[0 for i in range(n)]
ans[0]=L4[0]
L=[0]
L2=[]
L3=[]
while len(L2)!=n and len(L)!=0:
for j in range(len(L)):
for k in range(len(connection[L[j]])):
distance[connection[L[j]][k]]=distance[L[j]]+L4[connection[L[j]][k]]
L3.append(connection[L[j]][k])
L2.append(L[j])
L=L3
L3=[]
for i in range(len(distance)):
distance[i]=str(distance[i])
print((' '.join(distance))) | p02936 |
import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
l=[]
for i in range(n-1):
l.append(list(map(int,input().split())))
l2=[]
for i in range(q):
l2.append(list(map(int,input().split())))
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
L4=[]
for i in range(n):
L4.append(0)
for i in range(q):
L4[l2[i][0]-1]+=l2[i][1]
distance=[0 for i in range(n)]
distance[0]=L4[0]
ans=[0 for i in range(n)]
ans[0]=L4[0]
L=[0]
L2=[]
L3=[]
while len(L2)!=n and len(L)!=0:
for j in range(len(L)):
for k in range(len(connection[L[j]])):
distance[connection[L[j]][k]]=distance[L[j]]+L4[connection[L[j]][k]]
L3.append(connection[L[j]][k])
L2.append(L[j])
L=L3
L3=[]
for i in range(len(distance)):
distance[i]=str(distance[i])
print((' '.join(distance))) | import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
l=[]
for i in range(n-1):
l.append(list(map(int,input().split())))
l2=[]
for i in range(q):
l2.append(list(map(int,input().split())))
connection=[]
for i in range(n):
connection.append([])
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
L4=[]
for i in range(n):
L4.append(0)
for i in range(q):
L4[l2[i][0]-1]+=l2[i][1]
distance=[0 for i in range(n)]
distance[0]=L4[0]
ans=[0 for i in range(n)]
ans[0]=L4[0]
L=[0]
L2=[]
L3=[]
while len(L2)!=n and len(L)!=0:
for j in range(len(L)):
for k in range(len(connection[L[j]])):
distance[connection[L[j]][k]]=distance[L[j]]+L4[connection[L[j]][k]]
L3.append(connection[L[j]][k])
L2.append(L[j])
L=L3
L3=[]
for i in range(len(distance)):
distance[i]=str(distance[i])
print((' '.join(distance))) | p02936 |
n,q=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n-1)]
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
connection[l[i][1]-1].append(l[i][0]-1)
L=[list(map(int,input().split())) for i in range(q)]
ctL=[0]*n
for i in range(q):
ctL[L[i][0]-1]+=L[i][1]
def bfs(v):
distance=[-1]*n
distance[v]=ctL[v]
next=[v]
next2=set()
visited=[-1]*n
visitct=0
while len(next)!=0 and visitct!=n:
for i in range(len(next)):
if visited[next[i]]==-1:
visited[next[i]]=1
visitct+=1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]]==-1:
distance[connection[next[i]][j]]=distance[next[i]]+ctL[connection[next[i]][j]]
next2.add(connection[next[i]][j])
next=list(next2)
next2=set()
return distance
x=bfs(0)
for i in range(n):
x[i]=str(x[i])
print((' '.join(x))) | import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n-1)]
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
connection[l[i][1]-1].append(l[i][0]-1)
L=[list(map(int,input().split())) for i in range(q)]
ctL=[0]*n
for i in range(q):
ctL[L[i][0]-1]+=L[i][1]
def bfs(v):
distance=[-1]*n
distance[v]=ctL[v]
next=[v]
next2=set()
visited=[-1]*n
visitct=0
while len(next)!=0 and visitct!=n:
for i in range(len(next)):
if visited[next[i]]==-1:
visited[next[i]]=1
visitct+=1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]]==-1:
distance[connection[next[i]][j]]=distance[next[i]]+ctL[connection[next[i]][j]]
next2.add(connection[next[i]][j])
next=list(next2)
next2=set()
return distance
x=bfs(0)
for i in range(n):
x[i]=str(x[i])
print((' '.join(x))) | p02936 |
import sys
sys.setrecursionlimit(10 ** 7)
N,Q = list(map(int,input().split()))
AB = [[int(i) for i in input().split()] for _ in range(N-1)]
PX = [[int(j) for j in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
counters = [0] * (N+1)
for p,x in PX:
counters[p] += x
def dfs(v,parent,add):
counters[v] += add
for x in graph[v]:
if x == parent:
continue
dfs(x,v,counters[v])
dfs(1,0,0)
ans = ' '.join(map(str,counters[1:]))
print(ans) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,Q = list(map(int,input().split()))
AB = [[int(i) for i in input().split()] for _ in range(N-1)]
PX = [[int(j) for j in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
counters = [0] * (N+1)
for p,x in PX:
counters[p] += x
def dfs(v,parent,add):
counters[v] += add
for x in graph[v]:
if x == parent:
continue
dfs(x,v,counters[v])
dfs(1,0,0)
ans = ' '.join(map(str,counters[1:]))
print(ans) | p02936 |
n,q=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n-1)]
px=[list(map(int,input().split())) for i in range(q)]
temp=[[i+1] for i in range(n)]
for i in range(n-2,-1,-1):
if len(temp[ab[i][1]-1]) >= 2:
temp[ab[i][0]-1].extend(temp[ab[i][1]-1])
else:
temp[ab[i][0]-1].append(ab[i][1])
ans=[0 for i in range(n)]
for j in range(q):
for _ in temp[px[j][0]-1]:
ans[_-1]+=px[j][1]
print((" ".join(map(str,ans)))) | n,q=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n-1)]
px=[list(map(int,input().split())) for i in range(q)]
parent=[0 for i in range(n)]
for i in range(n-1):
parent[ab[i][1]-1]=ab[i][0]
ans=[0 for i in range(n)]
for i in range(q):
ans[px[i][0]-1]+=px[i][1]
for i in range(1,n):
if parent[i] != 0:
ans[i]+=ans[parent[i]-1]
print((" ".join(map(str,ans))))
| p02936 |
from pprint import pprint
import queue
def solve(n, q, a, b, p, x):
counter = [0] * n
q_sum = [0] * n
for i in range(q):
q_sum[p[i]] += x[i]
# pprint(q_sum)
edges = {}
for i in range(n-1):
if a[i] not in edges:
edges[a[i]] = []
edges[a[i]].append(b[i])
# pprint(edges)
counter[0] = q_sum[0]
children = queue.Queue()
for child in edges[0]:
counter[child] = q_sum[0]
children.put(child)
while not children.empty():
child = children.get()
counter[child] += q_sum[child]
# print("child")
# print(child, counter[child])
if child in edges:
for c in edges[child]:
counter[c] = counter[child]
# print("c")
# print(c, counter[c])
children.put(c)
print((" ".join(list(map(str, counter)))))
if __name__ == "__main__":
n, q = list(map(int, input().strip().split(" ")))
a = []
b = []
for _ in range(n-1):
a_i, b_i = list(map(int, input().strip().split(" ")))
a.append(a_i - 1)
b.append(b_i - 1)
p = []
x = []
for _ in range(q):
p_i, x_i = list(map(int, input().strip().split(" ")))
p.append(p_i-1)
x.append(x_i)
solve(n, q, a, b, p, x) | from collections import deque
def solve(n, q, a, b, p, x):
counter = [0] * n
q_sum = [0] * n
for i in range(q):
q_sum[p[i]] += x[i]
# pprint(q_sum)
edges = {}
for i in range(n-1):
if a[i] not in edges:
edges[a[i]] = []
edges[a[i]].append(b[i])
# pprint(edges)
counter[0] = q_sum[0]
children = deque()
for child in edges[0]:
counter[child] = q_sum[0]
children.append(child)
while children:
child = children.popleft()
counter[child] += q_sum[child]
# print("child")
# print(child, counter[child])
if child in edges:
for c in edges[child]:
counter[c] = counter[child]
# print("c")
# print(c, counter[c])
children.append(c)
print((" ".join(list(map(str, counter)))))
if __name__ == "__main__":
n, q = list(map(int, input().strip().split(" ")))
a = []
b = []
for _ in range(n-1):
a_i, b_i = list(map(int, input().strip().split(" ")))
a.append(a_i - 1)
b.append(b_i - 1)
p = []
x = []
for _ in range(q):
p_i, x_i = list(map(int, input().strip().split(" ")))
p.append(p_i-1)
x.append(x_i)
solve(n, q, a, b, p, x) | p02936 |
from pprint import pprint
from collections import deque, defaultdict
def solve(n, q, edges, p):
counter = defaultdict(int)
parents = deque()
parents.append(0)
while parents:
parent = parents.popleft()
counter[parent] += p[parent]
# print("parent")
# print(parent, counter[parent])
if parent in edges:
for child in edges[parent]:
counter[child] = counter[parent]
# print("child")
# print(child, counter[child])
parents.append(child)
print((" ".join(list(map(str, list(counter.values()))))))
if __name__ == "__main__":
n, q = list(map(int, input().strip().split(" ")))
edges = defaultdict(list)
for _ in range(n-1):
a_i, b_i = list(map(int, input().strip().split(" ")))
edges[a_i-1].append(b_i-1)
p = [0] * n
x = []
for _ in range(q):
p_i, x_i = list(map(int, input().strip().split(" ")))
p[p_i-1] += x_i
solve(n, q, edges, p) | from pprint import pprint
from collections import deque, defaultdict
def solve(n, q, edges, p):
counter = defaultdict(int)
parents = deque()
parents.append(0)
while parents:
parent = parents.popleft()
counter[parent] += p[parent]
# print("parent")
# print(parent, counter[parent])
if parent in edges:
for child in edges[parent]:
if counter[child] != 0:
continue
counter[child] = counter[parent]
# print("child")
# print(child, counter[child])
parents.append(child)
print((" ".join(list(map(str, list(counter.values()))))))
if __name__ == "__main__":
n, q = list(map(int, input().strip().split(" ")))
edges = defaultdict(list)
for _ in range(n-1):
a_i, b_i = list(map(int, input().strip().split(" ")))
edges[a_i-1].append(b_i-1)
p = [0] * n
x = []
for _ in range(q):
p_i, x_i = list(map(int, input().strip().split(" ")))
p[p_i-1] += x_i
solve(n, q, edges, p) | p02936 |
from pprint import pprint
from collections import deque, defaultdict
n, q = list(map(int, input().strip().split(" ")))
edges = defaultdict(set)
for _ in range(n-1):
a_i, b_i = list(map(int, input().strip().split(" ")))
# edges[a_i-1].append(b_i-1)
# edges[b_i-1].append(a_i-1)
edges[a_i-1].add(b_i-1)
edges[b_i-1].add(a_i-1)
# p = defaultdict(int)
# counter = defaultdict(int)
counter = [0] * n
p = [0] * n
x = []
for _ in range(q):
p_i, x_i = list(map(int, input().strip().split(" ")))
# p[p_i-1] += x_i
counter[p_i-1] += x_i
parents = deque()
# parents.append(0)
# parents = []
parents.append(0)
visited = set()
while parents:
parent = parents.popleft()
# parent = parents.pop()
if parent in visited:
continue
visited.add(parent)
# counter[parent] += p[parent]
# print("parent")
# print(parent, counter[parent])
for child in edges[parent]:
if child in visited:
continue
# if counter[child] != 0:
# continue
counter[child] += counter[parent]
# print("child")
# print(child, counter[child])
parents.append(child)
# parents.add(child)
#print(" ".join(list(map(str, counter.values()))))
print((" ".join(list(map(str, counter))))) | from pprint import pprint
from collections import deque, defaultdict
n, q = list(map(int, input().strip().split(" ")))
# edges = defaultdict(set)
edges = [[] for _ in range(n)]
for _ in range(n-1):
a_i, b_i = list(map(int, input().strip().split(" ")))
edges[a_i-1].append(b_i-1)
edges[b_i-1].append(a_i-1)
# edges[a_i-1].add(b_i-1)
# edges[b_i-1].add(a_i-1)
# p = defaultdict(int)
# counter = defaultdict(int)
counter = [0] * n
p = [0] * n
x = []
for _ in range(q):
p_i, x_i = list(map(int, input().strip().split(" ")))
# p[p_i-1] += x_i
counter[p_i-1] += x_i
parents = deque()
# parents.append(0)
# parents = []
parents.append(0)
visited = set()
while parents:
parent = parents.popleft()
# parent = parents.pop()
if parent in visited:
continue
visited.add(parent)
# counter[parent] += p[parent]
# print("parent")
# print(parent, counter[parent])
for child in edges[parent]:
if child in visited:
continue
# if counter[child] != 0:
# continue
counter[child] += counter[parent]
# print("child")
# print(child, counter[child])
parents.append(child)
# parents.add(child)
#print(" ".join(list(map(str, counter.values()))))
print((" ".join(list(map(str, counter))))) | p02936 |
from pprint import pprint
from collections import deque, defaultdict
n, q = list(map(int, input().strip().split(" ")))
edges = [[] for _ in range(n)]
for _ in range(n-1):
a_i, b_i = list(map(int, input().strip().split(" ")))
edges[a_i-1].append(b_i-1)
edges[b_i-1].append(a_i-1)
counter = [0] * n
p = [0] * n
for _ in range(q):
p_i, x_i = list(map(int, input().strip().split(" ")))
counter[p_i-1] += x_i
parents = deque()
parents.append(0)
visited = set()
while parents:
parent = parents.popleft()
if parent in visited:
continue
visited.add(parent)
for child in edges[parent]:
if child in visited:
continue
counter[child] += counter[parent]
# print("child")
# print(child, counter[child])
parents.append(child)
print((" ".join(list(map(str, counter))))) | from pprint import pprint
from collections import deque, defaultdict
import sys
# n, q = map(int, input().strip().split(" "))
n, q = list(map(int, sys.stdin.readline().strip().split(" ")))
edges = [[] for _ in range(n)]
for _ in range(n-1):
# a_i, b_i = map(int, input().strip().split(" "))
a_i, b_i = list(map(int, sys.stdin.readline().strip().split(" ")))
edges[a_i-1].append(b_i-1)
edges[b_i-1].append(a_i-1)
counter = [0] * n
p = [0] * n
for _ in range(q):
# p_i, x_i = map(int, input().strip().split(" "))
p_i, x_i = list(map(int, sys.stdin.readline().strip().split(" ")))
counter[p_i-1] += x_i
parents = deque()
parents.append(0)
visited = set()
while parents:
parent = parents.popleft()
if parent in visited:
continue
visited.add(parent)
for child in edges[parent]:
if child in visited:
continue
counter[child] += counter[parent]
# print("child")
# print(child, counter[child])
parents.append(child)
print((" ".join(list(map(str, counter))))) | p02936 |
from pprint import pprint
from collections import deque, defaultdict
import sys
# n, q = map(int, input().strip().split(" "))
n, q = list(map(int, sys.stdin.readline().strip().split(" ")))
edges = [[] for _ in range(n)]
for _ in range(n-1):
# a_i, b_i = map(int, input().strip().split(" "))
a_i, b_i = list(map(int, sys.stdin.readline().strip().split(" ")))
edges[a_i-1].append(b_i-1)
edges[b_i-1].append(a_i-1)
counter = [0] * n
p = [0] * n
for _ in range(q):
# p_i, x_i = map(int, input().strip().split(" "))
p_i, x_i = list(map(int, sys.stdin.readline().strip().split(" ")))
p[p_i-1] += x_i
# counter[p_i-1] += x_i
parents = deque()
parents.append(0)
visited = set()
while parents:
parent = parents.popleft()
if parent in visited:
continue
counter[parent] += p[parent]
visited.add(parent)
for child in edges[parent]:
if child in visited:
continue
counter[child] += counter[parent]
# print("child")
# print(child, counter[child])
parents.append(child)
print((" ".join(list(map(str, counter))))) | import sys
from collections import deque
N, Q = list(map(int, sys.stdin.readline().split(" ")))
edges = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, sys.stdin.readline().split(" ")))
# print(a, b)
edges[a-1].append(b-1)
edges[b-1].append(a-1)
# print(edges)
# sys.exit()
points = [0] * N
for _ in range(Q):
p, x = list(map(int, sys.stdin.readline().split(" ")))
points[p-1] += x
visited = set()
counted = [0] * N
q = deque([(0, points[0])])
while q:
node, point = q.popleft()
# print(node, point)
if node in visited:
continue
counted[node] = str(point)
visited.add(node)
for edge in edges[node]:
q.appendleft((edge, point + points[edge]))
print((" ".join(counted))) | p02936 |
import queue
N, Q = list(map(int, input().split()))
tree = [[] for _ in range(N+1)]
value = [0] * (N+1)
visit = [False] * (N+1)
# make_tree
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
# make_value
for _ in range(Q):
p, x = list(map(int, input().split()))
value[p] += x
# all_value_sum
q = queue.Queue()
q.put(1)
visit[1] = True
while not q.empty():
now = q.get()
for next in tree[now]:
if not visit[next]:
value[next] += value[now]
q.put(next)
visit[next] = True
# output_value
s = " ".join(map(str, value[1:]))
print(s) | import sys
import queue
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
tree = [[] for _ in range(N+1)]
value = [0] * (N+1)
visit = [False] * (N+1)
# make_tree
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
# make_value
for _ in range(Q):
p, x = list(map(int, input().split()))
value[p] += x
# all_value_sum
q = queue.Queue()
q.put(1)
visit[1] = True
while not q.empty():
now = q.get()
for next in tree[now]:
if not visit[next]:
value[next] += value[now]
q.put(next)
visit[next] = True
# output_value
s = " ".join(map(str, value[1:]))
print(s) | p02936 |
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
n, q = [int(item) for item in input().split()]
edge = [[] for _ in range(n)]
for i in range(n-1):
a, b = [int(item) for item in input().split()]
a -= 1; b -= 1
edge[a].append(b)
edge[b].append(a)
cost = [0] * n
for i in range(q):
p, x = [int(item) for item in input().split()]
p -= 1
cost[p] += x
ans = [-1] * n
ans.append(0)
def dfs(frm, n):
if ans[n] != -1:
return
ans[n] = ans[frm] + cost[n]
for to in edge[n]:
dfs(n, to)
dfs(-1, 0)
print((" ".join([str(item) for item in ans[:-1]]))) | import sys
sys.setrecursionlimit(10**6)
n, q = [int(item) for item in input().split()]
edge = [[] for _ in range(n)]
for i in range(n-1):
a, b = [int(item) for item in input().split()]
a -= 1; b -= 1
edge[a].append(b)
edge[b].append(a)
cost = [0] * n
for i in range(q):
p, x = [int(item) for item in input().split()]
p -= 1
cost[p] += x
ans = [-1] * n
ans.append(0)
def dfs(frm, n):
ans[n] = ans[frm] + cost[n]
for to in edge[n]:
if ans[to] != -1:
continue
dfs(n, to)
dfs(-1, 0)
print((" ".join([str(item) for item in ans[:-1]]))) | p02936 |
import sys
sys.setrecursionlimit(1000000)
n, q = list(map(int, input().split()))
adj = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
adj[a].append(b)
adj[b].append(a)
p = [0] * n
for _ in range(q):
i, x = list(map(int, input().split()))
p[i-1] += x
parent = [0] * n
res = [0] * n
visited = [False] * n
def dfs(x, n):
res[x] += n
visited[x] = True
for ne in adj[x]:
if not visited[ne]:
dfs(ne, n + p[ne])
dfs(0, p[0])
print((' '.join([str(x) for x in res])))
| import sys
n, q = list(map(int, input().split()))
adj = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
adj[a].append(b)
res = [0] * n
for _ in range(q):
i, x = list(map(int, input().split()))
res[i-1] += x
parent = [0] * n
stack = [0]
while len(stack) > 0:
i = stack.pop()
for j in adj[i]:
res[j] += res[i]
stack.append(j)
print((' '.join([str(x) for x in res])))
| p02936 |
import sys
import collections
sys.setrecursionlimit(1000000)
n, q = list(map(int, input().split()))
cost = collections.deque([])
tree = collections.deque([])
level = collections.deque([])
parent = collections.deque([])
for i in range(210000):
tree.append(collections.deque([]))
level = collections.deque([-1] * 200100)
parent = collections.deque([-1] * 200100)
cost = collections.deque([0] * 200100)
for loop in range(n - 1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
for loop in range(q):
p, x = list(map(int, input().split()))
cost[p] += x
def make_level(index, lev, pp):
level[index] = lev
parent[index] = pp
for next in tree[index]:
if level[next] != -1:
continue
cost[next] += cost[index]
make_level(next, lev + 1, index)
make_level(1, 0, -1)
print((" ".join(list(map(str, cost))[1:n+1]))) | edge = []
n, q = list(map(int, input().split()))
for _ in range(n+100):
edge.append([])
for _ in range(n-1):
a,b = list(map(int, input().split()))
edge[a].append(b)
edge[b].append(a)
res = [0] * (n+1)
cost = [0] * (n+1)
for _ in range(q):
a,b = list(map(int, input().split()))
res[a] += b
import collections
q = collections.deque([[1, 0]])
used = [False] * (n+1)
while len(q) > 0:
#print(q)
curnode, cost = q.popleft()
res[curnode] += cost
used[curnode] = True
for i in range(len(edge[curnode])):
nnext = edge[curnode][i]
if used[nnext] is True:
continue
else:
q.append([nnext, res[curnode]])
res=res[1:]
print((" ".join(list(map(str, res)))))
| p02936 |
N, Q = map(int, input().split())
T = [[] for i in range(N)]
for i in range(N - 1):
a, b = map(int, input().split())
a, b = a - 1, b - 1
T[a].append(b)
T[b].append(a)
Point = [0] * N
for q in range(Q):
p, x = map(int, input().split())
p -= 1
Point[p] += x
ans = [0] * N
stack = [[0, Point[0]]]
visited = [False] * N
while stack:
n, p = stack.pop()
visited[n] = True
ans[n] = p
for to in T[n]:
if visited[to]:
continue
stack.append([to, p + Point[to]])
print(*ans, sep=' ')
| N, Q = map(int, input().split())
T = [[] for i in range(N)]
for i in range(N - 1):
a, b = map(int, input().split())
a, b = a - 1, b - 1
T[a].append(b)
T[b].append(a)
ans = [None] * N
V = [0] * N
for q in range(Q):
p, x = map(int, input().split())
p -= 1
V[p] += x
stack = [[0, V[0]]]
while stack:
n, v = stack.pop()
ans[n] = v
for to in T[n]:
if ans[to] is not None:
continue
stack.append([to, v + V[to]])
print(*ans, sep=' ')
| p02936 |
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
root = {}
for i in range(n-1):
a, b = list(map(int, input().split()))
if a in root:
root[a] += [b]
else:
root.setdefault(a, [b])
if b in root:
root[b] += [a]
else:
root.setdefault(b, [a])
cnt = [0 for _ in range(n+1)]
for i in range(q):
p, x = list(map(int, input().split()))
cnt[p] += x
quu = [1]
visited = []
while len(quu) > 0:
now = quu.pop(0)
visited += [now]
child = root[now]
for i in range(len(child)):
if not child[i] in visited:
quu += [child[i]]
cnt[child[i]] += cnt[now]
print((" ".join(map(str, cnt[1:])))) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(300000)
n, q = list(map(int, input().split()))
root = [[] for _ in range(n+1)]
for i in range(n-1):
a, b = list(map(int, input().split()))
root[a].append(b)
root[b].append(a)
cnt = [0 for _ in range(n+1)]
for i in range(q):
p, x = list(map(int, input().split()))
cnt[p] += x
def rec(node, parent):
for i in root[node]:
if i == parent:
continue
cnt[i] += cnt[node]
rec(i, node)
rec(1, 1)
print((" ".join(map(str, cnt[1:])))) | p02936 |
import sys
from collections import deque
sys.setrecursionlimit(2 * 10**6)
def inpl():
return list(map(int, input().split()))
def bfs():
visited[0] = True
ans[0] = counter[0]
deq = deque()
deq.append(0)
while deq:
v = deq.popleft()
for nv in edge[v]:
if visited[nv] is True:
continue
visited[nv] = True
ans[nv] = ans[v] + counter[nv]
deq.append(nv)
N, Q = inpl()
edge = [[] for i in range(N)]
for i in range(N - 1):
a, b = inpl()
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
counter = {k: 0 for k in range(N)}
for i in range(Q):
p, q = inpl()
counter[p - 1] = counter.get(p - 1, 0) + q
ans = [0 for i in range(N)]
visited = [False for i in range(N)]
bfs()
print((" ".join(list(map(str, ans)))))
| from collections import deque
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)
def inpl():
return list(map(int, input().split()))
def bfs():
visited[0] = True
ans[0] = counter[0]
deq = deque()
deq.append(0)
while deq:
v = deq.popleft()
for nv in edge[v]:
if visited[nv] is True:
continue
visited[nv] = True
ans[nv] = ans[v] + counter[nv]
deq.append(nv)
N, Q = inpl()
edge = [[] for i in range(N)]
for i in range(N - 1):
a, b = inpl()
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
counter = {k: 0 for k in range(N)}
for i in range(Q):
p, q = inpl()
counter[p - 1] = counter.get(p - 1, 0) + q
ans = [0] * N
visited = [False] * N
bfs()
print((" ".join(list(map(str, ans)))))
| p02936 |
import sys
input = sys.stdin.readline
N, Q = [int(x) for x in input().split()]
edge = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = [int(x) for x in input().split()]
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
cost = [0] * N
for _ in range(Q):
p, x = [int(x) for x in input().split()]
cost[p - 1] += x
next = [0]
for i in next:
for v in edge[i]:
s_next = set(next)
if v in s_next:
continue
next.append(v)
cost[v] += cost[i]
print((" ".join(map(str, cost))))
| import sys
input = sys.stdin.readline
N, Q = [int(x) for x in input().split()]
edge = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = [int(x) for x in input().split()]
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
cost = [0] * N
for _ in range(Q):
p, x = [int(x) for x in input().split()]
cost[p - 1] += x
next = [0]
s_next = {0}
for i in next:
for v in edge[i]:
if v in s_next:
continue
s_next.add(v)
next.append(v)
cost[v] += cost[i]
print((" ".join(map(str, cost))))
| p02936 |
N, Q = list(map(int, input().split()))
order_dict = {}
reversed_dict = {}
Q_dict = {}
have_relationlist = {}
ans = []
for i in range(N):
if i != 0:
a, b = list(map(int, input().split()))
if not a in order_dict:
order_dict[a] = set()
if not b in reversed_dict:
reversed_dict[b] = set()
order_dict[a].add(b)
reversed_dict[b].add(a)
ans.append(0)
have_relationlist[i+1] = set()
have_relationlist[i+1].add(i+1)
for b in reversed(list(range(2, N+1))):
for a in reversed_dict[b]:
if a in order_dict:
have_relationlist[a] |= order_dict[a]
have_relationlist[a] |= have_relationlist[b]
for i in range(Q):
p, x = list(map(int, input().split()))
for a in have_relationlist[p]:
ans[a-1] += x
print((' '.join(map(str, ans)))) | N, Q = list(map(int, input().split()))
order_dict = {}
ans = [0]*N
for i in range(N):
if i != 0:
a, b = list(map(int, input().split()))
if not a in order_dict:
order_dict[a] = set()
order_dict[a].add(b)
for i in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
for a in range(N+1):
if a in order_dict:
for b in order_dict[a]:
ans[b-1] += ans[a-1]
print((' '.join(map(str, ans)))) | p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
# 遅延評価で加えてあげるだけ
N,Q = list(map(int,input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N-1)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in PX:
value[p] += x
q = [(1,0)]
while q:
x,parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y,x))
answer = ' '.join(map(str,value[1:]))
print(answer)
| import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
# 遅延評価で加えてあげるだけ
N,Q = list(map(int,readline().split()))
lines = readlines()
AB = (tuple(int(x) for x in line.split()) for line in lines[:N-1])
PX = (tuple(int(x) for x in line.split()) for line in lines[-Q:])
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in PX:
value[p] += x
par = [None] * (N+1)
q = [1]
while q:
x = q.pop()
for y in graph[x]:
if y == par[x]:
continue
value[y] += value[x]
q.append(y)
par[y] = x
answer = ' '.join(map(str,value[1:]))
print(answer) | p02936 |
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
# 遅延評価で加えてあげるだけ
N,Q = list(map(int,readline().split()))
AB = (tuple(int(x) for x in readline().split()) for _ in range(N-1))
PX = (tuple(int(x) for x in readline().split()) for _ in range(Q))
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in PX:
value[p] += x
par = [None] * (N+1)
q = [1]
while q:
x = q.pop()
for y in graph[x]:
if y == par[x]:
continue
value[y] += value[x]
q.append(y)
par[y] = x
answer = ' '.join(map(str,value[1:]))
print(answer)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,Q = list(map(int,readline().split()))
ABPX = list(map(int,read().split()))
AB = iter(ABPX[:N+N-2])
PX = iter(ABPX[N+N-2:])
graph = [[] for _ in range(N+1)]
for a,b in zip(AB,AB):
graph[a].append(b)
graph[b].append(a)
val = [0] * (N+1)
for p,x in zip(PX,PX):
val[p] += x
stack = [1]
parent = [0] * (N+1)
while stack:
x = stack.pop()
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
val[y] += val[x]
print((' '.join(map(str,val[1:])))) | p02936 |
def main():
N, Q = list(map(int, input().split()))
graph = dict()
for i in range(N-1):
a, b = list(map(int, input().split()))
if a not in graph: graph[a] = [b]
else: graph[a].append(b)
# if b not in graph: graph[b] = [a]
# else: graph[b].append(a)
ops = dict()
for i in range(Q):
p, x = list(map(int, input().split()))
if p not in ops: ops[p] = x
else: ops[p] += x
# print(graph)
# print(ops)
vals = [0 for _ in range(N)]
v = 0
if 1 in ops: v = ops[1]
cur = [[1, v]]
visited = set([1])
while cur:
temp = []
for a, v in cur:
vals[a-1] += v
if a in graph:
for b in graph[a]:
if b not in visited:
if b in ops:
temp.append([b, v+ops[b]])
else:
temp.append([b, v])
visited.add(b)
cur = temp
print((' '.join(map(str, vals))))
if __name__ == '__main__':
main() | def main():
N, Q = list(map(int, input().split()))
graph = dict()
for i in range(N-1):
a, b = list(map(int, input().split()))
if a not in graph: graph[a] = [b]
else: graph[a].append(b)
# if b not in graph: graph[b] = [a]
# else: graph[b].append(a)
ops = dict()
for i in range(Q):
p, x = list(map(int, input().split()))
if p not in ops: ops[p] = x
else: ops[p] += x
# print(graph)
# print(ops)
vals = [0 for _ in range(N)]
v = 0
if 1 in ops: v = ops[1]
cur = [[1, v]]
while cur:
temp = []
for a, v in cur:
vals[a-1] += v
if a in graph:
for b in graph[a]:
if b in ops:
temp.append([b, v+ops[b]])
else:
temp.append([b, v])
cur = temp
print((' '.join(map(str, vals))))
if __name__ == '__main__':
main() | p02936 |
import sys
import heapq
import bisect
mod = 10**9+7
dd = ((-1,0),(1,0),(0,-1),(0,1))
def I(): return(int(sys.stdin.readline()))
def LI(): return([int(x) for x in sys.stdin.readline().split()])
def S(): return(sys.stdin.readline()[:-1])
def IR(n): return([I() for _ in range(n)])
def GCD(a,b):
while b!=0:
a,b = b,a%b
return a
def LCM(a,b):
return a * b // GCD(a,b)
def main():
N,Q = LI()
Child = [[] for _ in range(N)]
tree = [False]*N
tree[0] = True
cur_tree = []
for _ in range(N-1):
a,b = LI()
cur_tree.append([a-1,b-1])
counter = [0] * N
for _ in range(Q):
p,x = LI()
counter[p-1] += x
while cur_tree:
nxt_tree = []
for a,b in cur_tree:
if tree[a]:
Child[a].append(b)
counter[b] += counter[a]
tree[b] = True
elif tree[b]:
Child[b].append(a)
counter[a] += counter[b]
tree[a] = True
else:
nxt_tree.append([a,b])
cur_tree = [x for x in nxt_tree]
r = [counter[i] for i in range(N)]
return(" ".join(map(str,r)))
if __name__ == "__main__":
print((main()))
| import sys
import heapq
import bisect
mod = 10**9+7
dd = ((-1,0),(1,0),(0,-1),(0,1))
def I(): return(int(sys.stdin.readline()))
def LI(): return([int(x) for x in sys.stdin.readline().split()])
def S(): return(sys.stdin.readline()[:-1])
def IR(n): return([I() for _ in range(n)])
def GCD(a,b):
while b!=0:
a,b = b,a%b
return a
def LCM(a,b):
return a * b // GCD(a,b)
def main():
N,Q = LI()
node=[[] for _ in range(N)]
flag = [True for _ in range(N)]
for _ in range(N-1):
a,b = LI()
node[a-1].append(b-1)
node[b-1].append(a-1)
counter = [0] * N
for _ in range(Q):
p,x = LI()
counter[p-1] += x
cur = [[0,0]]
while cur:
nxt = []
for a,c in cur:
flag[a]=False
counter[a]+=c
for b in node[a]:
if flag[b]:
nxt.append([b,counter[a]])
cur = [x for x in nxt]
r = [counter[i] for i in range(N)]
return(" ".join(map(str,r)))
if __name__ == "__main__":
print((main()))
| p02936 |
import sys
import heapq
import bisect
mod = 10**9+7
dd = ((-1,0),(1,0),(0,-1),(0,1))
def I(): return(int(sys.stdin.readline()))
def LI(): return([int(x) for x in sys.stdin.readline().split()])
def S(): return(sys.stdin.readline()[:-1])
def IR(n): return([I() for _ in range(n)])
def GCD(a,b):
while b!=0:
a,b = b,a%b
return a
def LCM(a,b):
return a * b // GCD(a,b)
def main():
N,Q = LI()
node=[[] for _ in range(N)]
flag = [True for _ in range(N)]
for _ in range(N-1):
a,b = LI()
node[a-1].append(b-1)
node[b-1].append(a-1)
counter = [0] * N
for _ in range(Q):
p,x = LI()
counter[p-1] += x
cur = [[0,0]]
while cur:
nxt = []
for a,c in cur:
flag[a]=False
counter[a]+=c
for b in node[a]:
if flag[b]:
nxt.append([b,counter[a]])
cur = [x for x in nxt]
r = [counter[i] for i in range(N)]
return(" ".join(map(str,r)))
if __name__ == "__main__":
print((main()))
| import sys
def I(): return(int(sys.stdin.readline()))
def LI(): return([int(x) for x in sys.stdin.readline().split()])
def main():
N,Q = LI()
node=[[] for _ in range(N)]
flag = [True for _ in range(N)]
for _ in range(N-1):
a,b = LI()
node[a-1].append(b-1)
node[b-1].append(a-1)
counter = [0] * N
for _ in range(Q):
p,x = LI()
counter[p-1] += x
que = [[0,0]]
while que:
a,c = que.pop()
flag[a]=False
counter[a]+=c
for b in node[a]:
if flag[b]:
que.append([b,counter[a]])
r = [counter[i] for i in range(N)]
return(" ".join(map(str,r)))
if __name__ == "__main__":
print((main()))
| p02936 |
import sys
sys.setrecursionlimit(200005)
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n, q = na()
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = na()
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
ps = [0] * n
for i in range(q):
p, x = na()
p -= 1
ps[p] += x
ans = [0] * (n+1)
def dfs(cur, pre):
global ps, ans, g
ans[cur] = ans[pre] + ps[cur]
for e in g[cur]:
if e != pre:
dfs(e, cur)
dfs(0, -1)
print((" ".join(map(str, ans[0:-1]))))
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n, q = na()
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = na()
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
ps = [0] * n
for i in range(q):
p, x = na()
p -= 1
ps[p] += x
stack = [0] * (n+1)
inds = [0] * (n+1)
sp = 0
stack[sp] = 0
sp += 1
while sp > 0:
cur = stack[sp-1]
if inds[sp-1] == len(g[cur]):
sp -= 1
continue
if inds[sp-1] == 0 and sp > 1:
ps[cur] += ps[stack[sp-2]]
if sp == 1 or stack[sp-2] != g[cur][inds[sp-1]]:
stack[sp] = g[cur][inds[sp-1]]
inds[sp] = 0
inds[sp-1] += 1
sp += 1
continue
inds[sp - 1] += 1
print((" ".join(map(str, ps))))
| p02936 |
from collections import defaultdict, deque
N, Q = list(map(int, input().split()))
connect_dic = defaultdict(list)
for _ in range(N - 1):
a, b = list(map(int, input().split()))
connect_dic[a].append(b)
connect_dic[b].append(a)
query_weight = defaultdict(int)
for _ in range(Q):
q, x = list(map(int, input().split()))
query_weight[q] += x
used = set()
dq = deque([1])
used.add(1)
ans = [0] * (N + 1)
while dq:
node = dq.popleft()
can = connect_dic[node]
used.add(node)
ans[node] += query_weight[node]
for c in can:
if c not in used:
ans[c] += ans[node]
dq.append(c)
ans = [str(w) for w in ans[1:]]
print((' '.join(ans)))
| from collections import deque
N, Q = list(map(int, input().split()))
connect_lst = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
connect_lst[a].append(b)
connect_lst[b].append(a)
query_weight = [0] * (N + 1)
for _ in range(Q):
q, x = list(map(int, input().split()))
query_weight[q] += x
used = set()
dq = deque([1])
used.add(1)
ans = [0] * (N + 1)
while dq:
node = dq.popleft()
can = connect_lst[node]
used.add(node)
ans[node] += query_weight[node]
for c in can:
if c not in used:
ans[c] += ans[node]
dq.append(c)
ans = [str(w) for w in ans[1:]]
print((' '.join(ans)))
| p02936 |
from collections import defaultdict
import sys
sys.setrecursionlimit(300000)
N, Q = list(map(int, input().split()))
tree = defaultdict(list)
counter = [0] * N
for i in range(N-1):
a, b = list(map(int, input().split()))
tree[a-1].append(b-1)
tree[b-1].append(a-1)
for j in range(Q):
p, x = list(map(int, input().split()))
counter[p-1] += x
visited = [False] * N
def dfs(parent):
visited[parent] = True
for child in tree[parent]:
if not visited[child]:
counter[child] += counter[parent]
dfs(child)
dfs(0)
print((' '.join(map(str, counter))))
| from collections import defaultdict, deque
N, Q = list(map(int, input().split()))
tree = defaultdict(list)
counter = [0] * N
for i in range(N-1):
a, b = list(map(int, input().split()))
tree[a-1].append(b-1)
tree[b-1].append(a-1)
for j in range(Q):
p, x = list(map(int, input().split()))
counter[p-1] += x
visited = [False] * N
queue = deque()
queue.append(0)
while queue:
parent = queue.popleft()
visited[parent] = True
for child in tree[parent]:
if not visited[child]:
counter[child] += counter[parent]
queue.append(child)
print((' '.join(map(str, counter))))
| p02936 |
import queue
import sys
sys.setrecursionlimit(5*10**5)
N, Q = list(map(int, input().split()))
ab=[]
for _ in range(N-1):
ab.append(tuple(map(int, input().split())))
px=[]
for _ in range(Q):
px.append(tuple(map(int, input().split())))
cnt=[0]*(N+1)
for el in px:
cnt[el[0]]+=el[1]
#print(cnt)
lst=[[] for _ in range(N+1)]
for el in ab:
lst[el[0]].append(el[1])
lst[el[1]].append(el[0])
#print(lst)
seen = [False] * (N + 1)
def dfs(n):
seen[n] = True
for child in lst[n]:
if seen[child] == False:
cnt[child]+=cnt[n]
dfs(child)
dfs(1)
#print(cnt)
print((' '.join(list(map(str, cnt[1:]))))) | import sys
sys.setrecursionlimit(5*10**5)
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
ab=[]
for _ in range(N-1):
ab.append(tuple(map(int, input().split())))
px=[]
for _ in range(Q):
px.append(tuple(map(int, input().split())))
cnt=[0]*(N+1)
for el in px:
cnt[el[0]] += el[1]
#print(cnt)
lst=[[] for _ in range(N+1)]
for el in ab:
lst[el[0]].append(el[1])
lst[el[1]].append(el[0])
#print(lst)
seen = [False] * (N + 1)
def dfs(n):
seen[n] = True
for child in lst[n]:
if seen[child] == False:
cnt[child]+=cnt[n]
dfs(child)
dfs(1)
#print(cnt)
print((' '.join(list(map(str, cnt[1:]))))) | p02936 |
import sys
sys.setrecursionlimit(5*10**5)
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
ab=[]
for _ in range(N-1):
ab.append(tuple(map(int, input().split())))
px=[]
for _ in range(Q):
px.append(tuple(map(int, input().split())))
cnt=[0]*(N+1)
for el in px:
cnt[el[0]] += el[1]
#print(cnt)
lst=[[] for _ in range(N+1)]
for el in ab:
lst[el[0]].append(el[1])
lst[el[1]].append(el[0])
#print(lst)
seen = [False] * (N + 1)
def dfs(n):
seen[n] = True
for child in lst[n]:
if seen[child] == False:
cnt[child]+=cnt[n]
dfs(child)
dfs(1)
#print(cnt)
print((' '.join(list(map(str, cnt[1:]))))) | import sys
sys.setrecursionlimit(5*10**5)
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
ab=[]
for _ in range(N-1):
ab.append(tuple(map(int, input().split())))
px=[]
for _ in range(Q):
px.append(tuple(map(int, input().split())))
cnt=[0]*(N+1)
for el in px:
cnt[el[0]] += el[1]
#print(cnt)
lst=[[] for _ in range(N+1)]
for el in ab:
lst[el[0]].append(el[1])
lst[el[1]].append(el[0])
#print(lst)
seen = set()
def dfs(n):
seen.add(n)
for child in lst[n]:
if child not in seen:
cnt[child]+=cnt[n]
dfs(child)
dfs(1)
#print(cnt)
print((' '.join(list(map(str, cnt[1:]))))) | p02936 |
import collections
n, q = list(map(int, input().split()))
edge = [tuple(map(int, input().split())) for _ in range(n - 1)]
counter = [0] * n
for _ in range(q):
p, x = list(map(int, input().split()))
counter[p - 1] += x
tree = [[] for _ in range(n)]
edge = collections.deque(edge)
flag = [False] * n
flag[0] = True
while len(edge) != 0:
a, b = edge.popleft()
if flag[a - 1]:
tree[a - 1].append(b - 1)
flag[b - 1] = True
elif flag[b - 1]:
tree[b - 1].append(a - 1)
flag[a - 1] = True
else:
edge.append((a, b))
que = collections.deque([0])
while len(que) != 0:
i = que.popleft()
for j in tree[i]:
counter[j] += counter[i]
que.append(j)
print((' '.join([str(c) for c in counter]))) | import collections
n, q = list(map(int, input().split()))
edge = [tuple(map(int, input().split())) for _ in range(n - 1)]
counter = [0] * n
for _ in range(q):
p, x = list(map(int, input().split()))
counter[p - 1] += x
tree = [[] for _ in range(n)]
edge = collections.deque(edge)
while len(edge) != 0:
a, b = edge.popleft()
tree[a - 1].append(b - 1)
tree[b - 1].append(a - 1)
que = collections.deque([0])
flag = [False] * n
while len(que) != 0:
i = que.popleft()
flag[i] = True
for j in tree[i]:
if flag[j]: continue
counter[j] += counter[i]
que.append(j)
print((' '.join([str(c) for c in counter]))) | p02936 |
import sys
sys.setrecursionlimit(10 ** 7)
def dfs(tree, count, p):
# print(p, tree[p])
for i in tree[p]:
count[i] += count[p]
dfs(tree, count, i)
def solve(tree, count):
from collections import deque
stk = deque([1])
while stk:
p = stk.pop()
for i in tree[p]:
count[i] += count[p]
stk.append(i)
def remove_parents(tree, p):
for i in tree[p]:
tree[i].remove(p)
remove_parents(tree, i)
def main():
N, Q = list(map(int, input().split()))
tree = {i+1: set() for i in range(N)}
count = {i+1: 0 for i in range(N)}
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a].add(b)
tree[b].add(a)
for _ in range(Q):
p, x = list(map(int, input().split()))
count[p] += x
# print(count)
# visited = {k+1: False for k in range(N)}
# visited[1] = True
remove_parents(tree, 1)
# print(tree)
# dfs(tree, count, 1)
solve(tree, count)
ans = [str(count[k]) for k in sorted(count.keys())]
print((" ".join(ans)))
if __name__ == '__main__':
main() | from collections import defaultdict, deque
def main():
N, Q = list(map(int, input().split()))
tree = defaultdict(list)
counter = defaultdict(int)
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
for _ in range(Q):
p, x = list(map(int, input().split()))
counter[p] += x
# bfs
q = deque([1])
visited = {1}
while q:
i = q.popleft()
for j in tree[i]:
if j not in visited:
q.append(j)
counter[j] += counter[i]
visited.add(j)
counts = [counter[i] for i in range(1, N+1)]
ans = " ".join(map(str, counts))
print(ans)
if __name__ == '__main__':
main() | p02936 |
import queue
n,q = list(map(int, input().split()))
d = [[] for i in range(n)]
for i in range(n-1):
a,b = list(map(int, input().split()))
d[a-1].append(b-1)
d[b-1].append(a-1)
c = [0]*n
for i in range(q):
p,x = list(map(int,input().split()))
c[p-1]+=x
ans = [0]*n
visited = [0]*n
que = queue.Queue()
que.put(0)
visited[0]=1
ans[0]+=c[0]
while not que.empty():
x = que.get()
for y in d[x]:
if visited[y]==1:
continue
else:
ans[y]+=ans[x]+c[y]
visited[y]=1
que.put(y)
print((' '.join(map(str,ans))))
| n,q = list(map(int, input().split()))
d = [[] for i in range(n)]
for i in range(n-1):
a,b = list(map(int, input().split()))
d[a-1].append(b-1)
d[b-1].append(a-1)
c = [0]*n
for i in range(q):
p,x = list(map(int,input().split()))
c[p-1]+=x
ans = [0]*n
visited = [0]*n
que = []
que.append(0)
visited[0]=1
ans[0]+=c[0]
while que:
x = que.pop()
for y in d[x]:
if visited[y]==1:
continue
else:
ans[y]+=ans[x]+c[y]
visited[y]=1
que.append(y)
print((' '.join(map(str,ans))))
| p02936 |
import sys
sys.setrecursionlimit(20000000)
N, Q = [int(i) for i in input().split()]
tree = {i:[] for i in range(1,N+1)}
cost_ls = {i:0 for i in range(1,N+1)}
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
def plus(node, _from):
#cost_ls[node] += num
for child in tree[node]:
if child == _from:
continue
cost_ls[child] += cost_ls[node]
plus(child, node)
for _ in range(Q):
p, x = list(map(int, input().split()))
cost_ls[p] += x
plus(1, 0)
print((' '.join(str(cost_ls[i]) for i in range(1,N+1)))) | import sys
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
N, Q = [int(i) for i in input().split()]
tree = {i:[] for i in range(1,N+1)}
cost_ls = {i:0 for i in range(1,N+1)}
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
def plus(node, _from):
#cost_ls[node] += num
for child in tree[node]:
if child == _from:
continue
cost_ls[child] += cost_ls[node]
plus(child, node)
for _ in range(Q):
p, x = list(map(int, input().split()))
cost_ls[p] += x
plus(1, 0)
print((' '.join(str(cost_ls[i]) for i in range(1,N+1)))) | p02936 |
n, q = list(map(int, input().split()))
tl = [list() for _ in range(n)]
ab = []
ans = [0] * n
for i in range(n-1):
a, b = list(map(int, input().split()))
ab.append((a, b))
ab.sort(reverse=True)
for a, b in ab:
a -= 1
b -= 1
tl[a].append(b)
tl[a].extend(tl[b])
for i in range(q):
p, x = list(map(int, input().split()))
ans[p-1] += x
for num in tl[p-1]:
ans[num] += x
print((" ".join(map(str, ans)))) | n, q = list(map(int, input().split()))
tl = [list() for _ in range(n)]
ab = [None] * (n-1)
ans = [0] * n
for i in range(n-1):
ab[i] = tuple(map(int, input().split()))
ab.sort(reverse=True)
for a, b in ab:
a -= 1
b -= 1
tl[a].append(b)
tl[a].extend(tl[b])
for _ in range(q):
p, x = list(map(int, input().split()))
ans[p-1] += x
for num in tl[p-1]:
ans[num] += x
print((" ".join(map(str, ans)))) | p02936 |
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
from collections import deque
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
N, Q = list(map(int, readline().split()))
path = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, readline().split()))
path[a-1].append(b-1)
path[b-1].append(a-1)
child = [[] for _ in range(N)]
child[0] = path[0]
used = [False] * N
used[0] = True
que = deque(child[0])
while que:
x = que.popleft()
used[x] = True
for a in path[x]:
if used[a]:
continue
else:
child[x].append(a)
que.append(a)
counter = [0]*N
for _ in range(Q):
p, x = list(map(int, readline().split()))
que.append(p-1)
counter[p-1] += x
while que:
a = que.popleft()
for b in child[a]:
counter[b] += x
que.append(b)
print((' '.join(map(str, counter))))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
from collections import deque
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
N, Q = list(map(int, readline().split()))
AB = list(list(map(int, readline().split())) for _ in range(N-1))
PX = list(list(map(int, readline().split())) for _ in range(Q))
graph = [[] for _ in range(N)]
for a, b in AB:
graph[a-1].append(b-1)
graph[b-1].append(a-1)
value = [0] * N
for p, x in PX:
value[p-1] += x
que = deque([0])
visited = [False]*N
while que:
x = que.popleft()
visited[x] = True
for y in graph[x]:
if visited[y]:
continue
else:
value[y] += value[x]
que.append(y)
print((' '.join(map(str, value))))
if __name__ == '__main__':
main()
| p02936 |
import sys
sys.setrecursionlimit(10**7)
def cur(x):
for i in neighbor[x]:
ans[i]+=ans[x]
neighbor[i].remove(x)
cur(i)
n,q=list(map(int,input().split()))
neighbor=[[] for _ in range(n+1)]
ans=[0]*(n+1)
for _ in range(n-1):
a,b=list(map(int,input().split()))
neighbor[a].append(b)
neighbor[b].append(a)
for _ in range(q):
p,x=list(map(int,input().split()))
ans[p]+=x
cur(1)
print((" ".join(map(str,ans[1:]))))
| n,q=list(map(int,input().split()))
neighbor=[[] for _ in range(n+1)]
ans=[0]*(n+1)
for _ in range(n-1):
a,b=list(map(int,input().split()))
neighbor[a].append(b)
neighbor[b].append(a)
for _ in range(q):
p,x=list(map(int,input().split()))
ans[p]+=x
visit=[True]*(n+1)
tmp=[1]
for x in tmp:
visit[x]=False
for y in neighbor[x]:
if visit[y]:
tmp.append(y)
ans[y]+=ans[x]
print((" ".join(map(str,ans[1:]))))
| p02936 |
import sys
sys.setrecursionlimit(10000000)
N,Q=list(map(int, input().split()))
tree_dist={}
for i in range(N):
tree_dist[i+1] = []
for i in range(N-1):
a,b = list(map(int, input().split()))
tree_dist[a].append(b)
tree_dist[b].append(a)
z=[0]*N
for i in range(Q):
p,x = list(map(int, input().split()))
z[p-1] += x
def saiki(i,p):
L = list(tree_dist[i])
for l in L:
if l != p:
z[l-1] += z[i-1]
saiki(l,i)
saiki(1,0)
print((" ".join(map(str,z))))
| import sys
sys.setrecursionlimit(10000000)
input=lambda :sys.stdin.readline()
N,Q=list(map(int, input().split()))
tree_dist={}
for i in range(N):
tree_dist[i+1] = []
for i in range(N-1):
a,b = list(map(int, input().split()))
tree_dist[a].append(b)
tree_dist[b].append(a)
z=[0]*N
for i in range(Q):
p,x = list(map(int, input().split()))
z[p-1] += x
def saiki(i,p):
L = list(tree_dist[i])
for l in L:
if l != p:
z[l-1] += z[i-1]
saiki(l,i)
saiki(1,0)
print((" ".join(map(str,z))))
| p02936 |
from collections import deque
N,Q = list(map(int, input().split()))
g = [[] for i in range(N)]
q,s,c = [0]*N,[False]*N,[0]*N
d = deque()
for _ in range(N-1):
a,b = list(map(int, input().split()))
a,b = a-1,b-1
g[a].append(b)
g[b].append(a)
for _ in range(Q):
p,x = list(map(int, input().split()))
q[p-1] += x
d.append(0)
while d:
v = d.popleft()
s[v] = True
for x in g[v]:
if not s[x]:
d.append(x)
q[x] += q[v]
print((' '.join(map(str,q)))) | from collections import deque
N,Q = list(map(int, input().split()))
g,q,s,c,d = [[] for i in range(N)],[0]*N,[False]*N,[0]*N,deque()
for _ in range(N-1):
a,b = [int(x)-1 for x in input().split()]
g[a].append(b)
g[b].append(a)
for _ in range(Q):
p,x = list(map(int, input().split()))
q[p-1] += x
d.append(0)
while d:
v = d.popleft()
s[v] = True
for x in g[v]:
if not s[x]:
d.append(x)
q[x] += q[v]
print((' '.join(map(str,q)))) | p02936 |
from sys import setrecursionlimit
setrecursionlimit(10**6)
N, Q = list(map(int, input().split()))
def update(v, p):
for next in tree[v]:
if next == p:
continue
counter[next] += counter[v]
update(next, v)
tree = [[] for _ in range(N)]
counter = [0] * N
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a-1].append(b-1)
tree[b-1].append(a-1)
for _ in range(Q):
p, x = list(map(int, input().split()))
counter[p-1] += x
update(0, -1)
print((" ".join(map(str, counter))))
| from sys import setrecursionlimit
from sys import stdin
input = stdin.readline
setrecursionlimit(10**7)
N, Q = list(map(int, input().split()))
def update(v, p):
for next in tree[v]:
if next == p:
continue
counter[next] += counter[v]
update(next, v)
tree = [[] for _ in range(N)]
counter = [0] * N
for _ in range(N-1):
a, b = list(map(int, input().split()))
tree[a-1].append(b-1)
tree[b-1].append(a-1)
for _ in range(Q):
p, x = list(map(int, input().split()))
counter[p-1] += x
update(0, -1)
print((" ".join(map(str, counter))))
| p02936 |
N,Q = list(map(int,input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N-1)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in PX:
value[p] += x
q = [(1,0)]
while q:
x,parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y,x))
answer = ' '.join(map(str,value[1:]))
print(answer)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,Q = list(map(int,input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N-1)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in PX:
value[p] += x
q = [(1,0)]
while q:
x,parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y,x))
answer = ' '.join(map(str,value[1:]))
print(answer)
| p02936 |
n, q = list(map(int, input().split()))
# 各ノードのリンクを記録
link_dict = dict()
keys = []
for i in range(n-1):
a,b = list(map(int, input().split()))
if a in keys:
link_dict[str(a-1)].add(b)
else:
keys.append(a)
link_dict[str(a-1)] = {b}
# 各ノードの部分木の全てのノードをリストアップ
link_set = [set() for i in range(n-1)]
for i in sorted(keys, reverse=True):
link_set[int(i) - 1] = set(link_dict[str(i-1)])
if int(i) < n - 1:
for j in link_dict[str(int(i) - 1)]:
if j < n - 1:
link_set[i - 1] = link_set[i - 1] | link_set[j - 1]
# カウンターの計算を実施
counters = [0] * n
for i in range(q):
p, x = list(map(int, input().split()))
counters[p - 1] += x
children_counters = [0] * n
for i in range(0, n-1):
for node in link_set[i]:
children_counters[node - 1] += counters[i]
str_counters = [str(counters[i] + children_counters[i]) for i in range(n)]
print((' '.join(str_counters))) | n, q = list(map(int, input().split()))
# 各ノードのリンクを記録
link_set = [set() for _ in range(n-1)]
for i in range(n-1):
a, b = list(map(int, input().split()))
link_set[a - 1].add(b)
# カウンターの計算を実施 (O(QN)の計算を避けることがポイント)
## O(Q)の計算
counters = [0] * n
for i in range(q):
p, x = list(map(int, input().split()))
counters[p - 1] += x
## O(N)の計算
for i in range(n - 1):
for node in link_set[i]:
counters[node - 1] += counters[i]
str_counters = [str(c) for c in counters]
print((' '.join(str_counters))) | p02936 |
# 2019-11-17 10:52:21(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np
def main():
n, q = [int(x) for x in sys.stdin.readline().split()]
AB = [[] for _ in range(n+1)]
for _ in range(n-1):
a, b = [int(x) for x in sys.stdin.readline().split()]
AB[a].append(b)
AB[b].append(a)
# 無向グラフとして考える
ans = [0 for _ in range(n+1)]
for _ in range(q):
p, x = [int(x) for x in sys.stdin.readline().split()]
ans[p] += x
stack = [1]
parent = [0 for _ in range(n+1)]
while stack:
x = stack.pop()
for y in AB[x]:
if y != parent[x]: # yがxの親でなければ
parent[y] = x # xがyの親
stack.append(y)
ans[y] += ans[x]
print((' '.join(map(str, ans[1:]))))
if __name__ == "__main__":
main()
| import sys
n, q = map(int, sys.stdin.readline().split())
g = [[] for _ in range(n+1)]
for _ in range(n-1):
a, b = map(int, sys.stdin.readline().split())
g[a].append(b)
g[b].append(a)
px = zip(*[map(int, sys.stdin.read().split())] * 2)
def main():
value = [0] * (n + 1)
for p, x in px:
value[p] += x
stack = [1]
par = [None] * (n + 1)
while stack:
u = stack.pop()
for v in g[u]:
if v != par[u]:
par[v] = u
value[v] += value[u]
stack.append(v)
return value[1:]
if __name__ == '__main__':
ans = main()
print(*ans, sep=' ')
| p02936 |
# 早くなるおまじない
import sys
input = sys.stdin.buffer.readline
# 再帰関数の呼び出し制限
sys.setrecursionlimit(10**6)
n,q = map(int,input().split())
dic = {}
for i in range(n-1):
aa, bb = map(int,input().split())
if aa not in dic:
dic[aa] = set()
dic[aa].add(bb)
else:
dic[aa].add(bb)
if bb not in dic:
dic[bb] = set()
dic[bb].add(aa)
else:
dic[bb].add(aa)
p = []
x = []
for _ in range(q):
s, t = map(int,input().split())
p.append(s)
x.append(t)
res = [0]*n
for i in range(q):
res[p[i]-1] += x[i]
visited = set()
# 深さが一つ前のやつのresの値を足す
# dfsはおk，ここで累積和を使う発想が出てこなかった
def dfs(node, prev):
visited.add(node)
if prev != 0:
res[node-1] += res[prev-1]
for i in dic[node]:
if i not in visited:
prev = node
dfs(i, prev)
dfs(1, 0)
print(*res, sep=" ")
| # 早くなるおまじない
import sys
input = sys.stdin.buffer.readline
# 再帰関数の呼び出し制限
sys.setrecursionlimit(3 * 10 ** 5)
# 深さが一つ前のやつのresの値を足す
# dfsはおk，ここで累積和を使う発想が出てこなかった
# def dfs(node, prev):
# visited.add(node)
# if prev != 0:
# res[node-1] += res[prev-1]
# for i in dic[node]:
# if i not in visited:
# prev = node
# dfs(i, prev)
def dfs(node, prev, visited, res, dic):
visited.add(node)
if prev != 0:
res[node-1] += res[prev-1]
for i in dic[node]:
if i not in visited:
prev = node
dfs(i, prev, visited, res, dic)
def main():
n,q = map(int,input().split())
dic = {}
for i in range(n-1):
aa, bb = map(int,input().split())
if aa not in dic:
dic[aa] = set()
dic[aa].add(bb)
else:
dic[aa].add(bb)
if bb not in dic:
dic[bb] = set()
dic[bb].add(aa)
else:
dic[bb].add(aa)
p = []
x = []
for _ in range(q):
s, t = map(int,input().split())
p.append(s)
x.append(t)
res = [0]*n
for i in range(q):
res[p[i]-1] += x[i]
visited = set()
dfs(1, 0, visited, res, dic)
print(*res, sep=" ")
if __name__ == '__main__':
main()
| p02936 |
N,Q = map(int,input().split())
Edge = [[] for _ in range(N+1)]
for _ in range(N-1):
a,b, = map(int,input().split())
Edge[a].append(b)
Edge[b].append(a)
PX = [list(map(int,input().split())) for _ in range(Q)]
visited = [True for _ in range(N+1)]
visited[1] = False
stack = [1]
Ans = [0]*(N+1)
for p,x in PX:
Ans[p] += x
while len(stack) > 0:
nextnode = stack.pop()
for e in Edge[nextnode]:
if visited[e]:
visited[e] = False
stack.append(e)
Ans[e] += Ans[nextnode]
print(*Ans[1:],sep = " ")
| N, Q = map(int,input().split())
E = [[] for _ in range(N+1)]
for _ in range(N-1):
a,b = map(int,input().split())
E[a].append(b)
E[b].append(a)
PX = [list(map(int,input().split())) for _ in range(Q)]
def main():
V = [0]*(N+1)
for p,x in PX:
V[p] += x
stack = [1]
gone = [False]*(N+1)
gone[1] = True
while len(stack) > 0:
node = stack.pop(-1)
for e in E[node]:
if not(gone[e]):
stack.append(e)
V[e] += V[node]
gone[e] = True
print(*V[1:],sep =" ")
return
if __name__ == "__main__":
main()
| p02936 |
import collections
def solve(N, Q, ABs, PXs):
# print(N, ",", Q, ",", ABs, ",", PXs)
vertexes = {}
values = {i: 0 for i in range(N + 1)}
for a, b in ABs:
vertexes.setdefault(a, []).append(b)
vertexes.setdefault(b, []).append(a)
for p, x in PXs:
values[p] += x
ans = [-1 for i in range(N + 1)]
queue = collections.deque()
queue.append((1, 0))
while queue:
index, parent_value = queue.popleft()
value = parent_value + values[index]
ans[index] = value
for child in vertexes[index]:
if ans[child] == -1:
queue.append((child, value))
return " ".join([str(a) for a in ans[1:]])
# assert (solve(4, 3, [(1, 2), (2, 3), (2, 4)], [(2, 10), (1, 100), (3, 1)]) == "100 110 111 110")
# assert (solve(6 , 2 , [(1, 2), (1, 3), (2, 4), (3, 6), (2, 5)] , [(1, 10), (1, 10)]) == "20 20 20 20 20 20")
if __name__ == "__main__":
N, Q = tuple(map(int, input().split(" ")))
ABs = [tuple(map(int, input().split(" "))) for _ in range(N - 1)]
PXs = [tuple(map(int, input().split(" "))) for _ in range(Q)]
print((solve(N, Q, ABs, PXs)))
|
def solve(N, Q, ABs, PXs):
values = {i: 0 for i in range(N + 1)}
ans = [-1 for i in range(N + 1)]
vertexes = {}
for a, b in ABs:
vertexes.setdefault(a, []).append(b)
vertexes.setdefault(b, []).append(a)
for p, x in PXs:
values[p] += x
queue = []
queue.append((1, 0))
while queue:
index, parent_value = queue.pop()
value = parent_value + values[index]
ans[index] = value
for child in vertexes[index]:
if ans[child] == -1:
queue.append((child, value))
return " ".join([str(a) for a in ans[1:]])
assert (solve(4, 3, [(1, 2), (2, 3), (2, 4)], [(2, 10), (1, 100), (3, 1)]) == "100 110 111 110")
assert (solve(6 , 2 , [(1, 2), (1, 3), (2, 4), (3, 6), (2, 5)] , [(1, 10), (1, 10)]) == "20 20 20 20 20 20")
if __name__ == "__main__":
N, Q = tuple(map(int, input().split(" ")))
ABs = [tuple(map(int, input().split(" "))) for _ in range(N - 1)]
PXs = [tuple(map(int, input().split(" "))) for _ in range(Q)]
print((solve(N, Q, ABs, PXs)))
| p02936 |
def solve(N, Q, ABs, PXs):
values = {i: 0 for i in range(N + 1)}
ans = [-1 for i in range(N + 1)]
vertexes = {}
for a, b in ABs:
vertexes.setdefault(a, []).append(b)
vertexes.setdefault(b, []).append(a)
for p, x in PXs:
values[p] += x
queue = []
queue.append((1, 0))
while queue:
index, parent_value = queue.pop()
value = parent_value + values[index]
ans[index] = value
for child in vertexes[index]:
if ans[child] == -1:
queue.append((child, value))
return " ".join([str(a) for a in ans[1:]])
assert (solve(4, 3, [(1, 2), (2, 3), (2, 4)], [(2, 10), (1, 100), (3, 1)]) == "100 110 111 110")
assert (solve(6 , 2 , [(1, 2), (1, 3), (2, 4), (3, 6), (2, 5)] , [(1, 10), (1, 10)]) == "20 20 20 20 20 20")
if __name__ == "__main__":
N, Q = tuple(map(int, input().split(" ")))
ABs = [tuple(map(int, input().split(" "))) for _ in range(N - 1)]
PXs = [tuple(map(int, input().split(" "))) for _ in range(Q)]
print((solve(N, Q, ABs, PXs)))
|
def solve(N, Q, ABs, PXs):
values = {i: 0 for i in range(N + 1)}
ans = [-1 for i in range(N + 1)]
vertexes = {}
for a, b in ABs:
vertexes.setdefault(a, []).append(b)
vertexes.setdefault(b, []).append(a)
for p, x in PXs:
values[p] += x
queue = []
queue.append((1, 0))
while queue:
index, parent_value = queue.pop()
value = parent_value + values[index]
ans[index] = value
for child in vertexes[index]:
if ans[child] == -1:
queue.append((child, value))
return " ".join([str(a) for a in ans[1:]])
if __name__ == "__main__":
N, Q = tuple(map(int, input().split(" ")))
ABs = [tuple(map(int, input().split(" "))) for _ in range(N - 1)]
PXs = [tuple(map(int, input().split(" "))) for _ in range(Q)]
print((solve(N, Q, ABs, PXs)))
| p02936 |
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def solve():
N, Q = list(map(int, input().split()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
A, B = list(map(int, input().split()))
A, B = A-1, B-1
adjL[A].append(B)
adjL[B].append(A)
anss = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
p = p-1
anss[p] += x
useds = [False] * N
def dfs(vNow, x):
useds[vNow] = True
anss[vNow] += x
for v2 in adjL[vNow]:
if not useds[v2]:
dfs(v2, anss[vNow])
dfs(0, 0)
print((' '.join(map(str, anss))))
solve()
| def solve():
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
A, B = list(map(int, input().split()))
A, B = A-1, B-1
adjL[A].append(B)
adjL[B].append(A)
anss = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
p = p-1
anss[p] += x
useds = [False] * N
def dfs(vNow, x):
useds[vNow] = True
anss[vNow] += x
ans = anss[vNow]
for v2 in adjL[vNow]:
if not useds[v2]:
dfs(v2, ans)
dfs(0, 0)
print((' '.join(map(str, anss))))
solve()
| p02936 |
# https://atcoder.jp/contests/abc138/tasks/abc138_d
from collections import deque
def bfs(graph, start, query, n):
queue = deque([])
acc = query[start] if start in query else 0
queue.append([start, acc])
ans = [-1] * n
ans[start] = acc
while queue:
idx, acc = queue.popleft()
for child in list(graph[idx].keys()):
if ans[child] >= 0:
continue
ans[child] = acc
if child in query:
ans[child] += query[child]
queue.append([child, ans[child]])
print((' '.join(map(str, ans))))
n,q = list(map(int, input().split()))
tree = {}
start = 0
for i in range(n-1):
a,b = list(map(int, input().split()))
a -= 1
b -= 1
if a not in tree:
tree[a] = {}
tree[a][b] = 1
if b not in tree:
tree[b] = {}
tree[b][a] = 1
query = {}
for _ in range(q):
p, x = list(map(int,input().split()))
p -= 1
if p not in query:
query[p] = x
else:
query[p] += x
bfs(tree, start, query, n)
| # https://atcoder.jp/contests/abc138/tasks/abc138_d
from collections import deque
def dfs(graph, start, ans, n):
queue = deque([])
queue.append(start)
visited = [False] * n
visited[start] = True
while queue:
parent = queue.popleft()
for child in list(graph[parent].keys()):
if visited[child]:
continue
visited[child] = True
ans[child] += ans[parent]
queue.append(child)
print((' '.join(map(str, ans))))
n,q = list(map(int, input().split()))
tree = {}
start = 0
for i in range(n-1):
a,b = list(map(int, input().split()))
a -= 1
b -= 1
if a not in tree:
tree[a] = {}
tree[a][b] = 1
if b not in tree:
tree[b] = {}
tree[b][a] = 1
ans = [0]*n
for _ in range(q):
p, x = list(map(int,input().split()))
p -= 1
ans[p] += x
dfs(tree, start, ans, n)
| p02936 |
# Input N, Q
N, Q = [int(c) for c in input().split()]
# Input edges
edges = [[] for i in range(N)]
for i in range(N-1):
u, v = [int(c)-1 for c in input().split()]
edges[u].append(v)
edges[v].append(u)
# Form tree
parent = [None for i in range(N)]
childs = [[] for i in range(N)]
def dfs(root):
parent[root] = -1
stack = [root]
while stack:
now = stack.pop()
for nex in edges[now]:
if parent[nex] is None:
parent[nex] = now
childs[now].append(nex)
stack.append(nex)
dfs(0)
# Queries
incremented = [0 for i in range(N)]
for i in range(Q):
v, add = [int(c) for c in input().split()]
v -= 1
incremented[v] += add
# Lower propagate
total = [0 for i in range(N)]
def propagate(root):
global total
stack = [root]
while stack:
now = stack.pop()
total[now] += incremented[now]
for child in childs[now]:
total[child] += total[now]
stack.append(child)
propagate(0)
# Print
print((" ".join(str(num) for num in total)))
| def main():
# Input N, Q
N, Q = [int(c) for c in input().split()]
# Input edges
edges = [[] for i in range(N)]
for i in range(N-1):
u, v = [int(c)-1 for c in input().split()]
edges[u].append(v)
edges[v].append(u)
# Form tree
parent = [None for i in range(N)]
childs = [[] for i in range(N)]
def dfs(root):
parent[root] = -1
stack = [root]
while stack:
now = stack.pop()
for nex in edges[now]:
if parent[nex] is None:
parent[nex] = now
childs[now].append(nex)
stack.append(nex)
dfs(0)
# Queries
incremented = [0 for i in range(N)]
for i in range(Q):
v, add = [int(c) for c in input().split()]
v -= 1
incremented[v] += add
# Lower propagate
total = [0 for i in range(N)]
def propagate(root):
stack = [root]
while stack:
now = stack.pop()
total[now] += incremented[now]
for child in childs[now]:
total[child] += total[now]
stack.append(child)
propagate(0)
# Print
print((" ".join(str(num) for num in total)))
main()
| p02936 |
#/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
N, Q = map(int, input().split())
adj = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = map(int, input().split())
a, b = (a - 1, b - 1)
adj[a].append(b)
adj[b].append(a)
values = [0 for _ in range(N)]
for _ in range(Q):
p, x = map(int, input().split())
values[p - 1] += x
def dfs(node, parent):
for child in adj[node]:
if child == parent: continue
values[child] += values[node]
dfs(child, node)
dfs(0, -1)
print(*values, sep=" ")
| #/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
def input():
return sys.stdin.readline()
N, Q = list(map(int, input().split()))
adj = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a, b = (a - 1, b - 1)
adj[a].append(b)
adj[b].append(a)
values = [0 for _ in range(N)]
for _ in range(Q):
p, x = list(map(int, input().split()))
values[p - 1] += x
def dfs(node, parent):
for child in adj[node]:
if child == parent: continue
values[child] += values[node]
dfs(child, node)
dfs(0, -1)
print((" ".join(map(str, values))))
| p02936 |
import sys
sys.setrecursionlimit(2 *(10**5) + 1)
def main():
N, Q = list(map(int, input().split()))
d = {}
for _ in range(N-1):
a, b = list(map(int, input().split()))
if a in d:
d[a].append(b)
else:
d[a] = [b]
if b in d:
d[b].append(a)
else:
d[b] = [a]
dc = {}
for _ in range(Q):
p, x = list(map(int, input().split()))
if p in dc:
dc[p] += x
else:
dc[p] = x
v = set()
l = [0] * N
def dfs(n, p):
v.add(n)
if n in dc:
p += dc[n]
for i in d[n]:
if i not in v:
dfs(i, p)
l[n-1] = p
dfs(1, 0)
return ' '.join(str(i) for i in l)
print((main()))
| def main():
N, Q = list(map(int, input().split()))
d = {}
for _ in range(N-1):
a, b = list(map(int, input().split()))
if a in d:
d[a].append(b)
else:
d[a] = [b]
if b in d:
d[b].append(a)
else:
d[b] = [a]
dc = {}
for _ in range(Q):
p, x = list(map(int, input().split()))
if p in dc:
dc[p] += x
else:
dc[p] = x
v = set()
vr = set(range(1,N+1))
l = [0] * N
n = [(1,0)]
c = []
while v != vr:
for i, j in n:
v.add(i)
if i in dc:
j += dc[i]
l[i-1] = j
for k in d[i]:
if k not in v:
c.append((k, j))
n = c
c = []
return ' '.join(str(i) for i in l)
print((main()))
| p02936 |
n, q = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(n-1)]
P = [list(map(int,input().split())) for i in range(q)]
ANS = [0] * (n+1)
C_plus = [0] * (n+1)
for i in range(q):
C_plus[P[i][0]] += P[i][1]
oya = [0] * (n+1)
E = [[] for i in range(n+1)]
V = [0] * (n+1)
Q = [1]
t = 0
V[1] = 1
ANS[1] = C_plus[1]
for i in range(n-1):
E[A[i][0]].append(A[i][1])
E[A[i][1]].append(A[i][0])
def tansaku(x):
for i in E[x]:
if V[i] == 0:
oya[i] = x
ANS[i] = C_plus[i] + ANS[x]
V[i] = 1
Q.append(i)
#print(Q)
while t < len(Q):
tansaku(Q[t])
t += 1
#print(ANS)
for i in range(n+1):
ANS[i] = str(ANS[i])
print((" ".join(ANS[1:]))) | n, q = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(n-1)]
P = [list(map(int,input().split())) for i in range(q)]
ANS = [0] * (n+1)
C_plus = [0] * (n+1)
for i in range(q):
C_plus[P[i][0]] += P[i][1]
E = [[] for i in range(n+1)]
V = [0] * (n+1)
Q = [1]
t = 0
V[1] = 1
ANS[1] = C_plus[1]
for i in range(n-1):
E[A[i][0]].append(A[i][1])
E[A[i][1]].append(A[i][0])
def tansaku(x):
for i in E[x]:
if V[i] == 0:
ANS[i] = C_plus[i] + ANS[x]
V[i] = 1
Q.append(i)
#print(Q)
while t < len(Q):
tansaku(Q[t])
t += 1
#print(ANS)
for i in range(n+1):
ANS[i] = str(ANS[i])
print((" ".join(ANS[1:]))) | p02936 |
n, q = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(n-1)]
P = [list(map(int,input().split())) for i in range(q)]
ANS = [0] * (n+1)
C_plus = [0] * (n+1)
for i in range(q):
C_plus[P[i][0]] += P[i][1]
E = [[] for i in range(n+1)]
V = [0] * (n+1)
Q = [1]
t = 0
V[1] = 1
ANS[1] = C_plus[1]
for i in range(n-1):
E[A[i][0]].append(A[i][1])
E[A[i][1]].append(A[i][0])
def tansaku(x):
for i in E[x]:
if V[i] == 0:
ANS[i] = C_plus[i] + ANS[x]
V[i] = 1
Q.append(i)
#print(Q)
while t < len(Q):
tansaku(Q[t])
t += 1
#print(ANS)
for i in range(n+1):
ANS[i] = str(ANS[i])
print((" ".join(ANS[1:]))) | n, q = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(n-1)]
P = [list(map(int,input().split())) for i in range(q)]
ANS = [0] * (n+1)
C_plus = [0] * (n+1)
for i in range(q):
C_plus[P[i][0]] += P[i][1]
E = [[] for i in range(n+1)]
V = [0] * (n+1)
Q = [0] * (n+2)
Q[0] = 1
t = 0
r = 1
V[1] = 1
ANS[1] = C_plus[1]
for i in range(n-1):
E[A[i][0]].append(A[i][1])
E[A[i][1]].append(A[i][0])
def tansaku(x):
global r
for i in E[x]:
if V[i] == 0:
ANS[i] = C_plus[i] + ANS[x]
V[i] = 1
Q[r] = i
r += 1
#print(Q)
while t != r:
tansaku(Q[t])
t += 1
#print(ANS)
for i in range(n+1):
ANS[i] = str(ANS[i])
print((" ".join(ANS[1:]))) | p02936 |
from sys import setrecursionlimit
setrecursionlimit(2 * 10**5) #再帰の回数制限を増やす
def add_num(i, total, parent=-1):
"""隣接リストを取り出して深さ優先探索
自分より上層の total のカウント数と部分木の頂点としてのカウント数を足す"""
for p in adj[i]:
if p != parent:
ans_lst[p] = total + tmp[p]
if adj[p] != [parent]:
add_num(p, total + tmp[p], i)
return
N, Q = [int(i) for i in input().split()]
adj = [[] for _ in range(N)] # 隣接リスト
tmp = [0] * N # 部分木の根としてのカウント数
ans_lst = [0] * N # 答えのリスト
# 隣接リストの作成
for _ in range(N - 1):
a, b = [int(i) - 1 for i in input().split()]
adj[a].append(b)
adj[b].append(a)
# ｔｍｐリストの作成
for _ in range(Q):
p, x = [int(i) for i in input().split()]
tmp[p-1] += x
ans_lst[0] = tmp[0]
total = tmp[0]
add_num(0, total)
print(*ans_lst, sep=' ')
| import sys
sys.setrecursionlimit(10**6) #再帰の回数制限を増やす
input = sys.stdin.readline
def add_num(i, total, parent=-1):
"""隣接リストを取り出して深さ優先探索
自分より上層の total のカウント数と部分木の頂点としてのカウント数を足す"""
for p in adj[i]:
if p != parent:
ans_lst[p] = total + tmp[p]
add_num(p, total + tmp[p], i)
return
N, Q = [int(i) for i in input().split()]
adj = [[] for _ in range(N)] # 隣接リスト
tmp = [0] * N # 部分木の根としてのカウント数
ans_lst = [0] * N # 答えのリスト
# 隣接リストの作成
for _ in range(N - 1):
a, b = [int(i) - 1 for i in input().split()]
adj[a].append(b)
adj[b].append(a)
# ｔｍｐリストの作成
for _ in range(Q):
p, x = [int(i) for i in input().split()]
tmp[p-1] += x
ans_lst[0] = tmp[0]
total = tmp[0]
add_num(0, total)
print(*ans_lst, sep=' ')
| p02936 |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
N,Q = inpl()
lines = defaultdict(set)
for _ in range(N-1):
a,b = inpl()
a,b = a-1,b-1
lines[a].add(b)
lines[b].add(a)
adds = [0]*N
for _ in range(Q):
p,x = inpl()
adds[p-1] += x
visited = [False]*N
ans = [0]*N
q = queue.LifoQueue()
q.put([0,0])
while not q.empty():
x,cnt = q.get()
visited[x] = True
cnt += adds[x]
ans[x] += cnt
for t in lines[x]:
if not visited[t]:
q.put([t,cnt])
print((' '.join(map(str,ans))))
| from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
N,Q = inpl()
lines = defaultdict(set)
for _ in range(N-1):
a,b = inpl()
a,b = a-1,b-1
lines[a].add(b)
adds = [0]*N
for _ in range(Q):
p,x = inpl()
adds[p-1] += x
visited = [False]*N
ans = [0]*N
q = queue.LifoQueue()
q.put([0,0])
while not q.empty():
x,cnt = q.get()
cnt += adds[x]
ans[x] += cnt
for t in lines[x]:
q.put([t,cnt])
print((' '.join(map(str,ans))))
| p02936 |
import sys
sys.setrecursionlimit(10**7)
N,Q=list(map(int,input().split()))
ab=[[] for _ in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
ab[a-1].append(b)
ab[b-1].append(a)
P=[0 for _ in range(N)]
for i in range(Q):
p,x=list(map(int,input().split()))
P[p-1]+=x
def dfs(p,par):
for i in ab[p-1]:
if i!=par:
P[i-1]+=P[p-1]
dfs(i,p)
dfs(1,-12345)
print((" ".join(map(str,P)))) | import sys
sys.setrecursionlimit(10**7)
input=lambda :sys.stdin.readline()
N,Q=list(map(int,input().split()))
ab=[[] for _ in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
ab[a-1].append(b)
ab[b-1].append(a)
P=[0 for _ in range(N)]
for i in range(Q):
p,x=list(map(int,input().split()))
P[p-1]+=x
def dfs(p,par):
for i in ab[p-1]:
if i!=par:
P[i-1]+=P[p-1]
dfs(i,p)
dfs(1,-12345)
print((" ".join(map(str,P)))) | p02936 |
import sys
from collections import defaultdict
sys.setrecursionlimit(100000)
N, Q = map(int, input().split())
neighbor = defaultdict(list)
counter = [0] * N
pcounter = [None] * N
for i in range(N-1):
a, b = map(int, input().split())
neighbor[a-1].append(b-1)
neighbor[b-1].append(a-1)
for i in range(Q):
p, x = map(int, input().split())
counter[p-1] += x
def solve():
stack = [(0, None)]
while stack:
(node, parent) = stack.pop()
pcounter[node] = counter[node]
if parent is not None:
pcounter[node] += pcounter[parent]
for c in neighbor[node]:
if pcounter[c] is None:
stack.append((c, node))
solve()
print(*pcounter, sep=' ')
| import sys
from collections import defaultdict
sys.setrecursionlimit(100000)
N, Q = map(int, input().split())
neighbor = defaultdict(list)
counter = [0] * N
pcounter = [None] * N
depth = {0: 0}
for i in range(N-1):
a, b = map(int, input().split())
a_deper, b_deeper = False, False
if a in depth and b not in depth:
depth[b] = depth[a] + 1
if b in depth and a not in depth:
depth[a] = depth[b] + 1
if a in depth and b in depth:
if depth[a] < depth[b]:
neighbor[a-1].append(b-1)
else:
neighbor[b-1].append(a-1)
else:
neighbor[a-1].append(b-1)
neighbor[b-1].append(a-1)
for i in range(Q):
p, x = map(int, input().split())
counter[p-1] += x
def solve():
stack = [(0, None)]
while stack:
(node, parent) = stack.pop()
pcounter[node] = counter[node]
if parent is not None:
pcounter[node] += pcounter[parent]
for c in neighbor[node]:
if pcounter[c] is None:
stack.append((c, node))
solve()
print(*pcounter, sep=' ')
| p02936 |
n,q=list(map(int,input().split()))
lst=[[] for i in range(n)]
ans=[0]*n
for i in range(n-1):
a,b=list(map(int,input().split()))
lst[a-1].append(b-1)
lst[b-1].append(a-1)
for i in range(q):
s,t=list(map(int,input().split()))
ans[s-1]+=t
Q=[0]
flag=[True]+[False]*(n-1)
while Q:
v=Q.pop(0)
flag[v]=True
for i in lst[v]:
if flag[i]:
continue
flag[i]=True
ans[i]+=ans[v]
Q.append(i)
print((' '.join([str(i) for i in ans])))
| n,q=list(map(int,input().split()))
lst=[[] for i in range(n)]
ans=[0]*n
for i in range(n-1):
a,b=list(map(int,input().split()))
lst[a-1].append(b-1)
lst[b-1].append(a-1)
for i in range(q):
s,t=list(map(int,input().split()))
ans[s-1]+=t
Q=[0]
flag=[True]+[False]*(n-1)
while Q:
v=Q.pop()
flag[v]=True
for i in lst[v]:
if flag[i]:
continue
flag[i]=True
ans[i]+=ans[v]
Q.append(i)
print((' '.join([str(i) for i in ans]))) | p02936 |
import sys
sys.setrecursionlimit(10**6)
n, q = list(map(int, input().split()))
path = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
path[a].append(b)
path[b].append(a)
plus = [0] * (n + 1)
for _ in range(q):
p, x = list(map(int, input().split()))
plus[p] += x
def calc(num, path, plus, parent):
for i in path[num]:
if i == parent:
continue
plus[i] += plus[num]
calc(i, path, plus, num)
calc(1, path, plus, 0)
print((" ".join([str(i) for i in plus[1:]])))
| import sys
sys.setrecursionlimit(10**6)
n, q = list(map(int, sys.stdin.readline().strip().split()))
path = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
path[a].append(b)
path[b].append(a)
plus = [0] * (n + 1)
for _ in range(q):
p, x = list(map(int, sys.stdin.readline().strip().split()))
plus[p] += x
def calc(num, path, plus, parent):
for i in path[num]:
if i == parent:
continue
plus[i] += plus[num]
calc(i, path, plus, num)
calc(1, path, plus, 0)
print((" ".join([str(i) for i in plus[1:]])))
| p02936 |
from collections import defaultdict
import queue
N, Q = list(map(int, input().split()))
adjacent = defaultdict(list)
for i in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
adjacent[a].append(b)
adjacent[b].append(a)
ans = [0] * N
for i in range(Q):
p, x = list(map(int, input().split()))
p -= 1
ans[p] += x
q = queue.Queue()
q.put((0, -1))
while not q.empty():
u, p = q.get()
for v in adjacent[u]:
if v == p:
continue
ans[v] += ans[u]
q.put((v, u))
print((' '.join([str(ans[i]) for i in range(N)])))
| from collections import defaultdict, deque
N, Q = list(map(int, input().split()))
adjacent = defaultdict(list)
for i in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
adjacent[a].append(b)
adjacent[b].append(a)
ans = [0] * N
for i in range(Q):
p, x = list(map(int, input().split()))
p -= 1
ans[p] += x
q = deque([(0, -1)])
while len(q) > 0:
u, p = q.pop()
for v in adjacent[u]:
if v == p:
continue
ans[v] += ans[u]
q.appendleft((v, u))
print((' '.join([str(ans[i]) for i in range(N)])))
| p02936 |
import sys
sys.setrecursionlimit(250000)
from collections import defaultdict
N, Q = list(map(int, input().split()))
nl = [[] for _ in range(N + 1)]
for a, b in [tuple(map(int, input().split())) for _ in range(N - 1)]:
nl[a].append(b)
nl[b].append(a)
val = defaultdict(int)
for p, x in [tuple(map(int, input().split())) for _ in range(Q)]:
val[p] += x
ans = [0 for _ in range(N + 1)]
def dfs(v, p, cnt):
cnt += val[v]
ans[v] = cnt
for next_v in nl[v]:
if next_v != p:
dfs(next_v, v, cnt)
dfs(1, -1, 0)
c = [0 for _ in range(N + 1)]
print((' '.join([str(a) for a in ans[1:]])))
| from collections import defaultdict
N, Q = list(map(int, input().split()))
nl = [[] for _ in range(N + 1)]
for a, b in [tuple(map(int, input().split())) for _ in range(N - 1)]:
nl[a].append(b)
nl[b].append(a)
nl[0].append(1)
val = defaultdict(int)
for p, x in [tuple(map(int, input().split())) for _ in range(Q)]:
val[p] += x
ans = [0 for _ in range(N + 1)]
stack = list()
stack.append((0, -1, 0))
while len(stack) > 0:
v, p, cnt = stack.pop()
cnt += val[v]
ans[v] = cnt
for next_v in nl[v]:
if next_v != p:
stack.append((next_v, v, cnt))
print((' '.join([str(a) for a in ans[1:]])))
| p02936 |
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
import bisect
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
N, Q = list(map(int, input().split()))
info = [[] for _ in range(N)]
ans = [0 for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
info[a - 1].append(b - 1)
info[b - 1].append(a - 1)
def checker(n):
for i in info[n]:
if n in info[i]:
del info[i][info[i].index(n)]
checker(i)
def plus(n, val):
ans[n] += val
for i in info[n]:
plus(i, val + Query[i])
checker(0)
Query = [0 for _ in range(N)]
for _ in range(Q):
p, x = list(map(int, input().split()))
Query[p - 1] += x
plus(0, Query[0])
ans = list(map(str, ans))
print((" ".join(ans)))
| import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
import bisect
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
N, Q = list(map(int, input().split()))
info = [[] for _ in range(N)]
ans = [0 for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
info[a - 1].append(b - 1)
info[b - 1].append(a - 1)
def checker(n, info2):
for i in info[n]:
if n in info2[i]:
continue
else:
info2[n].append(i)
checker(i, info2)
def plus(n, val):
ans[n] += val
for i in info2[n]:
plus(i, val + Query[i])
info2 = [[] for _ in range(N)]
checker(0, info2)
Query = [0 for _ in range(N)]
for _ in range(Q):
p, x = list(map(int, input().split()))
Query[p - 1] += x
plus(0, Query[0])
ans = list(map(str, ans))
print((" ".join(ans)))
| p02936 |
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
import bisect
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
N, Q = list(map(int, input().split()))
info = [[] for _ in range(N)]
ans = [0 for _ in range(N)]
check = [True for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
info[a - 1].append(b - 1)
info[b - 1].append(a - 1)
def plus(n, val):
ans[n] += val
check[n] = False
for i in info[n]:
if check[i]:
plus(i, val + Query[i])
Query = [0 for _ in range(N)]
for _ in range(Q):
p, x = list(map(int, input().split()))
Query[p - 1] += x
plus(0, Query[0])
ans = list(map(str, ans))
print((" ".join(ans)))
| import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
import bisect
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
N, Q = list(map(int, input().split()))
info = [[] for _ in range(N)]
ans = [0 for _ in range(N)]
check = [1 for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
info[a - 1].append(b - 1)
info[b - 1].append(a - 1)
def plus(n, val):
ans[n] += val
check[n] = 0
for i in info[n]:
if check[i]:
plus(i, val + Query[i])
Query = [0 for _ in range(N)]
for _ in range(Q):
p, x = list(map(int, input().split()))
Query[p - 1] += x
plus(0, Query[0])
ans = list(map(str, ans))
print((" ".join(ans)))
| p02936 |
N,Q=list(map(int,input().split()))
ans=[0]*N
ki=[[] for _ in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
ki[a-1].append(b-1)
ki[b-1].append(a-1)
for i in range(Q):
p,q=list(map(int,input().split()))
ans[p-1]+=q
# dfs
stack = [0]
visited = ["False"] * N
while stack:
ne = stack.pop()
if visited[ne] == "False":
visited[ne] = "True"
for j in ki[ne]:
if visited[j] == "False":
ans[j]+=ans[ne]
stack.append(j)
L=[str(a) for a in ans]
L=' '.join(L)
print(L) | import sys
input = sys.stdin.readline
N,Q=list(map(int,input().split()))
ans=[0]*N
ki=[[] for _ in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
ki[a-1].append(b-1)
ki[b-1].append(a-1)
for i in range(Q):
p,q=list(map(int,input().split()))
ans[p-1]+=q
# dfs
stack = [0]
visited = ["False"] * N
while stack:
ne = stack.pop()
if visited[ne] == "False":
visited[ne] = "True"
for j in ki[ne]:
if visited[j] == "False":
ans[j]+=ans[ne]
stack.append(j)
L=[str(a) for a in ans]
L=' '.join(L)
print(L) | p02936 |
#!/usr/bin/env python
from collections import deque
def main():
n, q = list(map(int, input().split()))
link = [[] for _ in range(n+1)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
link[a].append(b)
link[b].append(a)
manip = [list(map(int, input().split())) for _ in range(q)]
child = [[] for _ in range(n+1)]
parent = [0 for _ in range(n+1)]
unchecked = [True for _ in range(n+1)]
unchecked[1] = False
que = deque([1])
while que:
p = que.popleft()
for l in link[p]:
if unchecked[l]:
unchecked[l] = False
child[p].append(l)
parent[l] = p
que.append(l)
cnt = [0 for _ in range(n+1)]
for m in manip:
node, x = m
cnt[node] += x
que = deque([1])
while que:
node = que.pop()
cnt[node] += cnt[parent[node]]
que.extend(child[node])
print((' '.join(map(str, cnt[1:]))))
if __name__ == '__main__':
main()
| #!/usr/bin/env python
from collections import deque
def main():
n, q = list(map(int, input().split()))
link = [[] for _ in range(n+1)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
link[a].append(b)
link[b].append(a)
manip = [list(map(int, input().split())) for _ in range(q)]
cnt = [0 for _ in range(n+1)]
for m in manip:
node, x = m
cnt[node] += x
parent = [0 for _ in range(n+1)]
unchecked = [True for _ in range(n+1)]
unchecked[1] = False
que = deque([1])
while que:
node = que.pop()
for l in link[node]:
if unchecked[l]:
unchecked[l] = False
cnt[l] += cnt[node]
que.append(l)
print((' '.join(map(str, cnt[1:]))))
if __name__ == '__main__':
main()
| p02936 |
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
def s(generator, splitter, mapper):
return [ mapper(s) for s in generator().split(splitter) ]
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(eval(input())) for _ in range(n)]
n,q = get_nums_l()
lines = sys.stdin.readlines()
edges = list([list(map(int, s.split(" "))) for s in lines[:n-1]])
queries = list([list(map(int, s.split(" "))) for s in lines[n-1:]])
scores = [0] * (n+1)
for q in queries:
scores[q[0]] += q[1]
queue = deque()
mark = [False] * (n+1)
mark[1] = True
for e in edges:
queue.append(e)
while queue:
e = queue.popleft()
a = e[0]
b = e[1]
if mark[a]:
scores[b] += scores[a]
mark[b] = True
elif mark[b]:
scores[a] += scores[b]
mark[a] = True
else:
queue.append(e)
print()
print((" ".join(map(str,scores[1:]))))
| import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
def s(generator, splitter, mapper):
return [ mapper(s) for s in generator().split(splitter) ]
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(eval(input())) for _ in range(n)]
n,q = get_nums_l()
lines = sys.stdin.readlines()
edges = list([list(map(int, s.split(" "))) for s in lines[:n-1]])
queries = list([list(map(int, s.split(" "))) for s in lines[n-1:]])
scores = [0] * (n+1)
for q in queries:
scores[q[0]] += q[1]
queue = deque()
mark = [False] * (n+1)
mark[1] = True
childrens = [ [] for _ in range(n+1) ]
for e in edges:
a = e[0]
b = e[1]
childrens[a].append(b)
childrens[b].append(a)
queue.append(1)
while queue:
a = queue.popleft()
children = childrens[a]
for b in children:
if not mark[b]:
scores[b] += scores[a]
mark[b] = True
queue.append(b)
print((" ".join(map(str,scores[1:]))))
| p02936 |
N, Q = list(map(int, input().split()))
E = [[] for _ in range(N)]
C = [0] * N
C[0] = 0
for _ in range(N - 1):
a, b = list(map(int, input().split()))
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
for _ in range(Q):
p, x = list(map(int, input().split()))
C[p - 1] += x
D = [-1] * N
D[0] = 0
Q = [0]
while Q:
q = Q.pop(0)
for adj in E[q]:
if D[adj] >= 0:
continue
D[adj] = D[q] + 1
C[adj] += C[q]
Q.append(adj)
print((' '.join([str(c) for c in C]))) | N, Q = list(map(int, input().split()))
E = [[] for _ in range(N)]
C = [0] * N
C[0] = 0
for _ in range(N - 1):
a, b = list(map(int, input().split()))
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
for _ in range(Q):
p, x = list(map(int, input().split()))
C[p - 1] += x
D = [-1] * N
D[0] = 0
Q = [0] * N
enq = 0
for pos in range(N):
q = Q[pos]
for adj in E[q]:
if D[adj] >= 0:
continue
D[adj] = D[q] + 1
C[adj] += C[q]
enq += 1
Q[enq] = adj
print((' '.join([str(c) for c in C]))) | p02936 |
N,Q=list(map(int, input().split()))
node_lst=[list(map(int, input().split())) for i in range(N-1)]
ope_lst=[list(map(int, input().split())) for i in range(Q)]
cnt_lst=[0 for i in range(N)]
child_rel={}
parent_rel={}
for l in node_lst:
src, dst = l[0], l[1]
if src not in list(child_rel.keys()):
child_rel[src]=[dst]
else:
child_rel[src].append(dst)
if src in list(parent_rel.keys()):
for e in parent_rel[src]:
child_rel[e].append(dst)
if dst not in list(parent_rel.keys()):
parent_rel[dst]=[src]
else:
parent_rel[dst].append(src)
for ope in ope_lst:
p, x = ope[0], ope[1]
cnt_lst[p-1]+=x
if p in list(child_rel.keys()):
for e in child_rel[p]:
cnt_lst[e-1]+=x
print((" ".join([str(c) for c in cnt_lst]))) | N,Q=list(map(int, input().split()))
node_lst=[list(map(int, input().split())) for i in range(N-1)]
ope_lst=[list(map(int, input().split())) for i in range(Q)]
cnt_lst=[0 for i in range(N)]
for ope in ope_lst:
p, x = ope[0], ope[1]
cnt_lst[p-1]+=x
node_lst=sorted(node_lst, key=lambda x:x[0])
for l in node_lst:
src, dst = l[0]-1, l[1]-1
cnt_lst[dst]+=cnt_lst[src]
print((" ".join([str(c) for c in cnt_lst]))) | p02936 |
import sys
sys.setrecursionlimit(10**7)
N, Q = list(map(int,input().split()))
# AB = [[int(x) for x in input().split()] for _ in range(N-1)]
# print(AB)
# 添字を1からにしたいのでN+1
graph = [[] for _ in range(N+1)]
# 各頂点に隣接する頂点
for _ in range(N-1):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
# print(graph)
counter = [0] * (N+1)
# print(counter)
# PX = [[int(x) for x in input().split()] for _ in range(Q)]
# 各頂点に点数を足す
for _ in range(Q):
p, x = list(map(int, input().split()))
counter[p] += x
def shori(pa,c,val):
val += counter[c]
counter[c] = val
for i in graph[c]:
if i == pa:
continue
shori(c,i,val)
shori(0,1,0)
print((" ".join(map(str, counter[1:]))))
| import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
N, Q = list(map(int,input().split()))
# AB = [[int(x) for x in input().split()] for _ in range(N-1)]
# print(AB)
# 添字を1からにしたいのでN+1
graph = [[] for _ in range(N+1)]
# 各頂点に隣接する頂点
for _ in range(N-1):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
# print(graph)
counter = [0] * (N+1)
# print(counter)
# PX = [[int(x) for x in input().split()] for _ in range(Q)]
# 各頂点に点数を足す
for _ in range(Q):
p, x = list(map(int, input().split()))
counter[p] += x
def shori(pa,c,val):
val += counter[c]
counter[c] = val
for i in graph[c]:
if i == pa:
continue
shori(c,i,val)
shori(0,1,0)
print((" ".join(map(str, counter[1:]))))
| p02936 |
N,Q = list(map(int,input().split()))
edges = [[] for i in range(N+1)]
for i in range(N-1):
a,b = list(map(int,input().split()))
edges[a].append(b)
edges[b].append(a)
add = [0]*(N+1)
for i in range(Q):
p,x = list(map(int,input().split()))
add[p] += x
stack = [(1,0)]
ans = [0]*(N+1)
not_checked = [True]*(N+1)
while stack:
v,cnt = stack.pop()
ans[v] = cnt+add[v]
not_checked[v] = False
for edge in edges[v]:
if not_checked[edge]:
stack.append((edge,ans[v]))
for i in range(1,N):
print(ans[i],end=" ")
print(ans[N])
| def main():
N,Q = list(map(int,input().split()))
edges = [[] for i in range(N+1)]
for i in range(N-1):
a,b = list(map(int,input().split()))
edges[a].append(b)
edges[b].append(a)
add = [0]*(N+1)
for i in range(Q):
p,x = list(map(int,input().split()))
add[p] += x
stack = [(1,0)]
ans = [0]*(N+1)
not_checked = [True]*(N+1)
while stack:
v,cnt = stack.pop()
ans[v] = cnt+add[v]
not_checked[v] = False
for edge in edges[v]:
if not_checked[edge]:
stack.append((edge,ans[v]))
for i in range(1,N):
print(ans[i],end=" ")
print(ans[N])
if __name__ == "__main__":
main()
| p02936 |
def main():
N,Q = list(map(int,input().split()))
edges = [[] for i in range(N+1)]
for i in range(N-1):
a,b = list(map(int,input().split()))
edges[a].append(b)
edges[b].append(a)
add = [0]*(N+1)
for i in range(Q):
p,x = list(map(int,input().split()))
add[p] += x
stack = [(1,0)]
ans = [0]*(N+1)
not_checked = [True]*(N+1)
while stack:
v,cnt = stack.pop()
ans[v] = cnt+add[v]
not_checked[v] = False
for edge in edges[v]:
if not_checked[edge]:
stack.append((edge,ans[v]))
for i in range(1,N):
print(ans[i],end=" ")
print(ans[N])
if __name__ == "__main__":
main()
| import sys
def main():
input = sys.stdin.readline
N,Q = list(map(int,input().split()))
edges = [[] for i in range(N+1)]
for i in range(N-1):
a,b = list(map(int,input().split()))
edges[a].append(b)
edges[b].append(a)
add = [0]*(N+1)
for i in range(Q):
p,x = list(map(int,input().split()))
add[p] += x
stack = [(1,0)]
ans = [0]*(N+1)
not_checked = [True]*(N+1)
while stack:
v,cnt = stack.pop()
ans[v] = cnt+add[v]
not_checked[v] = False
for edge in edges[v]:
if not_checked[edge]:
stack.append((edge,ans[v]))
for i in range(1,N):
print(ans[i],end=" ")
print(ans[N])
if __name__ == "__main__":
main()
| p02936 |
import sys
sys.setrecursionlimit(10 ** 6)
class Node(object):
def __init__(self):
self.value = 0
self.children_id = []
def set_child(self, child_id):
self.children_id.append(child_id)
def add_number(self, n):
self.value += n
for child_id in self.children_id:
nodes[child_id].add_number(n)
def get_value(self):
return self.value
N, Q = map(int, sys.stdin.readline().rstrip().split())
nodes = []
for i in range(N + 1):
nodes.append(Node())
for j in range(N - 1):
parent, child = map(int, sys.stdin.readline().rstrip().split())
nodes[parent].set_child(child)
for _ in range(Q):
parent, number = map(int, sys.stdin.readline().rstrip().split())
nodes[parent].add_number(number)
res = []
for k in range(1, N + 1):
res.append(nodes[k].get_value())
print(*res, sep=' ')
| N, Q = map(int, input().split())
nodes = [0 for _ in range(N + 1)]
branches = []
for j in range(N - 1):
parent, child = map(int, input().split())
branches.append([parent, child])
for _ in range(Q):
parent, number = map(int, input().split())
nodes[parent] += number
branches.sort()
for branch in branches:
parent = branch[0]
child = branch[1]
nodes[child] += nodes[parent]
print(*nodes[1:], sep=' ')
| p02936 |
import sys
sys.setrecursionlimit(1000000)
n,q=list(map(int,input().split()))
ki=[[] for i in range(n+1)]
ki[0]="null"
for i in range(n-1):
a,b=list(map(int,input().split()))
ki[a].append(b)
ki[b].append(a)
scores=[0 for i in range(n+1)]
scores[0]="null"
for i in range(q):
p,x=list(map(int,input().split()))
scores[p]+=x
ans=[0 for i in range(n+1)]
ans[0]="null"
point=0
ed=[]
def tansa(n,point):
ed.append(n)
point+=scores[n]
for p in ki[n]:
if not p in ed:
tansa(p,point)
else:
ans[n]=point
tansa(1,0)
ans=ans[1:]
ans=[str(i) for i in ans]
print((" ".join(ans)))
| n,q=list(map(int,input().split()))
L=[[] for i in range(n+1)]
S=[0 for i in range(n+1)]
V=[0 for i in range(n+1)]
for _ in range(n-1):
a,b=list(map(int,input().split()))
L[a].append(b)
L[b].append(a)
for _ in range(q):
p,x=list(map(int,input().split()))
S[p]+=x
que=[1]
head=0
V[1]=1
while len(que)>head:
now=que[head]
head+=1
for nex in L[now]:
if V[nex]==0:
V[nex]=1
que.append(nex)
S[nex]+=S[now]
print((" ".join([str(i) for i in S[1:]]))) | p02936 |
import sys
sys.setrecursionlimit(500000)
N, Q = list(map(int, input().split()))
E = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
E[a].append(b)
E[b].append(a)
C = [0] * (N+1)
for _ in range(Q):
p, x = list(map(int, input().split()))
C[p] += x
Ans = [0] * (N+1)
def dfs(v, p, a):
global ans
a += C[v]
Ans[v] = a
for u in E[v]:
if u!=p:
dfs(u, v, a)
dfs(1, 0, 0)
print((" ".join(map(str, Ans[1:]))))
| import sys
input = sys.stdin.readline
import sys
sys.setrecursionlimit(500000)
N, Q = list(map(int, input().split()))
E = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
E[a].append(b)
E[b].append(a)
C = [0] * (N+1)
for _ in range(Q):
p, x = list(map(int, input().split()))
C[p] += x
Ans = [0] * (N+1)
def dfs(v, p, a):
a += C[v]
Ans[v] = a
for u in E[v]:
if u!=p:
dfs(u, v, a)
dfs(1, 0, 0)
print((" ".join(map(str, Ans[1:]))))
| p02936 |
n,q=list(map(int,input().split()))
a=[0]*(n-1)
b=[0]*(n-1)
for i in range(n-1):
a[i],b[i]=list(map(int,input().split()))
p=[0]*q
x=[0]*q
for k in range(q):
p[k],x[k]=list(map(int,input().split()))
t=[[i] for i in range(1,n+1)]
for i in range(n-1):
if a[i] not in t[a[i]-1]:
t[a[i]-1].append(a[i])
if b[i] not in t[a[i]-1]:
t[a[i]-1].append(b[i])
for i in range(n):
for j in t[i]:
for y in t[j-1]:
if y not in t[i]:
t[i].append(y)
ans=[0 for _ in range(n)]
g=0
for k in p:
for j in t[k-1]:
ans[j-1]+=x[g]
g+=1
print((' '.join(map(str,ans))))
| import sys
input = sys.stdin.readline
n,q=list(map(int,input().split()))
a=[[0,0] for _ in range(n-1)]
for i in range(n-1):
a[i][0],a[i][1]=list(map(int,input().split()))
a.sort()
p=[[0,0] for _ in range(q)]
for k in range(q):
p[k][0],p[k][1]=list(map(int,input().split()))
p.sort()
t=[[i] for i in range(1,n+1)]
ans=[0 for _ in range(n)]
for i in range(q):
ans[p[i][0]-1]+=p[i][1]
for i in range(n-1):
ans[a[i][1]-1]+=ans[a[i][0]-1]
print((' '.join(map(str,ans))))
| p02936 |
import collections
N,Q=map(int,input().split())
lc=[[] for i in range(N)]#二重リストで木を表現
for i in range(N-1):
a,b=map(int,input().split())
lc[a-1].append(b-1)
lc[b-1].append(a-1)
lv=[0 for i in range(N)]#値のリスト
for i in range(Q):
p,x=map(int,input().split())
lv[p-1]+=x
lf=[0 for i in range(N)]#訪れたかどうか
#d=collections.deque([0])
#lp=[0]
lp=collections.deque([0])
lf[0]=1
#for i in range(N):
while len(lp)>0:
#p=lp[-1]
p=lp.pop()
for c in lc[p]:
if lf[c]==0:
lv[c]+=lv[p]
lf[c]=1
lp.append(c)
for i in range(N-1):
print(lv[i],end=" ")
print(lv[N-1])
| import collections
N,Q=map(int,input().split())
lc=[[] for i in range(N)]#二重リストで木を表現
for i in range(N-1):
a,b=map(int,input().split())
lc[a-1].append(b-1)
lc[b-1].append(a-1)
lv=[0 for i in range(N)]#値のリスト
for i in range(Q):
p,x=map(int,input().split())
lv[p-1]+=x
lf=[0 for i in range(N)]#訪れたかどうか
#d=collections.deque([0])
#lp=[0]
lp=collections.deque([0])
lf[0]=1
#for i in range(N):
while len(lp)>0:
#p=lp[-1]
#p=lp.pop()
p=lp.popleft()
for c in lc[p]:
if lf[c]==0:
lv[c]+=lv[p]
lf[c]=1
lp.append(c)
for i in range(N-1):
print(lv[i],end=" ")
print(lv[N-1])
#スタックだとリストかデキューかは関係ない
| p02936 |
N,Q=list(map(int,input().split()))
ans=[0]*N
ab=[[] for i in range(N)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
ab[a-1].append(b-1)
for j,item in enumerate(ab[::-1]):
for i in item:
ab[N-j-1].extend(ab[i])
#for i in range(N):
# ab[i]=list(set(ab[i]))
for _ in range(Q):
p,x=list(map(int,input().split()))
for i in ab[p-1]:
ans[i]=ans[i]+x
ans[p-1]=ans[p-1]+x
# print(ans)
print((str(''.join(str(j)+' ' for j in ans)[:-1]))) |
N,Q=list(map(int,input().split()))
ans=[0]*N
ab=[[] for i in range(N)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
ab[a-1].append(b-1)
px=[]
for _ in range(Q):
px.append(list(map(int,input().split())))
for j,item in enumerate(ab[::-1]):
for i in item:
ab[N-j-1].extend(ab[i])
#for i in range(N):
# ab[i]=list(set(ab[i]))
for ppxx in px:
p,x=ppxx
for i in ab[p-1]:
ans[i]=ans[i]+x
ans[p-1]=ans[p-1]+x
# print(ans)
print((str(''.join(str(j)+' ' for j in ans)[:-1]))) | p02936 |
#!/usr/bin/env python
# coding: utf-8
# In[17]:
#from sys import stdin
#input = stdin.readline
N, Q = list(map(int, input().split()))
# In[18]:
class Node:
def __init__(self, nb, data): #コンストラクタ
self.nb = nb
self.data = data #ノードがもつ数値
self.parent = -1 # nodeがrootのとき-1、それ以外番号
self.childs = [] # childになるnode classが入る
def connect_childs(self, child_class_):
self.childs.append(child_class_)
# In[19]:
nodes = [Node(_+1, 0) for _ in range(N)]
# In[12]:
for i in range(N-1):
a, b = list(map(int, input().split()))
nodes[a-1].connect_childs(nodes[b-1])
nodes[b-1].parent = a-1
# In[13]:
for i in range(Q):
p, x = list(map(int, input().split()))
nodes[p-1].data += x
# In[14]:
def sum_data_to_childs(nodes):
datas = [0]*N
datas[0] = nodes[0].data
for i in range(1, N):
nodes[i].data += nodes[nodes[i].parent].data
#print(nodes[i].data)
datas[i] = nodes[i].data
return datas
# In[15]:
datas = sum_data_to_childs(nodes)
# In[16]:
print((' '.join(map(str, datas))))
# In[ ]:
| #!/usr/bin/env python
# coding: utf-8
# In[17]:
from sys import stdin
input = stdin.readline
N, Q = list(map(int, input().split()))
# In[18]:
class Node:
def __init__(self, nb, data): #コンストラクタ
self.nb = nb
self.data = data #ノードがもつ数値
self.parent = -1 # nodeがrootのとき-1、それ以外番号
#self.childs = [] # childになるnode classが入る
#def connect_childs(self, child_class_):
# self.childs.append(child_class_)
# In[19]:
nodes = [Node(_+1, 0) for _ in range(N)]
# In[12]:
for i in range(N-1):
a, b = list(map(int, input().split()))
#nodes[a-1].connect_childs(nodes[b-1])
nodes[b-1].parent = a-1
# In[13]:
for i in range(Q):
p, x = list(map(int, input().split()))
nodes[p-1].data += x
# In[14]:
def sum_data_to_childs(nodes):
datas = [0]*N
datas[0] = nodes[0].data
for i in range(1, N):
nodes[i].data += nodes[nodes[i].parent].data
#print(nodes[i].data)
datas[i] = nodes[i].data
return datas
# In[15]:
datas = sum_data_to_childs(nodes)
# In[16]:
print((' '.join(map(str, datas))))
# In[20]:
#datas = [0] * N
# In[21]:
#child = [[]] * N
# In[22]:
#print(child)
# In[ ]:
| p02936 |
import sys
import queue
#+++++
def main():
n,q = list(map(int, input().split()))
tree=[[] for _ in range(n+1)]
hh=[ 0 for _ in range(n+1)]
ret=[0 for _ in range(n+1)]
for i in range(n-1):
pa,ch = list(map(int, input().split()))
tree[pa].append(ch)
for v in range(q):
nd, hv = list(map(int, input().split()))
hh[nd] += hv
ol = queue.Queue(n+1)
ret[1]=hh[1]
vv=hh[1]
for cc in tree[1]:
ol.put((vv,cc))
while not ol.empty():
ph,nd=ol.get()
ret[nd]=hh[nd]+ph
vv=ret[nd]
for cc in tree[nd]:
ol.put((vv,cc))
print((' '.join([str(v) for v in ret[1:]])))
#+++++
if __name__ == "__main__":
if sys.platform =='ios':
sys.stdin=open('inputFile.txt')
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | import sys
import queue
#+++++
def main():
n,q = list(map(int, input().split()))
tree=[[] for _ in range(n+1)]
hh=[0 for _ in range(n+1)]
ret=[0 for _ in range(n+1)]
for i in range(n-1):
pa,ch = list(map(int, input().split()))
tree[pa].append(ch)
for v in range(q):
nd, hv = list(map(int, input().split()))
hh[nd] += hv
ol = queue.Queue(n+1)
ret[1]=hh[1]
vv=hh[1]
for cc in tree[1]:
ol.put((vv,cc))
while not ol.empty():
ph,nd=ol.get()
ret[nd]=hh[nd]+ph
vv=ret[nd]
for cc in tree[nd]:
ol.put((vv,cc))
rets=' '.join([str(v) for v in ret[1:]])
print(rets)
#+++++
if __name__ == "__main__":
if sys.platform =='ios':
sys.stdin=open('inputFile.txt')
else:
pass
input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | p02936 |
a,b=map(int,input().split())
y=[]
for i in range(a-1):
v=list(map(int,input().split()))
y.append(v)
y.sort(key=lambda net:net[0])
ans=[0]*a
for j in range(b):
c,d=map(int,input().split())
ans[c-1]=ans[c-1]+d
for k in range(a-1):
yy=y[k][0]-1
zz=y[k][1]-1
ans[zz]=ans[zz]+ans[yy]
print(*ans,sep=" ")
| a,b=map(int,input().split())
y=[]
for i in range(a-1):
v=list(map(int,input().split()))
y.append(v)
y.sort(key=lambda n:n[0])
ans=[0]*a
for j in range(b):
c,d=map(int,input().split())
ans[c-1]=ans[c-1]+d
for k in range(a-1):
ans[y[k][1]-1]=ans[y[k][1]-1]+ans[y[k][0]-1]
print(*ans,sep=" ")
| p02936 |
N, Q = map(int, input().split())
to = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
to[a].append(b)
to[b].append(a)
queue = [0]
branch = [[i] for i in range(N)]
parent = [[] for _ in range(N)]
while len(queue) > 0:
q = queue.pop(0)
for br in to[q]:
branch[q].append(br)
to[br].remove(q)
parent[br].append(q)
for p in parent[q]:
parent[br].append(p)
queue.append(br)
for i in range(1, N):
for p in parent[i]:
if not i in branch[p]:
branch[p].append(i)
cnt = [0 for _ in range(N)]
for _ in range(Q):
p, x = map(int, input().split())
p -= 1
for b in branch[p]:
cnt[b] += x
for i in range(N):
print(cnt[i], end = "")
if i == N - 1:
print()
else:
print(" ", end = "")
| N, Q = map(int, input().split())
to = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
to[a].append(b)
to[b].append(a)
queue = [0]
parent = [[] for _ in range(N)]
while len(queue) > 0:
q = queue.pop(0)
for br in to[q]:
to[br].remove(q)
parent[br].append(q)
queue.append(br)
cnt = [0 for _ in range(N)]
for _ in range(Q):
p, x = map(int, input().split())
p -= 1
cnt[p] += x
queue = [0]
while len(queue) > 0:
q = queue.pop(0)
if q != 0:
cnt[q] += cnt[parent[q][0]]
for br in to[q]:
queue.append(br)
for i in range(N):
print(cnt[i], end = "")
if i == N - 1:
print()
else:
print(" ", end = "")
| p02936 |
from collections import deque
n, q = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
edge[a].append(b)
edge[b].append(a)
imos = [0] * n
for i in range(q):
p, x = list(map(int, input().split()))
p -= 1
imos[p] += x
q = deque([(0, -1)])
while q:
v, p = q.pop()
for u in edge[v]:
if u == p:
continue
imos[u] += imos[v]
q.append((u, v))
print((' '.join([str(x) for x in imos])))
| import sys
from collections import deque
input = sys.stdin.readline
n, q = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
edge[a].append(b)
edge[b].append(a)
imos = [0] * n
for i in range(q):
p, x = list(map(int, input().split()))
p -= 1
imos[p] += x
q = deque([(0, -1)])
while q:
v, p = q.pop()
for u in edge[v]:
if u == p:
continue
imos[u] += imos[v]
q.append((u, v))
print((' '.join([str(x) for x in imos])))
| p02936 |
from collections import deque
def main():
n,q=map(int,input().split())
node=[[]*n for i in range(n)]
for i in range(n-1):
a,b=map(lambda x:int(x)-1,input().split())
node[b].append(a)
node[a].append(b)
ans=[0]*n
for i in range(q):
p,x=map(int,input().split())
p-=1
ans[p]+=x
root=[0]*n
edge=[[]*n for i in range(n)]
root[0]=0
q=deque([0])
visited=[False]*n
visited[0]=True
while q:
r=q.popleft()
for e in node[r]:
if not visited[e]:
visited[e]=True
q.append(e)
root[e]=r
edge[r].append(e)
p=[0]*n
q=deque(edge[0])
visited=[False]*n
while q:
e=q.popleft()
p[e]=p[root[e]]+1
for e2 in edge[e]:
if not visited[e2]:
visited[e2]=True
q.append(e2)
p=sorted(enumerate(p), key=lambda x:x[1])
for i in range(1,n):
e=p[i][0]
r=root[e]
ans[e]+=ans[r]
print(*ans,sep=' ')
if __name__=='__main__':
main()
| import sys
sys.setrecursionlimit(2*10**5+5)
def dfs(_v, _u):
for u in v[_v]:
if u==_u: continue;
ans[u]+=ans[_v]
dfs(u, _v)
def main():
for i in range(n-1):
a,b=map(lambda x:int(x)-1, input().split())
v[a].append(b)
v[b].append(a)
for i in range(q):
p,x=map(lambda x:int(x)-1, input().split())
ans[p]+=x+1
dfs(0,-1)
print(*ans, sep=' ')
if __name__=='__main__':
n,q=map(int,input().split())
ans=[0]*n
v=[[]*n for i in range(n)]
main()
| p02936 |
import queue
N,Q = list(map(int,input().split()))
Ki_p = [0 for i in range(N+1)]
Ki_c = [[] for i in range(N+1)]
Ki_co = [0 for i in range(N+1)]
for i in range(N-1):
a,b = list(map(int,input().split()))
Ki_p[b] = a
Ki_c[a] += [b]
for i in range(Q):
p,x = list(map(int,input().split()))
Ki_co[p] += x
ans = [0 for i in range(N+1)]
q = queue.Queue()
q.put(1)
while not q.empty():
vi = q.get()
ans[vi] = Ki_co[vi] + ans[Ki_p[vi]]
for a in Ki_c[vi]:
q.put(a)
print((' '.join(map(str,ans[1:N+1])))) | N,Q = list(map(int,input().split()))
Ki_p = [0 for i in range(N+1)]
Ki_c = [[] for i in range(N+1)]
Ki_co = [0 for i in range(N+1)]
for i in range(N-1):
a,b = list(map(int,input().split()))
Ki_p[b] = a
Ki_c[a] += [b]
for i in range(Q):
p,x = list(map(int,input().split()))
Ki_co[p] += x
ans = [0 for i in range(N+1)]
q = {1}
for i in range(N):
vi = q.pop()
ans[vi] = Ki_co[vi] + ans[Ki_p[vi]]
q |= set(Ki_c[vi])
print((' '.join(map(str,ans[1:N+1])))) | p02936 |
import sys
sys.setrecursionlimit(5 * 10**5)
N, Q = list(map(int, input().split()))
M = [[0] * N for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
M[a-1][b-1] = M[b-1][a-1] = 1
X = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
X[p-1] += x
ans = [0] * N
def setAnswer(parent, number, value):
ans[number] = value
for i in range(N):
if i != parent and M[number][i] == 1:
setAnswer(number, i, value + X[i])
setAnswer(0, 0, X[0])
print((' '.join(map(str, ans))))
| import sys
sys.setrecursionlimit(5 * 10**5)
N, Q = list(map(int, input().split()))
M = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
M[a-1].append(b-1)
M[b-1].append(a-1)
X = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
X[p-1] += x
ans = [0] * N
def setAnswer(parent, number, value):
ans[number] = value
for i in M[number]:
if i != parent:
setAnswer(number, i, value + X[i])
setAnswer(0, 0, X[0])
print((' '.join(map(str, ans))))
| p02936 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.