input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
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)
ans = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
def setAnswer(parent, number):
ans[number] += ans[parent]
for i in M[number]:
if i != parent:
setAnswer(number, i)
ans.append(0)
setAnswer(N, 0)
ans.pop(N)
print((' '.join(map(str, ans))))
| import sys
sys.setrecursionlimit(5 * 10**5)
input=sys.stdin.readline
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)
ans = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
def setAnswer(parent, number):
ans[number] += ans[parent]
for i in M[number]:
if i != parent:
setAnswer(number, i)
ans.append(0)
setAnswer(N, 0)
ans.pop(N)
print((' '.join(map(str, ans))))
| p02936 |
import sys
sys.setrecursionlimit(5 * 10**5)
input=sys.stdin.readline
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)))) | import sys
sys.setrecursionlimit(5 * 10**5)
input=sys.stdin.readline
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)
ans = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
def setAnswer(parent, number):
ans[number] += ans[parent]
for i in M[number]:
if i != parent:
setAnswer(number, i)
for i in M[0]:
setAnswer(0, i)
print((' '.join(map(str, ans))))
| p02936 |
import sys
from collections import deque
sys.setrecursionlimit(5 * 10**5)
input=sys.stdin.readline
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)
ans = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
Q = deque([0])
while Q:
current = Q.pop()
for i in M[current]:
ans[i] += ans[current]
M[i].remove(current)
Q.append(i)
print((' '.join(map(str, ans))))
| import sys
sys.setrecursionlimit(5 * 10**5)
input=sys.stdin.readline
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)
ans = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
Q = [0]
while Q:
current = Q.pop()
for i in M[current]:
ans[i] += ans[current]
M[i].remove(current)
Q.append(i)
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
def dfs(v,parent,add):
value[v] += add
for x in graph[v]:
if x == parent:
continue
dfs(x,v,value[v])
dfs(1,0,0)
answer = ' '.join(map(str,value[1:]))
print(answer)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
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)]
g = [[] for _ in range(N+1)]
for a,b in AB:
g[a].append(b)
g[b].append(a)
cnt = [0] * (N+1)
for p,x in PX:
cnt[p] += x
def dfs(v, p, add):
cnt[v] += add
for nv in g[v]:
if nv == p:
continue
dfs(nv, v, cnt[v])
dfs(1, 0, 0)
print((' '.join(map(str, cnt[1:])))) | p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
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)]
g = [[] for _ in range(N+1)]
for a,b in AB:
g[a].append(b)
g[b].append(a)
cnt = [0] * (N+1)
for p,x in PX:
cnt[p] += x
def dfs(v, p, add):
cnt[v] += add
for nv in g[v]:
if nv == p:
continue
dfs(nv, v, cnt[v])
dfs(1, 0, 0)
print((' '.join(map(str, cnt[1:])))) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, Q = list(map(int, input().split()))
g = [[] for _ in range(N+1)]
for i in range(N-1):
a, b = list(map(int, input().split()))
g[a].append(b)
g[b].append(a)
cnt = [0] * (N+1)
for i in range(Q):
p, x = list(map(int, input().split()))
cnt[p] += x
def dfs(v, p, add):
cnt[v] += add
for nv in g[v]:
if nv == p:
continue
dfs(nv, v, cnt[v])
dfs(1, 0, 0)
print((' '.join(map(str, cnt[1:])))) | p02936 |
import sys
sys.setrecursionlimit(10**6)
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
P = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
P[p-1] += x
ans = [-1] * N
#print(G)
#print(P)
def dfs(v, p):
ans[v] = P[v] + p
for vi in G[v]:
if ans[vi] != -1:
continue
dfs(vi, ans[v])
dfs(0, 0)
print((' '.join(map(str, ans))))
| import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
P = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
P[p-1] += x
ans = [-1] * N
#print(G)
#print(P)
def dfs(v, p):
ans[v] = P[v] + p
for vi in G[v]:
if ans[vi] != -1:
continue
dfs(vi, ans[v])
dfs(0, 0)
print((' '.join(map(str, ans))))
| p02936 |
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
int1 = lambda x: int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def printlist(lst, k='\n'): print((k.join(list(map(str, lst)))))
INF = float('inf')
from collections import deque
def solve():
n, q = MI()
e = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = MI1()
e[a].append(b)
e[b].append(a)
point = [0] * n
for _ in range(q):
p, x = MI()
p -= 1
point[p] += x
d = deque([(0, point[0])])
used = [0] * n
used[0] = 1
l = 1
while l > 0:
v, p = d.popleft()
l -= 1
for nv in e[v]:
if used[nv]: continue
used[nv] = 1
point[nv] += p
d.append((nv, point[nv]))
l += 1
printlist(point, " ")
if __name__ == '__main__':
solve()
| import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline ####
int1 = lambda x: int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def printlist(lst, k='\n'): print((k.join(list(map(str, lst)))))
INF = float('inf')
from collections import deque
def solve():
n, q = MI()
e = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = MI1()
e[a].append(b)
e[b].append(a)
point = [0] * n
for _ in range(q):
p, x = MI()
p -= 1
point[p] += x
d = deque([(0, point[0])])
used = [0] * n
used[0] = 1
l = 1
while l > 0:
v, p = d.popleft()
l -= 1
for nv in e[v]:
if used[nv]: continue
used[nv] = 1
point[nv] += p
d.append((nv, point[nv]))
l += 1
printlist(point, " ")
if __name__ == '__main__':
solve()
| p02936 |
import sys
sys.setrecursionlimit(1000000)
n, q = [int(i) for i in input().split()]
ab = [[] for _ in range(n)]
for _ in range(n - 1):
i, j = [int(i)-1 for i in input().split()]
ab[i].append(j)
ab[j].append(i)
p = [0]*n
for _ in range(q):
i, j = [int(i) for i in input().split()]
p[i-1] += j
al = [False]*n
pp = [0]*n
def a(i=0, j=0):
al[i] = True
j += p[i]
pp[i] = str(j)
for k in ab[i]:
if not al[k]:
a(k, j)
a()
print((" ".join(pp)))
| import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n, q = [int(i) for i in input().split()]
ab = [[] for _ in range(n)]
for _ in range(n - 1):
i, j = [int(i)-1 for i in input().split()]
ab[i].append(j)
ab[j].append(i)
p = [0]*n
for _ in range(q):
i, j = [int(i) for i in input().split()]
p[i-1] += j
al = [False]*n
pp = [0]*n
def a(i=0, j=0):
al[i] = True
j += p[i]
pp[i] = str(j)
for k in ab[i]:
if not al[k]:
a(k, j)
a()
print((" ".join(pp)))
| p02936 |
import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n, q = [int(i) for i in input().split()]
e = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = [int(i) - 1 for i in input().split()]
e[a].append(b)
e[b].append(a)
p = [0] * n
for _ in range(q):
pp, x = [int(i) for i in input().split()]
p[pp - 1] += x
def dfs(i=0, r=-1, po=0):
p[i] += po
for j in e[i]:
if j == r:
continue
dfs(j, i,p[i])
dfs()
print((" ".join(map(str,p)))) | import sys
sys.setrecursionlimit(1000000)
n, q = [int(i) for i in input().split()]
e = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = [int(i) - 1 for i in input().split()]
e[a].append(b)
e[b].append(a)
p = [0] * n
for _ in range(q):
pp, x = [int(i) for i in input().split()]
p[pp - 1] += x
def dfs(i=0, r=-1, po=0):
p[i] += po
for j in e[i]:
if j == r:
continue
dfs(j, i,p[i])
dfs()
print((" ".join(map(str,p))))
| p02936 |
import sys
sys.setrecursionlimit(10**7)
from collections import deque
seen=[]
#seen=dict()
path=[]
def dfs(g, v,add):
xx[v]+=add
# path.append(v)
seen[v]=True
for next_v in g[v]:
if seen[next_v]:
continue
dfs(g, next_v,xx[v])
# path.append(v)
return
icase=-1
if icase==-1:
n,q=list(map(int,input().split()))
# g = [deque([]) for _ in range(n)]
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)]
g = [set() for _ in range(n)]
for ai,bi in ab:
g[ai-1].add(bi-1)
g[bi-1].add(ai-1)
g=tuple(g)
xx=[0]*n
for pi,xi in px:
xx[pi-1]=xx[pi-1]+xi
if icase==0:
n,q=list(map(int,input().split()))
# g = [deque([]) for _ in range(n)]
g = [set() for _ in range(n)]
for i in range(n-1):
ai,bi=list(map(int,input().split()))
# g[ai-1].append(bi-1)
# g[bi-1].append(ai-1)
g[ai-1].add(bi-1)
g[bi-1].add(ai-1)
g=tuple(g)
xx=[0]*n
for i in range(q):
pi,xi=list(map(int,input().split()))
xx[pi-1]=xx[pi-1]+xi
elif icase==3:
n,q=6,2
g = [deque([]) for _ in range(n)]
g[0]=deque([1,2])
g[1]=deque([0,3,4])
g[2]=deque([0,5])
g[3]=deque([1])
g[4]=deque([1])
g[5]=deque([2])
p=[0]*q
x=[0]*q
p[0]=0
x[0]=10
p[1]=0
x[1]=10
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
elif icase==1:
n,q=3,3
g = [deque([]) for _ in range(n)]
g[0]=deque([2])
g[1]=deque([2])
g[2]=deque([0,1])
p=[0]*q
x=[0]*q
p[0]=1
x[0]=10
p[1]=2
x[1]=100
p[2]=0
x[2]=1
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
#ans:1 111 101
elif icase==2:
n,q=4,3
g = [deque([]) for _ in range(n)]
g[0]=deque([1])
g[1]=deque([0,2,3])
g[2]=deque([1])
g[3]=deque([1])
p=[0]*q
x=[0]*q
p[0]=1
x[0]=10
p[1]=0
x[1]=100
p[2]=2
x[2]=1
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
#ans:100 110 111 110
#c=[0]*n
seen=[False]*n
#for i in range(n):
# seen[i]=False
dfs(g,0,0)
#print(path)
'''
seen=[False]*n
c=[0]*n
cpt=0
for pt in path:
if seen[pt]==False:
seen[pt]=True
# print("pt:",pt,"cpt:",cpt,"xx[pt]:",xx[pt],"c[pt]:",c[pt]+cpt+xx[pt])
cpt=cpt+xx[pt]
c[pt]=c[pt]+cpt
else:
seen[pt]=False
cpt=cpt-xx[pt]
for i in range(n):
print(c[i],end=" ")
print()
'''
ans=" ".join(map(str,xx[0:]))
print(ans)
| import sys
sys.setrecursionlimit(10**7)
from collections import deque
input = sys.stdin.readline
seen=[]
#seen=dict()
path=[]
def dfs(g, v,add):
xx[v]+=add
# path.append(v)
seen[v]=True
for next_v in g[v]:
if seen[next_v]:
continue
dfs(g, next_v,xx[v])
# path.append(v)
return
icase=-1
if icase==-1:
n,q=list(map(int,input().split()))
# g = [deque([]) for _ in range(n)]
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)]
g = [set() for _ in range(n)]
for ai,bi in ab:
g[ai-1].add(bi-1)
g[bi-1].add(ai-1)
g=tuple(g)
xx=[0]*n
for pi,xi in px:
xx[pi-1]=xx[pi-1]+xi
if icase==0:
n,q=list(map(int,input().split()))
# g = [deque([]) for _ in range(n)]
g = [set() for _ in range(n)]
for i in range(n-1):
ai,bi=list(map(int,input().split()))
# g[ai-1].append(bi-1)
# g[bi-1].append(ai-1)
g[ai-1].add(bi-1)
g[bi-1].add(ai-1)
g=tuple(g)
xx=[0]*n
for i in range(q):
pi,xi=list(map(int,input().split()))
xx[pi-1]=xx[pi-1]+xi
elif icase==3:
n,q=6,2
g = [deque([]) for _ in range(n)]
g[0]=deque([1,2])
g[1]=deque([0,3,4])
g[2]=deque([0,5])
g[3]=deque([1])
g[4]=deque([1])
g[5]=deque([2])
p=[0]*q
x=[0]*q
p[0]=0
x[0]=10
p[1]=0
x[1]=10
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
elif icase==1:
n,q=3,3
g = [deque([]) for _ in range(n)]
g[0]=deque([2])
g[1]=deque([2])
g[2]=deque([0,1])
p=[0]*q
x=[0]*q
p[0]=1
x[0]=10
p[1]=2
x[1]=100
p[2]=0
x[2]=1
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
#ans:1 111 101
elif icase==2:
n,q=4,3
g = [deque([]) for _ in range(n)]
g[0]=deque([1])
g[1]=deque([0,2,3])
g[2]=deque([1])
g[3]=deque([1])
p=[0]*q
x=[0]*q
p[0]=1
x[0]=10
p[1]=0
x[1]=100
p[2]=2
x[2]=1
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
#ans:100 110 111 110
#c=[0]*n
seen=[False]*n
#for i in range(n):
# seen[i]=False
dfs(g,0,0)
#print(path)
'''
seen=[False]*n
c=[0]*n
cpt=0
for pt in path:
if seen[pt]==False:
seen[pt]=True
# print("pt:",pt,"cpt:",cpt,"xx[pt]:",xx[pt],"c[pt]:",c[pt]+cpt+xx[pt])
cpt=cpt+xx[pt]
c[pt]=c[pt]+cpt
else:
seen[pt]=False
cpt=cpt-xx[pt]
for i in range(n):
print(c[i],end=" ")
print()
'''
ans=" ".join(map(str,xx[0:]))
print(ans)
| p02936 |
import sys
sys.setrecursionlimit(10**7)
from collections import deque
input = sys.stdin.readline
seen=[]
#seen=dict()
path=[]
def dfs(g, v,add):
xx[v]+=add
# path.append(v)
seen[v]=True
for next_v in g[v]:
if seen[next_v]:
continue
dfs(g, next_v,xx[v])
# path.append(v)
return
icase=0
if icase==0:
n,q=list(map(int,input().split()))
# g = [deque([]) for _ in range(n)]
g = [set() for _ in range(n)]
for i in range(n-1):
ai,bi=list(map(int,input().split()))
# g[ai-1].append(bi-1)
# g[bi-1].append(ai-1)
g[ai-1].add(bi-1)
g[bi-1].add(ai-1)
g=tuple(g)
xx=[0]*n
for i in range(q):
pi,xi=list(map(int,input().split()))
xx[pi-1]=xx[pi-1]+xi
elif icase==3:
n,q=6,2
g = [deque([]) for _ in range(n)]
g[0]=deque([1,2])
g[1]=deque([0,3,4])
g[2]=deque([0,5])
g[3]=deque([1])
g[4]=deque([1])
g[5]=deque([2])
p=[0]*q
x=[0]*q
p[0]=0
x[0]=10
p[1]=0
x[1]=10
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
elif icase==1:
n,q=3,3
g = [deque([]) for _ in range(n)]
g[0]=deque([2])
g[1]=deque([2])
g[2]=deque([0,1])
p=[0]*q
x=[0]*q
p[0]=1
x[0]=10
p[1]=2
x[1]=100
p[2]=0
x[2]=1
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
#ans:1 111 101
elif icase==2:
n,q=4,3
g = [deque([]) for _ in range(n)]
g[0]=deque([1])
g[1]=deque([0,2,3])
g[2]=deque([1])
g[3]=deque([1])
p=[0]*q
x=[0]*q
p[0]=1
x[0]=10
p[1]=0
x[1]=100
p[2]=2
x[2]=1
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
#ans:100 110 111 110
#c=[0]*n
seen=[False]*n
#for i in range(n):
# seen[i]=False
dfs(g,0,0)
#print(path)
'''
seen=[False]*n
c=[0]*n
cpt=0
for pt in path:
if seen[pt]==False:
seen[pt]=True
# print("pt:",pt,"cpt:",cpt,"xx[pt]:",xx[pt],"c[pt]:",c[pt]+cpt+xx[pt])
cpt=cpt+xx[pt]
c[pt]=c[pt]+cpt
else:
seen[pt]=False
cpt=cpt-xx[pt]
for i in range(n):
print(c[i],end=" ")
print()
'''
ans=" ".join(map(str,xx[0:]))
print(ans)
|
from collections import deque
icase=0
if icase==0:
n,q=list(map(int,input().split()))
g = [set() for _ in range(n)]
for i in range(n-1):
ai,bi=list(map(int,input().split()))
g[ai-1].add(bi-1)
g[bi-1].add(ai-1)
g=tuple(g)
xx=[0]*n
for i in range(q):
pi,xi=list(map(int,input().split()))
xx[pi-1]=xx[pi-1]+xi
elif icase==2:
n,q=4,3
g = [deque([]) for _ in range(n)]
g[0]=deque([1])
g[1]=deque([0,2,3])
g[2]=deque([1])
g[3]=deque([1])
p=[0]*q
x=[0]*q
p[0]=1
x[0]=10
p[1]=0
x[1]=100
p[2]=2
x[2]=1
xx=[0]*n
for i in range(q):
xx[p[i]]=xx[p[i]]+x[i]
#ans:100 110 111 110
elif icase==3:
n,q=6,2
g = [deque([]) for _ in range(n)]
g[0]=deque([1,2])
g[1]=deque([0,3,4])
g[2]=deque([0,5])
g[3]=deque([1])
g[4]=deque([1])
g[5]=deque([2])
p=[0]*q
x=[0]*q
p[0]=0
x[0]=10
p[1]=0
x[1]=10
xx=[0]*n
for i in range(q):
# pi,xi=map(int,input().split())
xx[p[i]]=xx[p[i]]+x[i]
#q = deque([0])
stack=[0]
parent=[-1]*n
while stack:
# print(q)
state = stack.pop()
# print("------------- stack:",stack,"state:",state,"g:",g[state])
for v in g[state]:
# print("state:",state,"v:",v,"q:",q)
if parent[state] == v:
continue
else:
parent[v]=state
stack.append(v)
xx[v]+=xx[state]
# print("parent:",parent,"xx:",xx,"stack",stack)
print((" ".join(map(str,xx[0: ]))))
| p02936 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dfs(x):
fx = f[x]
for y in v[x]:
if d[y]:
d[y] = 0
f[y] += fx
dfs(y)
n,q = LI()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
f = [0]*n
for i in range(q):
p,x = LI()
p -= 1
f[p] += x
d = [1]*n
d[0] = 0
dfs(0)
print(*f,sep=" ")
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dfs(x):
fx = f[x]
for y in v[x]:
if d[y]:
d[y] = 0
f[y] += fx
dfs(y)
n,q = LI()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
f = [0]*n
for i in range(q):
p,x = LI()
p -= 1
f[p] += x
d = [1]*n
d[0] = 0
q = deque([0])
while q:
x = q.popleft()
fx = f[x]
for y in v[x]:
if d[y]:
d[y] = 0
f[y] += fx
q.append(y)
print(*f,sep=" ")
return
#Solve
if __name__ == "__main__":
solve()
| p02936 |
import sys
from collections import deque
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return list(map(int, input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def main():
N, Q = MI()
#木
tree = [[]]*N
visit = [True]*N
for i in range(N-1):
a,b = MI()
if len(tree[a-1]) == 0:
tree[a-1] = [b-1]
tree[b-1] = [a-1]
else:
tree[a-1].append(b-1)
tree[b-1].append(a-1)
#カウンター保存用、初期化
counter = [0]* N
score = [0]* N
dq = deque([0])
visit[0] = False
for i in range(Q):
p, x = MI()
counter[p-1] += x
score[0] = counter[0]
while dq:
temp = dq.pop()
for num in tree[temp]:
if visit[num]:
score[num] = score[temp]+counter[num]
dq.append(num)
visit[num] = False
score = [str(i) for i in score]
print((" ".join(score)))
return None
if __name__ == "__main__":
main() | import sys
from collections import deque
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return list(map(int, input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def main():
N, Q = MI()
#木
tree = [[] for i in range(N)]
for i in range(N-1):
a,b = MI()
tree[a-1].append(b-1)
tree[b-1].append(a-1)
#カウンター保存用、初期化
counter = [0]* N
score = [0]* N
dq = deque()
dq.append([0,-1])
for i in range(Q):
p, x = MI()
counter[p-1] += x
score[0] = counter[0]
#score[tree[0][0]] = counter[tree[0][0]]
while dq:
temp, past = dq.pop()
for num in tree[temp]:
if num != past:
score[num] = score[temp]+counter[num]
dq.append([num,temp])
score = [str(i) for i in score]
print((" ".join(score)))
return None
if __name__ == "__main__":
main() | p02936 |
from collections import deque
N, Q = list(map(int, input().split(' ')))
queue = deque()
for _ in range(1, N):
queue.append(tuple(map(int, input().split(' '))))
tree = {
1: set()
}
while len(queue) > 0:
a, b = queue.popleft()
if a in tree:
tree[a].add(b)
tree[b] = set()
elif b in tree:
tree[b].add(a)
tree[a] = set()
else:
queue.append((a, b))
results = [0] * (N + 1)
for _ in range(Q):
p, x = list(map(int, input().split(' ')))
results[p] += x
stack = deque([1])
while len(stack) > 0:
node = stack.popleft()
for child in tree[node]:
stack.append(child)
results[child] += results[node]
print((' '.join([str(result) for result in results[1:]])))
| from collections import deque, defaultdict
N, Q = list(map(int, input().split(' ')))
tree = defaultdict(set)
for _ in range(1, N):
a, b = list(map(int, input().split(' ')))
tree[a].add(b)
tree[b].add(a)
results = [0] * (N + 1)
for _ in range(Q):
p, x = list(map(int, input().split(' ')))
results[p] += x
stack = deque([1])
searched = set()
while len(stack) > 0:
node = stack.popleft()
searched.add(node)
for child in tree[node]:
if child not in searched:
stack.append(child)
results[child] += results[node]
print((' '.join([str(result) for result in results[1:]])))
| p02936 |
import sys
sys.setrecursionlimit(10000000)
N, Q = [int(x) for x in input().split()]
# V = [set() for _ in range(N)]
V = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = [int(x) for x in input().split()]
a -= 1
b -= 1
# V[a].add(b)
V[a].append(b)
C = [0] * N
for _ in range(Q):
p, x = [int(x) for x in input().split()]
p -= 1
C[p] += x
ANS = [0] * N
def dfs(n, val):
ANS[n] += (val + C[n])
for next in V[n]:
dfs(next, val + C[n])
def main():
dfs(0, 0)
print((" ".join([str(x) for x in ANS])))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
N, Q = [int(x) for x in input().split()]
# V = [set() for _ in range(N)]
V = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = [int(x) for x in input().split()]
a -= 1
b -= 1
# V[a].add(b)
V[a].append(b)
C = [0] * N
for _ in range(Q):
p, x = [int(x) for x in input().split()]
p -= 1
C[p] += x
ANS = [0] * N
def dfs(n, val):
ANS[n] += (val + C[n])
for next in V[n]:
dfs(next, val + C[n])
def main():
dfs(0, 0)
print((" ".join([str(x) for x in ANS])))
if __name__ == '__main__':
main()
| 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
def dfs(v,parent,add):
value[v] += add
for x in graph[v]:
if x == parent:
continue
dfs(x,v,value[v])
dfs(1,0,0)
answer = ' '.join(map(str,value[1:]))
print(answer)
| 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)]
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
def dfs(v,parent,add):
value[v] += add
for x in graph[v]:
if x == parent:
continue
dfs(x,v,value[v])
dfs(1,0,0)
answer = ' '.join(map(str,value[1:]))
print(answer)
| 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)]
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
def dfs(v,parent,add):
value[v] += add
for x in graph[v]:
if x == parent:
continue
dfs(x,v,value[v])
dfs(1,0,0)
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
def dfs(v,parent,add):
value[v] += add
for x in graph[v]:
if x == parent:
continue
dfs(x,v,value[v])
dfs(1,0,0)
answer = ' '.join(map(str,value[1:]))
print(answer)
| p02936 |
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def f(ab: list, parent: list, i: int = 0):
if len(ab[i]) == 1 and i != 0:
return
for j in ab[i]:
if j != parent[i]:
parent[j] = i
f(ab, parent, j)
def g(ab: list, parent: list, ans: list, i: int = 0):
if len(ab[i]) == 1 and i != 0:
return
for j in ab[i]:
if j != parent[i]:
ans[j] += ans[i]
g(ab, parent, ans, j)
def main():
N, Q = list(map(int, input().split()))
ab = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
ab[a-1].append(b-1)
ab[b-1].append(a-1)
parent = [-1] * N
f(ab, parent)
ans = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
g(ab, parent, ans)
print((' '.join(list(map(str, ans)))))
if __name__ == '__main__': main() | import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def g(ab: list, ans: list, check: list, i: int = 0):
if len(ab[i]) == 1 and i != 0:
return
check[i] = False
for j in ab[i]:
if check[j]:
ans[j] += ans[i]
g(ab, ans, check, j)
def main():
N, Q = list(map(int, input().split()))
ab = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
ab[a-1].append(b-1)
ab[b-1].append(a-1)
ans = [0] * N
check = [True] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
ans[p-1] += x
g(ab, ans, check)
print((' '.join(list(map(str, ans)))))
if __name__ == '__main__': main() | p02936 |
import sys
from collections import deque
sys.setrecursionlimit(500000)
n,q=list(map(int,input().split()))
edge=[[] for i in range(n)]
cost=[0]*n
for i in range(n-1):
p,s=list(map(int,input().split()))
p-=1;s-=1
edge[p].append(s)
edge[s].append(p)
for i in range(q):
x,c=list(map(int,input().split()))
x-=1
cost[x]+=c
visited=[False]*n
queue=deque([0])
visited[0]=True
while len(queue)!=0:
a=queue.popleft()
for i in edge[a]:
if visited[i]==True:continue
queue.append(i)
visited[i]=True
cost[i]+=cost[a]
for i in range(n):
cost[i]=str(cost[i])
print((" ".join(cost))) | import sys
from collections import deque
sys.setrecursionlimit(500000)
input=sys.stdin.readline
n,q=list(map(int,input().split()))
edge=[[] for i in range(n)]
cost=[0]*n
for i in range(n-1):
p,s=list(map(int,input().split()))
p-=1;s-=1
edge[p].append(s)
edge[s].append(p)
for i in range(q):
x,c=list(map(int,input().split()))
x-=1
cost[x]+=c
visited=[False]*n
queue=deque([0])
visited[0]=True
while len(queue)!=0:
a=queue.popleft()
for i in edge[a]:
if visited[i]==True:continue
queue.append(i)
visited[i]=True
cost[i]+=cost[a]
for i in range(n):
cost[i]=str(cost[i])
print((" ".join(cost)))
| p02936 |
import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=0):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if index==0:inp[0]-=1;inp[1]-=1
if len(inp)==2:
a,b=inp;g[a].append(b)
if not Directed:g[b].append(a)
elif len(inp)==3:
a,b,c=inp;aa=(inp[0],inp[2]);bb=(inp[1],inp[2]);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
mp=[1]*(w+2);found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[1]+[mp_def[j] for j in s]+[1]
mp+=[1]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.n=n
self.ide_ele=ide_ele=ide
self.num=num=2**(n-1).bit_length()
self.seg=seg=[self.ide_ele]*2*self.num
self.lazy=lazy=[self.ide_ele]*2*self.num
self.segfun=segfun=function
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1):
self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def evaluate(k,l,r): #遅延評価処理
if lazy[k]!=0:
node[k]+=lazy[k]
if(r-l>1):
lazy[2*k+1]+=lazy[k]//2
lazy[2*k+2]+=lazy[k]//2
lazy[k]=0
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def find_min_index(self,p,q,m):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def __str__(self):
# 生配列を表示
rt=self.seg[self.num-1:self.num-1+self.n]
return str(rt)
ans=0
class Tree:
def __init__(self,inp_size=None,init=True):
if init:
self.stdin(inp_size)
return
def stdin(self,inp_size=None):
if inp_size==None:
self.size=int(input())
else:
self.size=inp_size
self.edges,_=GI(self.size,self.size-1)
return
def listin(self,ls):
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls)
return
def __str__(self):
return str(self.edges)
def dfs(self,x,func=lambda x,y,z:x+z,root_v=0):
q=deque()
q.append(x)
v=[-1]*self.size
v[x]=root_v
while q:
c=q.pop()
for nb in self.edges[c]:
d=1
if type(nb) is not int:
nb,d=nb
if v[nb]==-1:
q.append(nb)
v[nb]=func(v[c],nb,d)
return v
def EulerTour(self,x,func=lambda x:x+1,root_v=0):
q=deque()
q.append((-1,x))
v=[None]*self.size
v[x]=root_v
et=[]
while q:
cb,ce=q.pop()
et.append(ce)
for nb in self.edges[ce]:
if v[nb]==None:
q.append((nb,ce))
q.append((ce,nb))
v[nb]=func(v[ce])
vid=[[-1,-1]for i in range(self.size)]
for i,j in enumerate(et):
if vid[j][0]==-1:
vid[j][0]=i
else:
vid[j][1]=i
return v,et,vid
def LCA_init(self,depth,et):
self.st=SegTree(self.size*2-1,func=min,ide=inf)
for i,j in enumerate(et):
self.st.update(i,j)
self.LCA_init_stat==True
return
def LCA(self,root,x,y):
if self.LCA_init_stat==False:
depth,et,vid=self.EulerTour(root)
self.LCA_init(depth,et)
return self.st.query(x,y+1)
#tr=Tree(init=False)
n,q=LI()
tr=Tree(n)
f=[0]*n
for i in range(q):
p,x=LI()
f[p-1]+=x
v=tr.dfs(0,func=lambda x,y,d:x+f[y],root_v=f[0])
show(*v)
| import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=0):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if index==0:inp[0]-=1;inp[1]-=1
if len(inp)==2:
a,b=inp;g[a].append(b)
if not Directed:g[b].append(a)
elif len(inp)==3:
a,b,c=inp;aa=(inp[0],inp[2]);bb=(inp[1],inp[2]);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
mp=[1]*(w+2);found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[1]+[mp_def[j] for j in s]+[1]
mp+=[1]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.n=n
self.ide_ele=ide_ele=ide
self.num=num=2**(n-1).bit_length()
self.seg=seg=[self.ide_ele]*2*self.num
self.lazy=lazy=[self.ide_ele]*2*self.num
self.segfun=segfun=function
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1):
self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def evaluate(k,l,r): #遅延評価処理
if lazy[k]!=0:
node[k]+=lazy[k]
if(r-l>1):
lazy[2*k+1]+=lazy[k]//2
lazy[2*k+2]+=lazy[k]//2
lazy[k]=0
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def find_min_index(self,p,q,m):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def __str__(self):
# 生配列を表示
rt=self.seg[self.num-1:self.num-1+self.n]
return str(rt)
ans=0
class Tree:
def __init__(self,inp_size=None,init=True):
if init:
self.stdin(inp_size)
return
def stdin(self,inp_size=None):
if inp_size==None:
self.size=int(input())
else:
self.size=inp_size
self.edges,_=GI(self.size,self.size-1)
return
def listin(self,ls):
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls)
return
def __str__(self):
return str(self.edges)
def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
q=deque()
q.append(x)
v=[-1]*self.size
v[x]=root_v
while q:
c=q.pop()
for nb in self.edges[c]:
d=1
if type(nb) is not int:
nb,d=nb
if v[nb]==-1:
q.append(nb)
v[nb]=func(v[c],nb,d)
return v
def EulerTour(self,x,func=lambda x:x+1,root_v=0):
q=deque()
q.append((-1,x))
v=[None]*self.size
v[x]=root_v
et=[]
while q:
cb,ce=q.pop()
et.append(ce)
for nb in self.edges[ce]:
if v[nb]==None:
q.append((nb,ce))
q.append((ce,nb))
v[nb]=func(v[ce])
vid=[[-1,-1]for i in range(self.size)]
for i,j in enumerate(et):
if vid[j][0]==-1:
vid[j][0]=i
else:
vid[j][1]=i
return v,et,vid
def LCA_init(self,depth,et):
self.st=SegTree(self.size*2-1,func=min,ide=inf)
for i,j in enumerate(et):
self.st.update(i,j)
self.LCA_init_stat==True
return
def LCA(self,root,x,y):
if self.LCA_init_stat==False:
depth,et,vid=self.EulerTour(root)
self.LCA_init(depth,et)
return self.st.query(x,y+1)
#tr=Tree(init=False)
n,q=LI()
tr=Tree(n)
f=[0]*n
for i in range(q):
p,x=LI()
f[p-1]+=x
v=tr.dfs(0,func=lambda x,y,d:x+f[y],root_v=f[0])
print(*v)
| p02936 |
N, Q = list(map(int, input().split(" ")))
ns= [list(map(int, input().split(" "))) for _ in range(N-1)]
vs = [list(map(int, input().split(" "))) for _ in range(Q)]
dic = dict.fromkeys(list(range(1,N+1)), 1)
rlt = dict.fromkeys(list(range(1,N+1)), 0)
for i in range(N-1):
dic[ns[i][1]] = ns[i][0]
for q in vs:
rlt[q[0]] = rlt[q[0]] + q[1]
l = [i for i in range(q[0]+1,N+1) if dic[i] == q[0]]
while len(l) > 0:
t = l.pop(0)
rlt[t] = rlt[t] + q[1]
l1 = [i for i in range(t+1,N+1) if dic[i] == t]
l.extend(l1)
print((" ".join(map(str, list(rlt.values()))))) | N, Q = list(map(int, input().split(" ")))
ns= [list(map(int, input().split(" "))) for _ in range(N-1)]
vs = [list(map(int, input().split(" "))) for _ in range(Q)]
dic = [[] for _ in range(N)]
rlt = [0]*N
for i in range(N-1):
dic[ns[i][0]-1] += [ns[i][1]-1]
for j in range(Q):
rlt[vs[j][0]-1] += vs[j][1]
for k in range(N):
for l in dic[k]:
rlt[l] += rlt[k]
print((" ".join(map(str, rlt)))) | p02936 |
N, Q = list(map(int, input().split(" ")))
ns= [list(map(int, input().split(" "))) for _ in range(N-1)]
vs = [list(map(int, input().split(" "))) for _ in range(Q)]
ns = sorted(ns)
flags = [True]+[False]*(N-1)
dic = [[] for _ in range(N)]
rlt = [0]*N
for i in range(N-1):
if flags[ns[i][1]-1]:
dic[ns[i][1]-1] += [ns[i][0]-1]
else:
dic[ns[i][0]-1] += [ns[i][1]-1]
flags[ns[i][1]-1] = True
for j in range(Q):
rlt[vs[j][0]-1] += vs[j][1]
for k in range(N):
for l in dic[k]:
rlt[l] += rlt[k]
print((" ".join(map(str, rlt)))) | N, Q = list(map(int, input().split(" ")))
ns= [list(map(int, input().split(" "))) for _ in range(N-1)]
vs = [list(map(int, input().split(" "))) for _ in range(Q)]
flags = [True]+[False]*(N-1)
dic = [[] for _ in range(N)]
rlt = [0]*N
for i in range(N-1):
dic[ns[i][1]-1] += [ns[i][0]-1]
dic[ns[i][0]-1] += [ns[i][1]-1]
for j in range(Q):
rlt[vs[j][0]-1] += vs[j][1]
for k in range(N):
for l in dic[k]:
if flags[l]:
continue
else:
rlt[l] += rlt[k]
flags[l] = True
print((" ".join(map(str, rlt)))) | p02936 |
from collections import deque
from collections import defaultdict
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
G = Graph()
N, Q = getlist()
for i in range(N - 1):
a, b = getlist()
G.add_edge(a, b)
G.add_edge(b, a)
plus = [0 for i in range(N + 1)]
for i in range(Q):
p, x = getlist()
plus[p] += x
q = deque()
ans = [0 for i in range(N)]
visit = [-1 for i in range(N + 1)]
visit[1] = 1
q.append(1)
while q:
m = q.pop()
visit[m] = 1
ans[m - 1] += plus[m]
x = ans[m - 1]
for i in G.graph[m]:
if visit[i] == -1:
q.append(i)
ans[i - 1] += x
print((" ".join(list(map(str, ans))))) | from collections import deque
from collections import defaultdict
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
G = Graph()
N, Q = getlist()
for i in range(N - 1):
a, b = getlist()
G.add_edge(a, b)
G.add_edge(b, a)
plus = [0 for i in range(N + 1)]
for i in range(Q):
p, x = getlist()
plus[p] += x
q = deque([])
ans = [0 for i in range(N)]
visit = [-1 for i in range(N + 1)]
visit[1] = 1
q.append(1)
while q:
m = q.pop()
visit[m] = 1
ans[m - 1] += plus[m]
x = ans[m - 1]
for i in G.graph[m]:
if visit[i] == -1:
q.append(i)
ans[i - 1] += x
print((" ".join(list(map(str, ans))))) | p02936 |
from collections import deque
from collections import defaultdict
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
G = Graph()
N, Q = getlist()
for i in range(N - 1):
a, b = getlist()
G.add_edge(a, b)
G.add_edge(b, a)
plus = [0 for i in range(N + 1)]
for i in range(Q):
p, x = getlist()
plus[p] += x
q = deque([])
ans = [0 for i in range(N)]
visit = [-1 for i in range(N + 1)]
visit[1] = 1
q.append(1)
while q:
m = q.pop()
visit[m] = 1
ans[m - 1] += plus[m]
x = ans[m - 1]
for i in G.graph[m]:
if visit[i] == -1:
q.append(i)
ans[i - 1] += x
print((" ".join(list(map(str, ans))))) | from collections import deque
from collections import defaultdict
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
G = Graph()
N, Q = getlist()
for i in range(N - 1):
a, b = getlist()
G.add_edge(a, b)
G.add_edge(b, a)
plus = [0] * (N + 1)
for i in range(Q):
p, x = getlist()
plus[p] += x
q = deque([])
ans = [0] * N
visit = [-1] * (N + 1)
visit[1] = 1
q.append(1)
while q:
m = q.pop()
visit[m] = 1
ans[m - 1] += plus[m]
x = ans[m - 1]
for i in G.graph[m]:
if visit[i] == -1:
q.append(i)
ans[i - 1] += x
print((" ".join(list(map(str, ans))))) | 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)]
# 各ノードと連結するノードを要素に持つ配列
# e.g., graph[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() # (1, 0)
value[x] += value[parent]
# 連結する成分について繰り返す
# このとき、親のノードに流さないように注意
# ここでの操作は、自分の子のノードを加えること
for y in graph[x]:
if y == parent:
continue
q.append((y, x)) #(親,子)
res = ' '.join(map(str, value[1:]))
print(res) | import sys
input = sys.stdin.readline
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)]
# 各ノードと連結するノードを要素に持つ配列
# e.g., graph[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() # (1, 0)
value[x] += value[parent]
# 連結する成分について繰り返す
# このとき、親のノードに流さないように注意
# ここでの操作は、自分の子のノードを加えること
for y in graph[x]:
if y == parent:
continue
q.append((y, x)) #(親,子)
res = ' '.join(map(str, value[1:]))
print(res)
| p02936 |
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
def init(n):
for i in range(N):
par[i]=i
num[i]=0
def find(x):
if par[x]==x:
return x
else:
return find(par[x])
def unite(x,y):
if (y<x):
par[x]=y
else:
par[y]=x
def same(x,y):
return find(x)==find(y)
def cnt(x,tmp):
res = tmp + num[x]
if par[x]==x:
return res
else:
return cnt(par[x],res)
N,Q = IL()
ab = [IL() for i in range(N-1)]
px = [IL() for i in range(Q)]
par=[0 for i in range(N+1)]
num=[0 for i in range(N+1)]
init(N)
for a,b in ab:
unite(a,b)
for p,x in px:
num[p] += x
ans = []
for i in range(1,N+1):
ans.append(cnt(i,0))
print((" ".join(map(str,ans)))) | import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
def init(n):
for i in range(N):
par[i]=i
num[i]=0
def find(x):
if par[x]==x:
return x
else:
return find(par[x])
def unite(x,y):
if (y<x):
par[x]=y
else:
par[y]=x
def same(x,y):
return find(x)==find(y)
def cnt(x):
if par[x]==x:
res = num[x]
return res
else:
if used[par[x]] == True:
res = num[x] + ans[par[x]]
return res
else:
return
N,Q = IL()
ab = [IL() for i in range(N-1)]
px = [IL() for i in range(Q)]
par=[0 for i in range(N+1)]
num=[0 for i in range(N+1)]
init(N)
for a,b in ab:
unite(a,b)
for p,x in px:
num[p] += x
ans = [0 for i in range(N+1)]
used = [False for i in range(N+1)]
for i in range(1,N+1):
ans[i] = cnt(i)
used[i] = True
print((" ".join(map(str,ans[1:])))) | p02936 |
n, q = list(map(int, input().split()))
link = dict()
counter = list([0]*n)
for i in range(n-1):
a, b = list(map(int, input().split()))
link[b-1] = a-1
for i in range(q):
p,pp = list(map(int, input().split()))
counter[p-1] += pp
ans = ""
for i in range(n):
isChild = True
now = i
count = counter[now]
while True:
if now in link:
count += counter[link[now]]
now = link[now]
else:
break
if i != n-1:
ans += str(count) + " "
else: ans += str(count)
print(ans)
| n, q = list(map(int, input().split()))
link = dict()
counter = list([0]*n)
for i in range(n-1):
a,b = list(map(int, input().split()))
link[b-1] = a-1
for i in range(q):
p,pp = list(map(int, input().split()))
counter[p-1] += pp
for i in range(n):
if i in link:
counter[i] += counter[link[i]]
counter = list(map(str, counter))
ans = " ".join(counter)
print(ans) | p02936 |
import sys
sys.setrecursionlimit(10**8)
N, Q = list(map(int, input().split()))
a = []
p = []
x = [0]*(N)
A = [0]*(N)
for i in range(N-1):
t=list(map(int,input().split()))
if t[0]>t[1]:
swap = t[1]
t[1] = t[0]
t[0] =swap
a.append((int(t[0]),int(t[1])))
for i in range(Q):
t=list(map(int,input().split()))
p.append((int(t[0]),int(t[1])))
a =sorted(a, key=lambda x: x[0])
p =sorted(p, key=lambda x: x[0])
#print(a)
for i in range(Q):
x[p[i][0]-1] += p[i][1]
for i in range(N):
A[i] = x[i]
for i in range(N-1):
La = a[i][0]-1
Lb = a[i][1]-1
A[Lb] = A[La]+x[Lb]
print((' '.join(map(str, A))))
|
N, Q = list(map(int, input().split()))
a = []
p = []
x = [0]*(N)
A = [0]*(N)
for i in range(N-1):
t=list(map(int,input().split()))
if t[0]>t[1]:
swap = t[1]
t[1] = t[0]
t[0] =swap
a.append((int(t[0]),int(t[1])))
for i in range(Q):
t=list(map(int,input().split()))
p.append((int(t[0]),int(t[1])))
a =sorted(a, key=lambda x: x[0])
p =sorted(p, key=lambda x: x[0])
#print(a)
for i in range(Q):
x[p[i][0]-1] += p[i][1]
for i in range(N):
A[i] = x[i]
for i in range(N-1):
La = a[i][0]-1
Lb = a[i][1]-1
A[Lb] = A[La]+x[Lb]
print((' '.join(map(str, A))))
| p02936 |
N, Q = list(map(int, input().split()))
value = [0]*(N+1)
tree = [[i] for i in range(N+1)]
for i in range(N-1):
a, b = list(map(int, input().split()))
for rel in tree:
if a in rel:
rel.append(b)
for i in range(Q):
a, b = list(map(int, input().split()))
for arg in tree[a]:
value[arg] += b
print((' '.join(map(str, value[1:])))) | N, Q = list(map(int, input().split()))
value = [0]*(N+1)
ab_list = []
for i in range(N-1):
a, b = list(map(int, input().split()))
ab_list.append([a, b])
ab_list.sort(key=lambda x:x[0])
for i in range(Q):
p, q = list(map(int, input().split()))
value[p] += q
for a, b in ab_list:
value[b] += value[a]
print((' '.join(map(str, value[1:])))) | p02936 |
while True:
try:
N, Q = list(map(int, input().split()))
verts = [None] * N
qs = [0] * N
results = [0] * N
for i in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
if verts[a] is None:
verts[a] = list()
if verts[b] is None:
verts[b] = list()
verts[a].append(b)
verts[b].append(a)
for i in range(Q):
q, x = list(map(int, input().split()))
q -= 1
qs[q] += x
rests = [(0, None)]
while rests:
x, parent = rests.pop()
if parent is not None:
results[x] += results[parent]
results[x] += qs[x]
if verts[x] is not None:
rests.extend((i, x) for i in [j for j in verts[x] if j != parent])
print((" ".join(map(str, results))))
except EOFError:
break | while True:
try:
N, Q = list(map(int, input().split()))
verts = [None] * N
qs = [0] * N
results = [0] * N
for i in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
if verts[a] is None:
verts[a] = list()
if verts[b] is None:
verts[b] = list()
verts[a].append(b)
verts[b].append(a)
for i in range(Q):
q, x = list(map(int, input().split()))
q -= 1
qs[q] += x
rests = [(0, None)]
while rests:
x, parent = rests.pop()
if parent is not None:
results[x] += results[parent]
results[x] += qs[x]
for i in verts[x]:
if i != parent:
rests.append((i, x))
print((" ".join(map(str, results))))
except EOFError:
break | p02936 |
import sys
sys.setrecursionlimit(10**6)
def dfs(ve, add):
global seen
global r
seen[ve] = True
r[ve] = add
a = len(ki[ve])
for i in range(a):
b = ki[ve][i]
if not seen[b]:
dfs(b, add+ook[b])
N,Q = list(map(int, input().split()))
side = [list(map(int, input().split())) for _ in range(N-1)]
op = [list(map(int, input().split())) for _ in range(Q)]
ki = [[] for _ in range(N)]
ook = [0]*N
seen = [False]*N
r = [0]*N
for i in range(N-1):
a = side[i][0] -1
b = side[i][1] -1
ki[a].append(b)
ki[b].append(a)
for i in range(Q):
ook[op[i][0] -1] += op[i][1]
for i in range(N):
if seen[i]:
continue
dfs(i, ook[i])
print((" ".join(map(str,r)))) | import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def dfs(ve, add):
global seen
global r
seen[ve] = True
r[ve] = add
a = len(ki[ve])
for i in range(a):
b = ki[ve][i]
if not seen[b]:
dfs(b, add+ook[b])
N,Q = list(map(int, input().split()))
side = [list(map(int, input().split())) for _ in range(N-1)]
op = [list(map(int, input().split())) for _ in range(Q)]
ki = [[] for _ in range(N)]
ook = [0]*N
seen = [False]*N
r = [0]*N
for i in range(N-1):
a = side[i][0] -1
b = side[i][1] -1
ki[a].append(b)
ki[b].append(a)
for i in range(Q):
ook[op[i][0] -1] += op[i][1]
for i in range(N):
if seen[i]:
continue
dfs(i, ook[i])
print((" ".join(map(str,r)))) | p02936 |
'''
pythonの再帰は10^5timesですら厳しい
import sys
sys.setrecursionlimit(10000000)
def dfs(v,p,G,c):
for u in G[v]:
if u!=p:
c[u]+=c[v]
dfs(u,v,G,c)
'''
from collections import deque
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()))
a-=1
b-=1
G[a].append(b)
G[b].append(a)
p=[0]*Q
x=[0]*Q
for i in range(Q):
p[i],x[i] = list(map(int,input().split()))
p[i]-=1
c=[0]*N
for i in range(Q):
c[p[i]] += x[i]
stack=deque([0])
p = [-1]*N
a
while(stack):
v = stack.pop()
for u in G[v]:
if u!=p[v]:
c[u]+=c[v]
p[u]=v
stack.appendleft(u)
ans = ' '.join([str(x) for x in c])
print(ans) | '''
pythonの再帰は10^5timesですら厳しい
import sys
sys.setrecursionlimit(10000000)
def dfs(v,p,G,c):
for u in G[v]:
if u!=p:
c[u]+=c[v]
dfs(u,v,G,c)
'''
from collections import deque
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()))
a-=1
b-=1
G[a].append(b)
G[b].append(a)
p=[0]*Q
x=[0]*Q
c=[0]*N
for i in range(Q):
p,x = list(map(int,input().split()))
p-=1
c[p] += x
stack=deque([0])
parent = [-1]*N
while(stack):
v = stack.pop()
for u in G[v]:
if u!=parent[v]:
c[u]+=c[v]
parent[u]=v
stack.appendleft(u)
ans = ' '.join([str(x) for x in c])
print(ans) | p02936 |
'''
pythonの再帰は10^5timesですら厳しい
import sys
sys.setrecursionlimit(10000000)
def dfs(v,p,G,c):
for u in G[v]:
if u!=p:
c[u]+=c[v]
dfs(u,v,G,c)
'''
from collections import deque
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()))
a-=1
b-=1
G[a].append(b)
G[b].append(a)
p=[0]*Q
x=[0]*Q
c=[0]*N
for i in range(Q):
p,x = list(map(int,input().split()))
p-=1
c[p] += x
stack=deque([0])
parent = [-1]*N
while(stack):
v = stack.pop()
for u in G[v]:
if u!=parent[v]:
c[u]+=c[v]
parent[u]=v
stack.append(u)
ans = ' '.join([str(x) for x in c])
print(ans) | 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()))
a-=1
b-=1
G[a].append(b)
G[b].append(a)
p=[0]*Q
x=[0]*Q
c=[0]*N
for i in range(Q):
p,x = list(map(int,input().split()))
p-=1
c[p] += x
stack=[0]
parent = [-1]*N
while(stack):
v = stack.pop()
for u in G[v]:
if u!=parent[v]:
c[u]+=c[v]
parent[u]=v
stack.append(u)
ans = ' '.join([str(x) for x in c])
print(ans) | p02936 |
n,q = list(map(int,input().split()))
ki = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = list(map(int, input().split()))
ki[a - 1].append(b-1)
ki[b - 1].append(a-1)
counter = [0 for _ in range(n)]
for _ in range(q):
p, x = list(map(int, input().split()))
counter[p-1] += x
qux = [0]
while qux:
x = qux.pop()
for ko in ki[x]:
counter[ko] += counter[x]
qux.append(ko)
ki[ko].remove(x)
print((" ".join(map(str,counter)))) | n,q = list(map(int,input().split()))
ki = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = list(map(int, input().split()))
ki[a - 1].append(b-1)
ki[b - 1].append(a-1)
counter = [0 for _ in range(n)]
for _ in range(q):
p, x = list(map(int, input().split()))
counter[p-1] += x
qux = [0]
flag = [False] * n
flag[0] = True
while qux:
x = qux.pop()
for ko in ki[x]:
if not flag[ko]:
counter[ko] += counter[x]
qux.append(ko)
flag[x] = True
print((" ".join(map(str,counter)))) | p02936 |
import sys
sys.setrecursionlimit(10**6)
N,Q = [int(i) for i in input().split()] #N個の頂点、Q回の操作
aaabbb = [[int(i) for i in input().split()] for j in range(N-1)] #木の辺
pppxxx = [[int(i) for i in input().split()] for j in range(Q)] #操作
tree = [[] for i in range(N+1)]
for a,b in aaabbb:
tree[a].append(b)
tree[b].append(a)
#print(tree)
counter = [0 for i in range(N+1)]
for p,x in pppxxx:
counter[p] += x
#print(counter)
def dfs(pos,parent,add):
counter[pos] += add
for next_pos in tree[pos]:
if not next_pos == parent:
dfs(next_pos,pos,counter[pos])
dfs(1,0,0)
#print(counter)
print((" ".join([str(i) for i in counter[1:]]))) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N,Q = [int(i) for i in input().split()] #N個の頂点、Q回の操作
aaabbb = [[int(i) for i in input().split()] for j in range(N-1)] #木の辺
pppxxx = [[int(i) for i in input().split()] for j in range(Q)] #操作
tree = [[] for i in range(N+1)]
for a,b in aaabbb:
tree[a].append(b)
tree[b].append(a)
#print(tree)
counter = [0 for i in range(N+1)]
for p,x in pppxxx:
counter[p] += x
#print(counter)
def dfs(pos,parent,add):
counter[pos] += add
for next_pos in tree[pos]:
if not next_pos == parent:
dfs(next_pos,pos,counter[pos])
dfs(1,0,0)
#print(counter)
print((" ".join([str(i) for i in counter[1:]])))
| p02936 |
# ki
from collections import deque
# input
n, q = list(map(int, input().split()))
ln = [list(map(int, input().split())) for i in range(n-1)]
lq = [list(map(int, input().split())) for i in range(q)]
edge = [[] for i in range(n+1)]
for next in ln:
parent = next[0]
child = next[1]
edge[parent].append(child)
edge[child].append(parent)
score = [0]*(n+1)
visited = [False]*(n+1)
for q in lq:
score[q[0]] += q[1]
que = deque()
que.append(1)
while que:
node = que.popleft()
if not visited[node]:
visited[node] = True
for next in edge[node]:
if not visited[next]:
score[next] += score[node]
que.append(next)
print((" ".join([str(n) for n in score][1:])))
| # ki
from collections import deque
# input
n, q = list(map(int, input().split()))
edge = [[] for i in range(n+1)]
for i in range(n-1):
a, b = list(map(int, input().split()))
edge[a].append(b)
edge[b].append(a)
lq = [list(map(int, input().split())) for i in range(q)]
score = [0]*(n+1)
visited = [False]*(n+1)
for q in lq:
score[q[0]] += q[1]
que = deque()
que.append(1)
while que:
node = que.popleft()
if not visited[node]:
visited[node] = True
for next in edge[node]:
if not visited[next]:
score[next] += score[node]
que.append(next)
print((" ".join([str(n) for n in score][1:]))) | p02936 |
import sys
sys.setrecursionlimit(10000000)
class tree:
def __init__(self):
self.baby_list=[]
self.counter=0
def add_value(self, value):
self.counter += value
for i in self.baby_list:
hoge[i].add_value(value)
N,Q=list(map(int, input().split() ))
hoge={}
for i in range(1,N+1):
hoge[i] = tree()
for i in range(N-1):
a,b=list(map(int, input().split() ))
hoge[a].baby_list.append(b)
for i in range(Q):
root, value = list(map(int, input().split() ))
hoge[root].add_value(value)
output = []
for t in hoge:
output.append(hoge[t].counter)
output = list(map(str, output))
print((" ".join(output))) | import sys
sys.setrecursionlimit(10000000)
class tree:
def __init__(self):
self.baby_list=[]
self.counter=0
def add_value(self):
for i in self.baby_list:
hoge[i].counter += self.counter
hoge[i].add_value()
N,Q=list(map(int, input().split() ))
hoge={}
for i in range(1,N+1):
hoge[i] = tree()
for i in range(N-1):
a,b=list(map(int, input().split() ))
hoge[a].baby_list.append(b)
for i in range(Q):
root, value = list(map(int, input().split() ))
hoge[root].counter+=value
hoge[1].add_value()
output = []
for t in hoge:
output.append(hoge[t].counter)
output = list(map(str, output))
print((" ".join(output))) | p02936 |
import sys
from collections import deque
class tree:
def __init__(self):
self.baby_list=deque()
self.counter=0
def add_value(self):
for i in self.baby_list:
hoge[i].counter+=self.counter
hoge[i].add_value()
N,Q=list(map(int, input().split() ))
hoge={i:tree() for i in range(1,N+1)}
for i in range(N-1):
a,b=list(map(int, input().split() ))
hoge[a].baby_list.append(b)
for i in range(Q):
root, value = list(map(int, input().split() ))
hoge[root].counter+=value
hoge[1].add_value()
output = []
for t in hoge:
output.append(hoge[t].counter)
output = list(map(str, output))
print((" ".join(output))) | import sys
sys.setrecursionlimit(10000000)
N,Q=list(map(int, input().split() ))
data={i+1:0 for i in range(N)}
# for i in range(N-1):
# a,b=list(map(int, input().split() ))
# hoge[a].baby_list.append(b)
relate = [list(map(int, input().split() )) for i in range(N-1)]
relate.sort(key=lambda x :x[0])
for i in range(Q):
root, value = list(map(int, input().split() ))
data[root]+=value
for a,b in relate:
data[b]+=data[a]
print((" ".join(list(map(str,list(data.values())))))) | p02936 |
### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(50000000)
class check():
def __init__(self):
readline=sys.stdin.readline
n,q=list(map(int, readline().rstrip().split()))
self.tree=[[] for i in range(n)]
self.ans=[0]*n
for i in range(n-1):
a,b=list(map(int, readline().rstrip().split()))
a-=1
b-=1
self.tree[a].append(b)
self.tree[b].append(a)
for i in range(q):
p,x=list(map(int, readline().rstrip().split()))
p-=1
self.ans[p]+=x
def do(self,root,next):
if root >= 0:
self.ans[next]+=self.ans[root]
for a in self.tree[next]:
if a==root:
continue
self.do(next,a)
def answer(self):
print((" ".join(map(str,self.ans))))
def resolve():
readline=sys.stdin.readline
dfs=check()
dfs.do(-1,0)
dfs.answer()
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ----------------
| ### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(50000000)
def do(root,next,tree,ans):
if root >= 0:
ans[next]+=ans[root]
for a in tree[next]:
if a==root:
continue
do(next,a,tree,ans)
def resolve():
readline=sys.stdin.readline
n,q=list(map(int, readline().rstrip().split()))
tree=[[] for i in range(n)]
ans=[0]*n
for i in range(n-1):
a,b=list(map(int, readline().rstrip().split()))
a-=1
b-=1
tree[a].append(b)
tree[b].append(a)
for i in range(q):
p,x=list(map(int, readline().rstrip().split()))
p-=1
ans[p]+=x
do(-1,0,tree,ans)
print((" ".join(map(str,ans))))
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ---------------- | p02936 |
from heapq import heappush, heappop, heapify, heapreplace
from collections import defaultdict
from bisect import bisect_left
class Solution:
def main(self):
path = defaultdict(list)
N, Q = list(map(int, input().split()))
freq = [0] * N
for i in range(N-1):
ai, bi = list(map(int, input().split()))
path[ai-1].append(bi-1)
# path[bi-1].append(ai-1)
for i in range(Q):
p, x = list(map(int, input().split()))
freq[p-1] += x
stack = [(0, 0)]
seen = set()
res = [0] * N
while stack:
node, cum = stack.pop(0)
# seen.add(node)
val = freq[node] + cum
res[node] = val
for other in path[node]:
# if other not in seen:
stack.append((other, val))
print((' '.join(map(str, res))))
if __name__ == '__main__':
Solution().main() | from heapq import heappush, heappop, heapify, heapreplace
from collections import defaultdict
from bisect import bisect_left
class Solution:
def main(self):
path = defaultdict(list)
N, Q = list(map(int, input().split()))
freq = [0] * N
for i in range(N-1):
ai, bi = list(map(int, input().split()))
path[ai-1].append(bi-1)
# path[bi-1].append(ai-1)
for i in range(Q):
p, x = list(map(int, input().split()))
freq[p-1] += x
stack = [(0, 0)]
seen = set()
res = freq[:]
for i in range(N):
for other in path[i]:
res[other] += res[i]
print((' '.join(map(str, res))))
if __name__ == '__main__':
Solution().main() | p02936 |
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
n, q = map(int, input().split())
edges = [[] for _ in range(n)]
cnt = [0 for _ in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
edges[a - 1].append(b - 1)
for i in range(q):
p, x = map(int, input().split())
cnt[p - 1] += x
ans = [0 for _ in range(n)]
visit = [False for _ in range(n)]
def rec(pos, val):
val += cnt[pos]
ans[pos] = val
for to in edges[pos]:
if not visit[to]:
visit[to] = True
rec(to, val)
visit[0] = True
rec(0, 0)
for x in ans[:-1]:
print(x, end=' ')
print(ans[-1])
| import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
n, q = map(int, input().split())
edges = [[] for _ in range(n)]
cnt = [0 for _ in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
edges[a - 1].append(b - 1)
for i in range(q):
p, x = map(int, input().split())
cnt[p - 1] += x
ans = [0 for _ in range(n)]
visit = [False for _ in range(n)]
visit[0] = True
stack = []
stack.append((0, 0))
while stack:
pos, val = stack.pop(-1)
val += cnt[pos]
ans[pos] = val
for to in edges[pos]:
if not visit[to]:
visit[to] = True
stack.append((to, val))
for x in ans[:-1]:
print(x, end=' ')
print(ans[-1])
| p02936 |
import sys
sys.setrecursionlimit(10 ** 9)
n,q=list(map(int,input().split()))
graph=[[] for _ in range(n+1)]
ab=[list(map(int,input().split())) for _ in range(n-1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
px=[list(map(int,input().split())) for _ in range(q)]
seen=[0]*(n+1)
ans=[0]*(n+1)
for p,x in px:
ans[p]+=x
def dfs(i):
seen[i]=1
for li in graph[i]:
if seen[li]==0:
ans[li]+=ans[i]
dfs(li)
dfs(1)
print((' '.join(map(str,ans[1:])))) | import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
def main():
n,q=list(map(int,input().split()))
graph=[[] for _ in range(n+1)]
ab=[list(map(int,input().split())) for _ in range(n-1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
px=[list(map(int,input().split())) for _ in range(q)]
seen=[0]*(n+1)
ans=[0]*(n+1)
for p,x in px:
ans[p]+=x
def dfs(i):
seen[i]=1
for li in graph[i]:
if seen[li]==0:
ans[li]+=ans[i]
dfs(li)
dfs(1)
print((' '.join(map(str,ans[1:]))))
if __name__ == '__main__':
main() | p02936 |
def main(n,ab,px):
import sys
sys.setrecursionlimit(10**7)
g=[[]for _ in range(n)]
for a,b in ab:
g[a-1].append(b-1)
g[b-1].append(a-1)
ans=[0]*n
for p,x in px:
ans[p-1]+=x
def dfs(seen,i):
seen[i]=1
l=g[i]
for li in [li for li in l if seen[li]==0]:
ans[li]+=ans[i]
dfs(seen,li)
seen=[0]*n
dfs(seen,0)
print((' '.join(list(map(str,ans)))))
if __name__=='__main__':
import sys
input = sys.stdin.readline
n,q=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(n-1)]
px=[list(map(int,input().split())) for _ in range(q)]
main(n,ab,px)
| def main(n,ab,px):
import sys
sys.setrecursionlimit(10**7)
g=[[]for _ in range(n)]
for a,b in ab:
g[a-1].append(b-1)
g[b-1].append(a-1)
ans=[0 for _ in range(n)]
for p,x in px:
ans[p-1]+=x
def dfs(seen,i):
seen[i]=1
l=g[i]
for li in [li for li in l if seen[li]==0]:
ans[li]+=ans[i]
dfs(seen,li)
seen=[0 for _ in range(n)]
dfs(seen,0)
print((' '.join(list(map(str,ans)))))
if __name__=='__main__':
import sys
input = sys.stdin.readline
n,q=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(n-1)]
px=[list(map(int,input().split())) for _ in range(q)]
main(n,ab,px)
| p02936 |
def main(n,ab,px):
import sys
sys.setrecursionlimit(10**7)
g=[[]for _ in range(n)]
for a,b in ab:
g[a-1].append(b-1)
g[b-1].append(a-1)
ans=[0 for _ in range(n)]
for p,x in px:
ans[p-1]+=x
def dfs(seen,i):
seen[i]=1
l=g[i]
for li in [li for li in l if seen[li]==0]:
ans[li]+=ans[i]
dfs(seen,li)
seen=[0 for _ in range(n)]
dfs(seen,0)
print((' '.join(list(map(str,ans)))))
if __name__=='__main__':
import sys
input = sys.stdin.readline
n,q=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(n-1)]
px=[list(map(int,input().split())) for _ in range(q)]
main(n,ab,px)
| import sys
input = sys.stdin.readline
import sys
sys.setrecursionlimit(10**7)
def main(n,ab,px):
g=[[]for _ in range(n)]
for a,b in ab:
g[a-1].append(b-1)
g[b-1].append(a-1)
ans=[0 for _ in range(n)]
for p,x in px:
ans[p-1]+=x
def dfs(seen,i):
seen[i]=1
for li in g[i]:
if seen[li]==0:
ans[li]+=ans[i]
dfs(seen,li)
seen=[0 for _ in range(n)]
dfs(seen,0)
print((' '.join(list(map(str,ans)))))
if __name__=='__main__':
n,q=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(n-1)]
px=[list(map(int,input().split())) for _ in range(q)]
main(n,ab,px)
| p02936 |
import sys
sys.setrecursionlimit(200005)
n, q = list(map(int, input().split()))
to = [[] for i in range(n+1)]
for i in range(n-1):
a, b = list(map(int, input().split()))
to[a].append(b)
to[b].append(a)
score = [0]*(n+1)
for i in range(q):
p, x = list(map(int, input().split()))
score[p] += x
def down_tree(index, parent):
for i in to[index]:
if i == parent:
continue
score[i] += score[index]
down_tree(i, index)
down_tree(1, 1)
print((' '.join(map(str, score[1:])))) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(200005)
n, q = list(map(int, input().split()))
to = [[] for i in range(n+1)]
for i in range(n-1):
a, b = list(map(int, input().split()))
to[a].append(b)
to[b].append(a)
score = [0]*(n+1)
for i in range(q):
p, x = list(map(int, input().split()))
score[p] += x
def down_tree(index, parent):
for i in to[index]:
if i == parent:
continue
score[i] += score[index]
down_tree(i, index)
down_tree(1, 1)
print((' '.join(map(str, score[1:])))) | p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, Q = list(map(int, input().split()))
link = [[0]*(N+1) for _ in range(N+1)]
for n in range(N-1):
a, b = list(map(int, input().split()))
link[a][b] = 1
link[b][a] = 1
V = [0] * (N+1)
ans = [0] * (N+1)
for q in range(Q):
p, x = list(map(int, input().split()))
V[p] += x
def dfs(i, parent, acc):
V[i] += acc
for j in range(1,N+1):
if link[i][j] == 1 and parent!=j:
dfs(j,i,V[i])
cur = 1
parent = 0
acc = 0
dfs(cur, parent , acc)
V = [str(v) for v in V]
print((" ".join(V[1:])))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(int(1E+7))
def main():
N, Q = list(map(int, input().split()))
link = [[] for _ in range(N+1)]
for n in range(N-1):
a, b = list(map(int, input().split()))
link[a].append(b)
link[b].append(a)
V = [0] * (N+1)
ans = [0] * (N+1)
for q in range(Q):
p, x = list(map(int, input().split()))
V[p] += x
def dfs(i, parent, acc):
V[i] += acc
for j in link[i]:
if j != parent:
dfs(j,i,V[i])
cur = 1
parent = 0
acc = 0
dfs(cur, parent , acc)
V = [str(v) for v in V]
print((" ".join(V[1:])))
if __name__ == '__main__':
main()
| p02936 |
import sys
sys.setrecursionlimit(10**6)
N,Q=list(map(int,input().split()))
L=[[] for _ in range(N)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
a-=1
b-=1
L[a].append(b)
L[b].append(a)
CL=[0]*N
for _ in range(Q):
p,x=list(map(int,input().split()))
CL[p-1]+=x
AL=[0]*N
ed=[0]*N
def dfs(val, now):
ed[now]=1
val+=CL[now]
AL[now]=val
for p in L[now]:
if ed[p]==0:
dfs(val,p)
dfs(0,0)
print((" ".join(map(str,AL)))) | import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**6)
N,Q=list(map(int,input().split()))
L=[[] for _ in range(N)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
a-=1
b-=1
L[a].append(b)
L[b].append(a)
CL=[0]*N
for _ in range(Q):
p,x=list(map(int,input().split()))
CL[p-1]+=x
AL=[0]*N
ed=[0]*N
q=[(0,0)]
while len(q)!=0:
now,val=q.pop(-1)
ed[now] = 1
val += CL[now]
AL[now] = val
for p in L[now]:
if ed[p] == 0:
q.append((p,val))
print((" ".join(map(str,AL)))) | p02936 |
n, q = list(map(int,input().split()))
ikeru = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
ikeru[a-1].append(b-1)
ikeru[b-1].append(a-1)
fukasa = [0 for _ in range(n)]
fukasamoto = [set([]) for _ in range(n)]
fukasamoto[0].add(0)
kaisuu = 0
settansaku = set([])
setmada = {0}
kouho = 1
while kouho != 0:
kaisuu += 1
for i in list(setmada):
settansaku.add(i)
setmada.remove(i)
kouho -= 1
for k in ikeru[i]:
if not k in setmada:
if not k in settansaku:
setmada.add(k)
kouho += 1
fukasa[k] = kaisuu
fukasamoto[k] = fukasamoto[i] | {i, k}
kasan = [0 for _ in range(n)]
for i in range(q):
p, x = list(map(int,input().split()))
kasan[p-1] += x
ansl = [0 for _ in range(n)]
for i in range(n):
tmpans = 0
for j in fukasamoto[i]:
tmpans += kasan[j]
ansl[i] = tmpans
print((" ".join([str(ansl[i]) for i in range(n)]))) | n, q = list(map(int,input().split()))
ikeru = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
ikeru[a-1].append(b-1)
ikeru[b-1].append(a-1)
kasan = [0 for _ in range(n)]
for i in range(q):
p, x = list(map(int,input().split()))
kasan[p-1] += x
ansl = [0 for _ in range(n)]
ansl[0] = kasan[0]
kaisuu = 0
settansaku = set([])
setmada = {0}
kouho = 1
while kouho != 0:
kaisuu += 1
for i in list(setmada):
settansaku.add(i)
setmada.remove(i)
kouho -= 1
for k in ikeru[i]:
if not k in setmada:
if not k in settansaku:
setmada.add(k)
kouho += 1
ansl[k] = ansl[i] + kasan[k]
print((" ".join([str(ansl[i]) for i in range(n)]))) | p02936 |
N, Q = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(N - 1)]
px = [list(map(int, input().split())) for _ in range(Q)]
graph = [[] for _ in range(N)]
for i, (ai, bi) in enumerate(ab):
graph[ai - 1].append(bi - 1)
graph[bi - 1].append(ai - 1)
from collections import deque
c = [0] * N
for j, (pj, xj) in enumerate(px):
c[pj - 1] += xj
ans = [None] * N
q_0 = deque([(0, 0)])
while len(q_0) > 0:
score, src = q_0.popleft()
# print("#", score, src)
score_tmp = score + c[src]
ans[src] = score_tmp
for dst in graph[src]:
if ans[dst] == None:
q_0.append((score_tmp, dst))
print((' '.join(map(str, ans)))) | N, Q = list(map(int, input().split()))
# ab = [list(map(int, input().split())) for _ in range(N - 1)]
# px = [list(map(int, input().split())) for _ in range(Q)]
# graph = [[] for _ in range(N)]
# for i, (ai, bi) in enumerate(ab):
# graph[ai - 1].append(bi - 1)
# graph[bi - 1].append(ai - 1)
from collections import deque
# c = [0] * N
# for j, (pj, xj) in enumerate(px):
# c[pj - 1] += xj
graph = [[] for _ in range(N)]
for _ in range(N - 1):
ai, bi = list(map(int, input().split()))
graph[ai - 1].append(bi - 1)
graph[bi - 1].append(ai - 1)
c = [0] * N
for _ in range(Q):
pj, xj = list(map(int, input().split()))
c[pj - 1] += xj
ans = [None] * N
q_0 = deque([(0, 0)])
while len(q_0) > 0:
score, src = q_0.popleft()
# print("#", score, src)
score_tmp = score + c[src]
ans[src] = score_tmp
for dst in graph[src]:
if ans[dst] == None:
q_0.append((score_tmp, dst))
print((' '.join(map(str, ans)))) | p02936 |
import sys
sys.setrecursionlimit(10**6)
def main():
N, Q = list(map(int, input().split()))
E = [[] for i in range(N+1)]
counter = [0] * (N+1)
for i in range(N-1):
a, b = list(map(int, input().split()))
E[a].append(b)
E[b].append(a)
for i in range(Q):
# 頂点p を根とする部分木に含まれるカウンターにxを足す
p, x = list(map(int, input().split()))
counter[p] += x
queue = []
parent = [1]
def mktree(v, parent, E):
children = E[v]
children.remove(parent)
for child in children:
mktree(child, v, E)
while parent:
p = parent.pop()
for child in E[p]:
E[child].remove(p)
parent.append(child)
def get(v, children, counter):
c = counter[v]
for child in children[v]:
counter[child] += c
get(child, children, counter)
"""
parent = [1]
while parent:
p = parent.pop()
c = counter[p]
for child in E[p]:
counter[child] += c
parent.append(child)
"""
get(1, E, counter)
print((" ".join(str(x) for x in counter[1:])))
main()
| import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def main():
N, Q = list(map(int, input().split()))
E = [[] for i in range(N+1)]
counter = [0] * (N+1)
for i in range(N-1):
a, b = list(map(int, input().split()))
E[a].append(b)
E[b].append(a)
for i in range(Q):
# 頂点p を根とする部分木に含まれるカウンターにxを足す
p, x = list(map(int, input().split()))
counter[p] += x
queue = []
parent = [1]
def mktree(v, parent, E):
children = E[v]
children.remove(parent)
for child in children:
mktree(child, v, E)
while parent:
p = parent.pop()
for child in E[p]:
E[child].remove(p)
parent.append(child)
def get(v, children, counter):
c = counter[v]
for child in children[v]:
counter[child] += c
get(child, children, counter)
"""
parent = [1]
while parent:
p = parent.pop()
c = counter[p]
for child in E[p]:
counter[child] += c
parent.append(child)
"""
get(1, E, counter)
print((" ".join(str(x) for x in counter[1:])))
main()
| p02936 |
from collections import deque
n, q = list(map(int, input().split()))
g = [[] for i in range(n)]
k = []
for i in range(n-1):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
for i in range(q):
a,b = list(map(int, input().split()))
k.append([a-1,b])
m = [-1]*n
m[0] = 0
q = deque()
q.append(0)
while len(q):
d = q.popleft()
for i in g[d]:
if m[i] == -1:
m[i] = m[d]+1
q.append(i)
kyori = [[] for i in range(max(m)+1)]
for i,j in enumerate(m):
kyori[j].append(i)
ans= [0]*n
for i,j in k:
t = m[i]
ans[i]+=j
for r in range(t+1,len(kyori)):
for z in kyori[r]:
ans[z]+=j
print((' '.join(map(str,ans)))) | from collections import deque
n, q = list(map(int, input().split()))
g = [[] for i in range(n)]
k = []
for i in range(n-1):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
for i in range(q):
a,b = list(map(int, input().split()))
k.append([a-1,b])
m = [-1]*n
m[0] = 0
m1 = [-1]*n
m1[0] = 0
q = deque()
q.append(0)
while len(q):
d = q.popleft()
for i in g[d]:
if m[i] == -1:
m[i] = m[d]+1
if m1[i] == -1:
m1[i] = d
q.append(i)
kyori = [[] for i in range(max(m)+1)]
for i,j in enumerate(m):
kyori[j].append(i)
ans= [0]*n
for i,j in k:
ans[i]+=j
for i in kyori[1:]:
for j in i:
ans[j] = ans[j] + ans[m1[j]]
print((' '.join(map(str,ans)))) | p02936 |
from collections import deque
n, q = list(map(int, input().split()))
g = [[] for i in range(n)]
k = []
for i in range(n-1):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
for i in range(q):
a,b = list(map(int, input().split()))
k.append([a-1,b])
m = [-1]*n
m[0] = 0
m1 = [-1]*n
m1[0] = 0
q = deque()
q.append(0)
while len(q):
d = q.popleft()
for i in g[d]:
if m[i] == -1:
m[i] = m[d]+1
if m1[i] == -1:
m1[i] = d
q.append(i)
kyori = [[] for i in range(max(m)+1)]
for i,j in enumerate(m):
kyori[j].append(i)
ans= [0]*n
for i,j in k:
ans[i]+=j
for i in kyori[1:]:
for j in i:
ans[j] = ans[j] + ans[m1[j]]
print((' '.join(map(str,ans)))) | from collections import deque
n, q = list(map(int, input().split()))
g = [[] for i in range(n)]
k = []
for i in range(n-1):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
for i in range(q):
a,b = list(map(int, input().split()))
k.append([a-1,b])
m = [-1]*n
m[0] = 0
m1 = [-1]*n
q = deque()
q.append(0)
while len(q):
d = q.popleft()
for i in g[d]:
if m[i] == -1:
m[i] = m[d]+1
m1[i] = d
q.append(i)
kyori = [[] for i in range(max(m)+1)]
for i,j in enumerate(m):
kyori[j].append(i)
ans= [0]*n
for i,j in k:
ans[i]+=j
for i in kyori[1:]:
for j in i:
ans[j] = ans[j] + ans[m1[j]]
print((' '.join(map(str,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)]
eda=[[] for i in range(N+1)]
pt= [0 for i in range(N+1)]
for a,b in AB:
eda[a].append(b)
eda[b].append(a)
for p,x in PX:
pt[p]+=x
eda=[sorted(i) for i in eda]
stack=[[1,eda[1]]]
v=set()
v.add(1)
while stack:
while stack[-1][1]:
a=stack[-1][1].pop()
if not a in v:
v.add(a)
pt[a]+=pt[stack[-1][0]]
stack.append([a,eda[a]])
stack.pop()
print((" ".join(list(map(str,pt[1:])))))
| 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)]
eda=[[] for i in range(N+1)]
pt= [0 for i in range(N+1)]
for a,b in AB:
eda[a].append(b)
eda[b].append(a)
for p,x in PX:
pt[p]+=x
stack=[[1,eda[1]]]
v=set()
v.add(1)
while stack:
while stack[-1][1]:
a=stack[-1][1].pop()
if not a in v:
v.add(a)
pt[a]+=pt[stack[-1][0]]
stack.append([a,eda[a]])
stack.pop()
print((" ".join(list(map(str,pt[1:])))))
| p02936 |
class Node:
def __init__(self):
self.counter = 0
self.childs = []
self.parents = set()
def add_child(self, node):
self.childs.append(node)
def add_parents(self, node):
self.parents.add(node)
N, Q = [int(i) for i in input().split()]
ndic = {}
for i in range(1, N+1):
ndic[i] = Node()
ndic[i].add_child(ndic[i])
for i in range(N-1):
a, b = [int(i) for i in input().split()]
ndic[a].add_child(ndic[b])
ndic[b].add_parents(ndic[a])
for n in ndic[a].parents:
n.add_child(ndic[b])
ndic[b].add_parents(n)
from collections import defaultdict
adddict = defaultdict(int)
for i in range(Q):
p, x = [int(i) for i in input().split()]
adddict[p] += x
for k, v in list(adddict.items()):
if v > 0:
for j in ndic[k].childs:
j.counter += v
ans = ""
for k, v in list(ndic.items()):
ans += str(v.counter) + " "
print((ans[:-1])) | n, q = list(map(int, input().split()))
tree = {i:[] for i in range(1, n + 1)}
for _ in range(1, n):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
cnt = [0]*n
for _ in range(q):
p, x = list(map(int, input().split()))
cnt[p-1] += x
check = [0]*n
tmp = [1]
while len(tmp) != 0:
tmp2 = tmp
tmp = []
for oya in tmp2:
check[int(oya)-1] = 1
for ko in tree[oya]:
if check[ko-1] == 0:
cnt[ko-1] += cnt[oya-1]
tmp.append(ko)
print((" ".join(map(str, cnt)))) | p02936 |
# ABC138D
import sys
sys.setrecursionlimit(1000000000)
def dfs(kol,adj,v,p):
for nv in adj[v]:
if nv==p:
continue
else:
dfs(kol,adj,nv,v)
kol[v]+=[v]
if p!=-1:
kol[p]+=kol[v]
N,Q=map(int,input().split())
adj=[[] for i in range(N)]
for i in range(N-1):
a,b=map(int,input().split())
adj[a-1]+=[b-1]
adj[b-1]+=[a-1]
ct=[0]*N
kol=[[] for i in range(N)]
dfs(kol,adj,0,-1)
for i in range(Q):
p,x=map(int,input().split())
for j in kol[p-1]:
ct[j]+=x
print(ct[0], end="")
for i in range(1,N):
print(" {}".format(ct[i]),end="")
print("")
| # ABC138D
import sys
sys.setrecursionlimit(1000000000)
def dfs(adj,v,p,px,x,ct):
x+=px[v]
for nv in adj[v]:
if nv==p:
continue
else:
dfs(adj,nv,v,px,x,ct)
ct[v]+=x
N,Q=map(int,input().split())
adj=[[] for i in range(N)]
for i in range(N-1):
a,b=map(int,input().split())
adj[a-1]+=[b-1]
adj[b-1]+=[a-1]
px=[0]*N
for i in range(Q):
p,x=map(int,input().split())
px[p-1]+=x
ct=[0]*N
dfs(adj,0,-1,px,0,ct)
print(ct[0], end="")
for i in range(1,N):
print(" {}".format(ct[i]),end="")
print("")
| p02936 |
# ABC138D
import sys
sys.setrecursionlimit(1000000000)
def dfs(adj,v,p,px,x,ct):
x+=px[v]
for nv in adj[v]:
if nv==p:
continue
else:
dfs(adj,nv,v,px,x,ct)
ct[v]+=x
N,Q=map(int,input().split())
adj=[[] for i in range(N)]
for i in range(N-1):
a,b=map(int,input().split())
adj[a-1]+=[b-1]
adj[b-1]+=[a-1]
px=[0]*N
for i in range(Q):
p,x=map(int,input().split())
px[p-1]+=x
ct=[0]*N
dfs(adj,0,-1,px,0,ct)
print(ct[0], end="")
for i in range(1,N):
print(" {}".format(ct[i]),end="")
print("")
| # ABC138D
import sys
input=sys.stdin.readline
sys.setrecursionlimit(1000000000)
def dfs(adj,v,p,px,x,ct):
x+=px[v]
for nv in adj[v]:
if nv==p:
continue
else:
dfs(adj,nv,v,px,x,ct)
ct[v]+=x
def main():
N,Q=map(int,input().split())
adj=[[] for i in range(N)]
for i in range(N-1):
a,b=map(int,input().split())
adj[a-1]+=[b-1]
adj[b-1]+=[a-1]
px=[0]*N
for i in range(Q):
p,x=map(int,input().split())
px[p-1]+=x
ct=[0]*N
dfs(adj,0,-1,px,0,ct)
print(ct[0], end="")
for i in range(1,N):
print(" {}".format(ct[i]),end="")
print("")
if __name__=="__main__":
main()
| p02936 |
import sys
sys.setrecursionlimit(10**7)
def main():
N, Q = [int(i) for i in input().split()]
V = [set() for _ in range(N)]
for _ in range(N - 1):
a, b = [int(i) - 1 for i in input().split()]
V[a].add(b)
V[b].add(a)
C = [0] * N
for _ in range(Q):
p, x = [int(i) for i in input().split()]
C[p - 1] += x
cur = [(0, 0)]
while cur:
nxt = []
for n, x in cur:
C[n] = x = C[n] + x
for c in V[n]:
V[c].remove(n)
nxt.append((c, x))
cur = nxt
print((' '.join(str(c) for c in C)))
main()
| def main():
N, Q = [int(i) for i in input().split()]
V = [set() for _ in range(N)]
for _ in range(N - 1):
a, b = [int(i) - 1 for i in input().split()]
V[a].add(b)
V[b].add(a)
C = [0] * N
for _ in range(Q):
p, x = [int(i) for i in input().split()]
C[p - 1] += x
cur = [(0, 0)]
while cur:
n, x = cur.pop()
C[n] = x = C[n] + x
for c in V[n]:
V[c].remove(n)
cur.append((c, x))
print((' '.join(str(c) for c in C)))
main()
| p02936 |
def main():
N, Q = [int(i) for i in input().split()]
V = [set() for _ in range(N)]
for _ in range(N - 1):
a, b = [int(i) - 1 for i in input().split()]
V[a].add(b)
V[b].add(a)
C = [0] * N
for _ in range(Q):
p, x = [int(i) for i in input().split()]
C[p - 1] += x
cur = [(0, 0)]
while cur:
n, x = cur.pop()
C[n] = x = C[n] + x
for c in V[n]:
V[c].remove(n)
cur.append((c, x))
print((' '.join(str(c) for c in C)))
main()
| def main():
N, Q = [int(i) for i in input().split()]
V = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = [int(i) - 1 for i in input().split()]
V[a].append(b)
V[b].append(a)
C = [0] * N
for _ in range(Q):
p, x = [int(i) for i in input().split()]
C[p - 1] += x
cur = [(0, 0, -1)]
while cur:
n, x, f = cur.pop()
C[n] = x = C[n] + x
for c in V[n]:
if c != f:
cur.append((c, x, n))
print((' '.join(str(c) for c in C)))
main()
| p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
val = [0] * (N)
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
val[p] += x
def dfs(n, pre):
for nxt in G[n]:
if nxt == pre:
continue
val[nxt] += val[n]
dfs(nxt, n)
dfs(0, 0)
answer = ' '.join(map(str, val[:]))
print(answer)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
val = [0] * (N)
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
val[p] += x
used = [False]*N
def dfs(s):
stack = []
stack.append(s)
while len(stack) > 0:
now = stack[-1]
used[now] = True
stack.pop()
for nxt in G[now]:
if used[nxt]:
continue
val[nxt] += val[now]
stack.append(nxt)
dfs(0)
answer = ' '.join(map(str, val[:]))
print(answer)
| p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
val = [0] * (N)
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
val[p] += x
used = [False]*N
def dfs(s):
stack = []
stack.append(s)
while len(stack) > 0:
now = stack[-1]
used[now] = True
stack.pop()
for nxt in G[now]:
if used[nxt]:
continue
val[nxt] += val[now]
stack.append(nxt)
dfs(0)
answer = ' '.join(map(str, val[:]))
print(answer)
| import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
val = [0] * (N)
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
val[p] += x
used = [False]*N
def dfs(s):
stack = []
stack.append(s)
while len(stack) > 0:
now = stack[-1]
used[now] = True
stack.pop()
for nxt in G[now]:
if used[nxt]:
continue
val[nxt] += val[now]
stack.append(nxt)
dfs(0)
answer = ' '.join(map(str, val[:]))
print(answer)
| p02936 |
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
val = [0] * (N)
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
val[p] += x
used = [False]*N
def dfs(s):
stack = []
stack.append(s)
while len(stack) > 0:
now = stack[-1]
used[now] = True
stack.pop()
for nxt in G[now]:
if used[nxt]:
continue
val[nxt] += val[now]
stack.append(nxt)
dfs(0)
answer = ' '.join(map(str, val[:]))
print(answer)
| import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
val = [0] * (N)
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
val[p] += x
def dfs(s):
used = [False]*N
stack = []
stack.append(s)
while len(stack):
now = stack[-1]
used[now] = True
stack.pop()
for nxt in G[now]:
if used[nxt]:
continue
val[nxt] += val[now]
stack.append(nxt)
dfs(0)
answer = ' '.join(map(str, val[:]))
print(answer)
| p02936 |
import sys
input = sys.stdin.readline #入力行数が多いから高速化が必要
sys.setrecursionlimit(int(1E+7))
#小さすぎるデフォルト値を変え再起処理の上限を引き上げる(だいたい1000やから)
def main():
n ,q = list(map(int,input().split()))
link = [[] for i in range(n + 1)]
for i in range(n - 1):
a,b = list(map(int,input().split()))
link[a].append(b)
link[b].append(a)
#print(link)
V = [0] * (n + 1)
for j in range(q):
p, x = list(map(int,input().split()))
V[p] += x
#print(V)
def dfs(i, parent, acc): #深さ優先探索なり
V[i] += acc #親ノードまでの累積値を加算
for j in link[i]:
if j != parent: # 親ノードを追加しない
dfs(j, i, V[i])
cur = 1
parent = 0
acc = 0
dfs(cur, parent, acc) #親ノードを０としてスタート
V = [str(i) for i in V]
print((" ".join(V[1:])))#数字はjoinつかえないので
if __name__ == "__main__":
main()
| #<D>
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
def main():
N, Q = list(map(int ,input().split()))
link = [[] for n in range(N + 1)]
for n in range(N - 1):
a, b = list(map(int, input().split()))
link[a].append(b)
link[b].append(a)
V = [0] * (N + 1)
for q in range(Q):
p, x = list(map(int, input().split()))
V[p] += x
def dfs(i, parent, acc):
V[i] += acc
for j in link[i]:
if j != parent:
dfs(j, i, V[i])
cur = 1
parent = 0
acc = 0
dfs(cur, parent, acc)
V = [str(i) for i in V]
print((" ".join(V[1:])))
if __name__ == "__main__":
main()
| p02936 |
from collections import deque
import sys
sys.setrecursionlimit(10**7)
N, Q = list(map(int, input().split()))
G = [[] for i in range(N)]
for i in range(N-1):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
count = [0 for i in range(N)]
for i in range(Q):
p, x = list(map(int, input().split()))
count[p-1] += x
def dfs(v, p):
if p != -1:
count[v] += count[p]
for next_v in G[v]:
if next_v == p: continue
dfs(next_v, v)
dfs(0, -1)
print((" ".join(map(str, count)))) | from collections import deque
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
G = [[] for i in range(N)]
for i in range(N-1):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
count = [0 for i in range(N)]
for i in range(Q):
p, x = list(map(int, input().split()))
count[p-1] += x
def dfs(v, p):
if p != -1:
count[v] += count[p]
for next_v in G[v]:
if next_v == p: continue
dfs(next_v, v)
dfs(0, -1)
print((" ".join(map(str, count)))) | p02936 |
from collections import deque
N, Q = list(map(int, input().split()))
adj = [[] for _ in range(N + 1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
adj[a].append(b)
adj[b].append(a)
point = [0] * (N + 1)
for _ in range(Q):
p, x = list(map(int, input().split()))
point[p] += x
ans = [0] * (N + 1)
queue = deque()
queue.append(1)
visited = [0] * (N + 1)
visited[1] = 1
while queue:
v = queue.pop()
if v == 1:
ans[v] = point[v]
for u in adj[v]:
if visited[u] == 0:
queue.append(u)
visited[u] = 1
ans[u] = ans[v] + point[u]
print((' '.join(map(str, ans[1:]))))
| from collections import deque
N, Q = list(map(int, input().split()))
adj = [[] for _ in range(N + 1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
adj[a].append(b)
adj[b].append(a)
point = [0] * (N + 1)
for _ in range(Q):
p, x = list(map(int, input().split()))
point[p] += x
ans = [0] * (N + 1)
queue = deque()
queue.append(1)
visited = [0] * (N + 1)
visited[1] = 1
ans[1] = point[1]
while queue:
v = queue.pop()
for u in adj[v]:
if visited[u] == 0:
queue.appendleft(u)
visited[u] = 1
ans[u] = ans[v] + point[u]
print((' '.join(map(str, ans[1:]))))
| p02936 |
from collections import defaultdict
def calc_parents(N, adj_nodes, root=0):
parents = [-1 for _ in range(N)]
frontier = [root]
parents[root] = root
while len(frontier) > 0:
node = frontier.pop()
for child in adj_nodes[node]:
if parents[child] >= 0:
continue
frontier.append(child)
parents[child] = node
return parents
def sum_counts(N, parents, counter_roots):
counter = [0 for _ in range(N)]
for node in range(N):
current_node = node
parent_node = parents[current_node]
s = counter_roots[current_node]
while current_node != parent_node:
current_node = parent_node
parent_node = parents[current_node]
s += counter_roots[current_node]
counter[node] += s
return counter
def main():
N, Q = list(map(int, input().split(' ')))
adj_nodes = defaultdict(list)
for _ in range(N - 1):
a, b = list(map(int, input().split(' ')))
a -= 1
b -= 1
adj_nodes[a].append(b)
adj_nodes[b].append(a)
parents = calc_parents(N, adj_nodes)
counter_roots = [0 for _ in range(N)]
for _ in range(Q):
p, x = list(map(int, input().split(' ')))
p -= 1
counter_roots[p] += x
counter = sum_counts(N, parents, counter_roots)
print((' '.join(map(str, counter))))
if __name__ == '__main__':
main() | from collections import defaultdict
def sum_counter(N, adj_nodes, counter_roots, root=0):
parents = [-1 for _ in range(N)]
counter = [0 for _ in range(N)]
frontier = [root]
counter[root] += counter_roots[root]
parents[root] = root
while len(frontier) > 0:
parent = frontier.pop()
for child in adj_nodes[parent]:
if parents[child] >= 0:
continue
frontier.append(child)
parents[child] = parent
counter[child] += counter[parent] + counter_roots[child]
return counter
def main():
N, Q = list(map(int, input().split(' ')))
adj_nodes = defaultdict(list)
for _ in range(N - 1):
a, b = list(map(int, input().split(' ')))
a -= 1
b -= 1
adj_nodes[a].append(b)
adj_nodes[b].append(a)
counter_roots = [0 for _ in range(N)]
for _ in range(Q):
p, x = list(map(int, input().split(' ')))
p -= 1
counter_roots[p] += x
c = sum_counter(N, adj_nodes, counter_roots)
print((' '.join(map(str, c))))
if __name__ == '__main__':
main()
| p02936 |
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
inpl = lambda: list(map(int,input().split()))
N, Q = inpl()
neighbor = [[] for i in range(N)]
for i in range(N-1):
a, b = inpl()
a -= 1
b -= 1
neighbor[a].append(b)
neighbor[b].append(a)
X = [0] * N
for _ in range(Q):
p, x = inpl()
X[p-1] += x
result = [0] * N
def dfs(node, x, parent):
x += X[node]
result[node] = x
for c in neighbor[node]:
if c == parent:
continue
else:
dfs(c,x,node)
dfs(0, 0, None)
print((' '.join(map(str,result)))) | import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
inpl = lambda: list(map(int,input().split()))
N, Q = inpl()
neighbor = [[] for i in range(N)]
for i in range(N-1):
a, b = inpl()
a -= 1
b -= 1
neighbor[a].append(b)
neighbor[b].append(a)
X = [0] * N
for _ in range(Q):
p, x = inpl()
X[p-1] += x
result = [0] * N
result[0] = X[0]
visited = [False] * N
dfs_stack = [0]
x = 0
while dfs_stack:
node = dfs_stack.pop()
visited[node] = True
for c in neighbor[node]:
if visited[c]:
continue
else:
dfs_stack.append(c)
result[c] = result[node] + X[c]
print((' '.join(map(str,result)))) | p02936 |
from queue import Queue
n , q = list(map(int, input().split()))
lab = []
points = [0]*n
for i in range(n-1):
lab.append(list(map(int, input().split())))
lpx = []
for i in range(q):
lpx.append(list(map(int, input().split())))
lll = []
for i in range(n):
childs = Queue()
inc = []
parent = i+1
childs.put(parent)
while childs.qsize() > 0:
a = childs.get()
inc.append(a)
for k in lab:
if k[0] == a:
childs.put(k[1])
lll.append(list(set(inc)))
for i in lpx:
for j in lll[i[0]-1]:
points[j-1] += i[1]
print((' '.join(map(str, points))))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,Q = list(map(int,input().split()))
aLst = [[int(x) for x in input().split()] for _ in range(N-1)]
pLst = [[int(x) for x in input().split()] for _ in range(Q)]
tmpLst = [[] for _ in range(N+1)]
for i, j in aLst:
tmpLst[i].append(j)
tmpLst[j].append(i)
ansLst = [0] * (N + 1)
for i,j in pLst:
ansLst[i] += j
def dfs(v, p):
for i in tmpLst[v]:
if i == p:
continue
ansLst[i] += ansLst[v]
dfs(i, v)
dfs(1, 0)
ans = ' '.join(map(str, ansLst[1:]))
print(ans)
| p02936 |
import sys
sys.setrecursionlimit(1000000)
s=sys.stdin.readlines()
n,q=list(map(int,s[0].split()))
G=[[]*n for i in range(n)]
P=[0]*n
V=[0]*n
R=[0]*n
for e in s[1:n]:
a,b=list(map(int,e.split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
for e in s[n:]:
c,d=list(map(int,e.split()))
P[c-1]+=d
def dsf(i,p):
V[i]=1
R[i]+=p+P[i]
p=0
if G[i]!=[]:
for j in G[i]:
if V[j]!=1:
dsf(j,R[i])
dsf(0,0)
print((' '.join(map(str,R)))) | import sys
sys.setrecursionlimit(1000000)
s=sys.stdin.readlines()
n,q=list(map(int,s[0].split()))
G=[[]*n for i in range(n)]
P=[0]*n
V=[0]*n
R=[0]*n
for e in s[1:n]:
a,b=list(map(int,e.split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
for e in s[n:]:
c,d=list(map(int,e.split()))
P[c-1]+=d
def dsf(i,p):
V[i]=1
R[i]+=p+P[i]
p=0
for j in G[i]:
if V[j]!=1:
dsf(j,R[i])
dsf(0,0)
print((' '.join(map(str,R)))) | p02936 |
import sys
sys.setrecursionlimit(1000000)
s=sys.stdin.readlines()
n,q=list(map(int,s[0].split()))
G=[[]*n for i in range(n)]
P=[0]*n
V=[0]*n
R=[0]*n
for e in s[1:n]:
a,b=list(map(int,e.split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
for e in s[n:]:
c,d=list(map(int,e.split()))
P[c-1]+=d
def dsf(i,p):
V[i]=1
R[i]+=p+P[i]
p=0
if G[i]!=[]:
for j in G[i]:
if V[j]!=1:
dsf(j,R[i])
dsf(0,0)
print((' '.join(map(str,R)))) | import sys
sys.setrecursionlimit(1000000)
s=sys.stdin.readlines()
n,q=list(map(int,s[0].split()))
G=[[]*n for i in range(n)]
P=[0]*n
V=[0]*n
for e in s[1:n]:
a,b=list(map(int,e.split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
for e in s[n:]:
c,d=list(map(int,e.split()))
P[c-1]+=d
def dsf(i,p):
V[i]=1
P[i]+=p
for j in G[i]:
if V[j]!=1:
dsf(j,P[i])
dsf(0,0)
print((' '.join(map(str,P)))) | p02936 |
# -*- coding: utf-8 -*-
N, Q = list(map(int,input().split()))
Node = [-1] * N
Counter = [0] * N
Result = [0] * N
for i in range(N-1):
a, b = list(map(int,input().split()))
Node[b-1] = a-1
for i in range(Q):
p, x = list(map(int,input().split()))
Counter[p-1] += x
for i in range(N):
p = i
ans = 0
while p >= 0:
ans = ans + Counter[p]
p = Node[p]
Result[i] = ans
print((" ".join(list(map(str,Result)))))
| # -*- coding: utf-8 -*-
N, Q = list(map(int,input().split()))
Node = [-1] * N
Counter = [0] * N
Result = [0] * N
for i in range(N-1):
a, b = list(map(int,input().split()))
Node[b-1] = a-1
for i in range(Q):
p, x = list(map(int,input().split()))
Counter[p-1] += x
for i in range(N):
p = i
ans = 0
while p >= i:
ans += Counter[p]
p = Node[p]
Result[i] = ans
if p >= 0:
Result[i] += Result[p]
print((" ".join(list(map(str,Result)))))
| p02936 |
import sys
input = sys.stdin.readline
n, q = [int(x) for x in input().split()]
edge = [[] for _ in range(n)]
counter = [0] * 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)
for _ in range(q):
a, b = [int(x) for x in input().split()]
counter[a-1] += b
parent = [0]
for i in parent:
for v in edge[i]:
if v in parent:
continue
parent.append(v)
counter[v] += counter[i]
print((" ".join(map(str, counter)))) |
import sys
input = sys.stdin.readline
n, q = [int(x) for x in input().split()]
edge = [[] for _ in range(n)]
counter = [0] * 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)
for _ in range(q):
a, b = [int(x) for x in input().split()]
counter[a-1] += b
parent = [0]
set_parent = {0}
for i in parent:
for v in edge[i]:
if v in set_parent:
continue
set_parent.add(v)
parent.append(v)
counter[v] += counter[i]
print((" ".join(map(str, counter)))) | p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def dfs(G, v, p, C):
"""G: graph, v: vertex, p: parent"""
# Loop for each child
for c in G[v]:
if c == p:
continue
dfs(G, c, v, C)
C[v].extend(C[c])
def main():
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
# Give all children for each parent
C = [[i] for i in range(N)]
dfs(G, 0, -1, C)
point = [0] * N
for i in range(Q):
p, x = list(map(int, input().split()))
p -= 1
children = C[p]
for c in children:
point[c] += x
print((" ".join(map(str, point))))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def dfs(G, v, p, point):
"""G: graph, v: vertex, p: parent"""
# Loop for each child
for c in G[v]:
if c == p:
continue
point[c] += point[v]
dfs(G, c, v, point)
def main():
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
point = [0] * N
for i in range(Q):
p, x = list(map(int, input().split()))
p -= 1
point[p] += x
dfs(G, 0, -1, point)
print((" ".join(map(str, point))))
if __name__ == "__main__":
main()
| p02936 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def dfs(G, v, p, point):
"""G: graph, v: vertex, p: parent"""
# Loop for each child
for c in G[v]:
if c == p:
continue
point[c] += point[v]
dfs(G, c, v, point)
def main():
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
point = [0] * N
for i in range(Q):
p, x = list(map(int, input().split()))
p -= 1
point[p] += x
dfs(G, 0, -1, point)
print((" ".join(map(str, point))))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline # NOQA
sys.setrecursionlimit(10 ** 7) # NOQA
def dfs(G, v, p, counter):
"""G: graph, v: vertex, p: parent"""
# Loop for each child
counter_v = counter[v]
for c in G[v]:
if c == p:
continue # Avoid multiple access to parent
counter[c] += counter_v
dfs(G, c, v, counter)
def main():
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
counter = [0] * N
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
counter[p] += x
dfs(G, 0, -1, counter)
# print(*counter)
print((" ".join(map(str, counter))))
if __name__ == "__main__":
main()
| p02936 |
n,q = list(map(int,input().split()))
hen = [[0,0]]*n
for i in range(n-1) :
hen[i] = list(map(int,input().split()))
xlist = [0]*n
for k in range(q) :
p,x = list(map(int,input().split()))
xlist[p-1] += x
y = [0]*n
for i in range(n) :
y[i] += xlist[i]
r = i
while True :
for j in range(n) :
if hen[j][1] - 1 == r :
r = hen[j][0] - 1
y[i] += xlist[r]
break
if j == n-1 :
break
c = str(y[0])
for i in range(1,n) :
c += ' ' + str(y[i])
print(c)
| n,q = list(map(int,input().split()))
hen = [[0,0]]*(n-1)
for i in range(n-1) :
hen[i] = list(map(int,input().split()))
xlist = [0]*n
for k in range(q) :
p,x = list(map(int,input().split()))
xlist[p-1] += x
#---
hen = sorted(hen, key=lambda x:x[1])
hen = sorted(hen, key=lambda x:x[0])
for i in range(n-1) :
xlist[hen[i][1]-1] += xlist[hen[i][0]-1]
y = xlist.copy()
c = str(y[0])
for i in range(1,n) :
c += ' ' + str(y[i])
print(c) | p02936 |
import sys
sys.setrecursionlimit(10 ** 7)
n, q = map(int, input().split())
ab = [tuple(map(int,input().split())) for i in range(n-1)]
px = [tuple(map(int,input().split())) for i in range(q)]
es = [[] for i in range(n)]
for a,b in ab:
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
visited = [0]*n
ans = [0]*n
# DFS for tree
def dfs(v=0, parent=-1):# どこからきたかの情報を入れとく
for to in es[v]:
if to == parent: continue # 今回はcontinue
if visited[to]: continue
ans[to] += ans[v]
dfs(to, v)
for p, x in px:
ans[p-1] += x
dfs(0)
print(*ans, sep=' ')
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n, q = map(int, input().split())
ab = [tuple(map(int,input().split())) for i in range(n-1)]
px = [tuple(map(int,input().split())) for i in range(q)]
es = [[] for i in range(n)]
for a,b in ab:
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
ans = [0]*n
# DFS for tree (再帰はpypyの方が遅かったりするので注意)
def dfs(v=0, parent=-1):# どこからきたかの情報を入れとく
for to in es[v]:
if to == parent: continue # 今回はcontinue
ans[to] += ans[v]
dfs(to, v)
for p, x in px:
ans[p-1] += x
dfs(0)
print(*ans, sep=' ')
| p02936 |
import sys
sys.setrecursionlimit(10**7)
N, Q = list(map(int, input().split()))
G = [[] for _ in range(N)]
P = [0 for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
for _ in range(Q):
p, x = list(map(int, input().split()))
p -= 1
P[p] += x
def dfs(current, parent):
for child in G[current]:
if child == parent:
continue
P[child] += P[current]
dfs(child, current)
dfs(0, -1)
print((' '.join([str(p) for p in P])))
| import sys
input = sys.stdin.readline #for input speed
sys.setrecursionlimit(10**6) #for deep recursion
N, Q = list(map(int, input().split()))
v = [[] for i in range(N)]
score = [0]*N
def dfs(cur,par):
for chi in v[cur]:
if chi == par:
continue
score[chi] += score[cur]
dfs(chi, cur)
for i in range(N-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
for j in range(Q):
p, x = list(map(int, input().split()))
score[p-1] += x
dfs(0,-1)
score_int=[str(a) for a in score]
output= ' '.join(score_int)
print(output)
| p02936 |
import sys
sys.setrecursionlimit(10**9)
def dfs(now, prev):
ans[now]+=(h[now]+ans[prev])
# 今いる頂点から行ける頂点を順に next に入れてループ
for next in g[now]:
if next != prev:
if memo[next]==True:
# 過去に訪れていれば終わらせる
return False
else:
memo[next] = True
dfs(next, now)
#木構造の取り込み
n, q = list(map(int, input().split()))
g = [[] * n for i in range(n)]
for i in range(n-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
#操作の取り込み
h=[0]*n
for i in range(q):
u, v = list(map(int, input().split()))
u -= 1
h[u]+=v
#初期のカウンター
ans=[0]*n
memo = [False for i in range(n)]
#DFSでカウンターを動かす
dfs(0,0)
print((' '.join(map(str, ans)))) | import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def dfs(now, prev):
ans[now]+=(h[now]+ans[prev])
# 今いる頂点から行ける頂点を順に next に入れてループ
for next in g[now]:
if next != prev:
if memo[next]==True:
# 過去に訪れていれば終わらせる
return False
else:
memo[next] = True
dfs(next, now)
#木構造の取り込み
n, q = list(map(int, input().split()))
g = [[] * n for i in range(n)]
for i in range(n-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
#操作の取り込み
h=[0]*n
for i in range(q):
u, v = list(map(int, input().split()))
u -= 1
h[u]+=v
#初期のカウンター
ans=[0]*n
memo = [False for i in range(n)]
#DFSでカウンターを動かす
dfs(0,0)
print((' '.join(map(str, ans)))) | p02936 |
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def dfs(now, prev):
ans[now]+=(h[now]+ans[prev])
# 今いる頂点から行ける頂点を順に next に入れてループ
for next in g[now]:
if next != prev:
if memo[next]==True:
# 過去に訪れていれば終わらせる
return False
else:
memo[next] = True
dfs(next, now)
#木構造の取り込み
n, q = list(map(int, input().split()))
g = [[] * n for i in range(n)]
for i in range(n-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
#操作の取り込み
h=[0]*n
for i in range(q):
u, v = list(map(int, input().split()))
u -= 1
h[u]+=v
#初期のカウンター
ans=[0]*n
memo = [False for i in range(n)]
#DFSでカウンターを動かす
dfs(0,0)
print((' '.join(map(str, ans)))) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def dfs(now, prev):
ans[now]+=(h[now]+ans[prev])
# 今いる頂点から行ける頂点を順に next に入れてループ
for next in g[now]:
if next != prev:
dfs(next, now)
n, q = list(map(int, input().split()))
g = [[] * n for i in range(n)]
for i in range(n-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
h=[0]*n
for i in range(q):
u, v = list(map(int, input().split()))
u -= 1
h[u]+=v
ans=[0]*n
dfs(0,0)
print((' '.join(map(str, ans)))) | p02936 |
n, q = [int(x) for x in input().split()]
vs = []
us = [1]
xs = None
for _ in range(0, n + 1):
vs.append([])
xs = [0] * (n + 1)
for _ in range(0, n - 1):
a, b = [int(x) for x in input().split()]
vs[a].append(b)
vs[b].append(a)
for _ in range(0, q):
p, x = [int(x) for x in input().split()]
xs[p] += x
for i in range(0, n):
x = xs[us[i]]
for v in vs[us[i]]:
if v not in us:
xs[v] += x
us.append(v)
print((" ".join(str(x) for x in xs[1:])))
| n, q = [int(x) for x in input().split()]
vs = []
for _ in range(0, n + 1):
vs.append([])
xs = [0] * (n + 1)
fs = [False] * (n + 1)
us = [0] * n
fs[1] = True
us[0] = 1
ui = 0
for _ in range(0, n - 1):
a, b = [int(x) for x in input().split()]
vs[a].append(b)
vs[b].append(a)
for _ in range(0, q):
p, x = [int(x) for x in input().split()]
xs[p] += x
for i in range(0, n):
x = xs[us[i]]
for v in vs[us[i]]:
if fs[v] == False:
xs[v] += x
ui += 1
us[ui] = v
fs[v] = True
print((" ".join(str(x) for x in xs[1:])))
| p02936 |
n,q=list(map(int,input().split()))
node=[0 for i in range(n)]
tree=[]
for i in range(n-1):
tree.append(list(map(int,input().split())))
def counter(p,x,cnt):
for i in range(n-1):
if tree[i][0]==p:
if cnt[tree[i][1]-1]!=1:
node[tree[i][1]-1]+=x
cnt[tree[i][1]-1]=1
counter(tree[i][1],x,cnt)
else:
continue
for j in range(q):
cnt=[0 for i in range(n)]
p,x=list(map(int,input().split()))
cnt[p-1]=1
node[p-1]+=x
counter(p,x,cnt)
for i in range(n):
node[i]=str(node[i])
print((' '.join(node)))
| n,q=list(map(int,input().split()))
c=[0 for i in range(n)]
tree=sorted([list(map(int,input().split())) for i in range(n-1)])
for j in range(q):
p,x=list(map(int,input().split()))
c[p-1]+=x
for i in range(n-1):
c[tree[i][1]-1]+=c[tree[i][0]-1]
for i in range(n):
c[i]=str(c[i])
print((' '.join(c)))
| p02936 |
from sys import stdin
import math
import fractions
from collections import deque
from collections import Counter
import itertools
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000)
# N <= 2*10^5
# Q <= 2*10^5
N, Q = [int(x) for x in stdin.readline().rstrip().split()]
#ab = [list(map(int, stdin.readline().rstrip().split())) for _ in range(N-1)]
#px = [list(map(int, stdin.readline().rstrip().split())) for _ in range(Q)]
ans = [0] * (N+1)
child = [[] for _ in range(N+1)]
def add(node, num):
for x in child[node]:
add(x, num)
ans[node] += num
for a, b in [list(map(int, stdin.readline().rstrip().split())) for _ in range(N-1)]:
child[a].append(b)
#print(child)
for p, x in [list(map(int, stdin.readline().rstrip().split())) for _ in range(Q)]:
ii = p
add(p, x)
print(*ans[1:], sep=" ")
| from sys import stdin
import math
import fractions
from collections import deque
from collections import Counter
import itertools
INF = 10 ** 10
# N <= 2*10^5
# Q <= 2*10^5
N, Q = [int(x) for x in stdin.readline().rstrip().split()]
ab = [list(map(int, stdin.readline().rstrip().split())) for _ in range(N-1)]
px = [list(map(int, stdin.readline().rstrip().split())) for _ in range(Q)]
node_value = [0] * (N+1)
parent = [-1] * (N+1)
for a, b in ab:
parent[b] = a
for p, x in px:
node_value[p] += x
#print(parent)
ans = [0] * (N+1)
for i in range(1, N+1):
ans[i] = node_value[i]
if parent[i] != -1:
ans[i] += ans[parent[i]]
print(*ans[1:], sep=" ")
| p02936 |
import sys
sys.setrecursionlimit(10**6)
n,q = list(map(int,input().split()))
a=[[] for i in range(n)]
l=[0 for _ in range(n)]
ans=[0 for _ in range(n)]
def dfs(parent,current,value):
value += l[current]
ans[current] = value
for i in a[current]:
if i == parent:
continue
dfs(current,i,value)
for i in range(n-1):
t1,t2 = list(map(int,input().split()))
a[t1-1].append(t2-1)
a[t2-1].append(t1-1)
for i in range(q):
t1,t2 = list(map(int,input().split()))
l[t1-1]+=t2
dfs(-1,0,0)
print((" ".join(map(str,ans)))) | import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,q = list(map(int,readline().split()))
a=[[] for i in range(n)]
l=[0 for _ in range(n)]
ans=[0 for _ in range(n)]
def dfs(parent,current,value):
value += l[current]
ans[current] = value
for i in a[current]:
if i == parent:
continue
dfs(current,i,value)
for i in range(n-1):
t1,t2 = list(map(int,readline().split()))
a[t1-1].append(t2-1)
a[t2-1].append(t1-1)
for i in range(q):
t1,t2 = list(map(int,readline().split()))
l[t1-1]+=t2
dfs(-1,0,0)
print((" ".join(map(str,ans)))) | p02936 |
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,q = list(map(int,readline().split()))
a=[[] for i in range(n)]
l=[0 for _ in range(n)]
ans=[0 for _ in range(n)]
def dfs(parent,current,value):
value += l[current]
ans[current] = value
for i in a[current]:
if i == parent:
continue
dfs(current,i,value)
for i in range(n-1):
t1,t2 = list(map(int,readline().split()))
a[t1-1].append(t2-1)
a[t2-1].append(t1-1)
for i in range(q):
t1,t2 = list(map(int,readline().split()))
l[t1-1]+=t2
dfs(-1,0,0)
print((" ".join(map(str,ans)))) | import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,q = list(map(int,readline().split()))
a=[[] for i in range(n)]
l=[0]*n
ans=[0]*n
def dfs(parent,current,value):
value += l[current]
ans[current] = value
for i in a[current]:
if i != parent:
dfs(current,i,value)
for i in range(n-1):
t1,t2 = list(map(int,readline().split()))
a[t1-1].append(t2-1)
a[t2-1].append(t1-1)
for i in range(q):
t1,t2 = list(map(int,readline().split()))
l[t1-1]+=t2
dfs(-1,0,0)
print((" ".join(map(str,ans)))) | p02936 |
from collections import deque
N,Q=map(int,input().split())
nondirtree=[[] for _ in range(N)]
dirtree=[[] for _ in range(N)]
rootflag=[0]*N
rootflag[0]=1
for i in range(N-1):
a,b=map(int,input().split())
nondirtree[a-1].append(b-1)
nondirtree[b - 1].append(a - 1)
points=[list(map(int,input().split())) for _ in range(Q)]
#print(points)
v=0
d=deque()
d.append(v)
seen=[0]*N
seen[0]=1
score=[0]*N
while len(d)!=0:
v=d.popleft()
for j in nondirtree[v]:
if seen[j]==0:
dirtree[v].append(j)
seen[j]=1
d.append(j)
#print(d,seen,dirtree)
#input()
for i in range(Q):
d=deque()
v=points[i][0]-1
d.append(v)
while len(d)!=0:
v=d.popleft()
score[v]=score[v]+points[i][1]
for j in dirtree[v]:
d.append(j)
#input()
print(*score,sep=" ")
| from collections import deque
N,Q=map(int,input().split())
nondirtree=[[] for _ in range(N)]
dirtree=[[] for _ in range(N)]
rootflag=[0]*N
rootflag[0]=1
for i in range(N-1):
a,b=map(int,input().split())
nondirtree[a-1].append(b-1)
nondirtree[b - 1].append(a - 1)
points=[list(map(int,input().split())) for _ in range(Q)]
#print(points)
v=0
d=deque()
d.append(v)
seen=[0]*N
seen[0]=1
score=[0]*N
ans=[0]*N
while len(d)!=0:
v=d.popleft()
for j in nondirtree[v]:
if seen[j]==0:
dirtree[v].append(j)
seen[j]=1
d.append(j)
#print(d,seen,dirtree)
#input(
#print(dirtree)
for i in range(Q):
score[points[i][0]-1]=score[points[i][0]-1]+points[i][1]
#print(score)
v=0
d=deque()
d.append(v)
ans[0]=score[0]
while len(d)!=0:
v=d.popleft()
for j in dirtree[v]:
ans[j]=ans[v]+score[j]
d.append(j)
#input()
#print(ans)
print(*ans,sep=" ")
| p02936 |
import itertools
while 1:
n=int(eval(input()))
if n==0:break
l=[int(eval(input())) for _ in range(n)]
print((sum([sum(sorted(l)[:len(l)-1][:i]) for i in range(1,len(l))])))
| import itertools
while 1:
n=int(eval(input()))
if n==0:break
l=[int(eval(input())) for _ in range(n)]
ll=len(l)
m=sorted(l)[:ll-1]
print((sum([sum(m[:i]) for i in range(1,ll)])))
| p00112 |
while True:
n = int(eval(input()))
if not n:
break
else:
lst = [int(eval(input())) for _ in range(n)]
lst.sort()
acc = ans = 0
for i in lst:
ans += acc
acc += i
print(ans)
| while True:
n = int(eval(input()))
if not n:
break
lst = sorted([int(eval(input())) for _ in range(n)])
print((sum([(n - i - 1) * lst[i] for i in range(n)])))
| p00112 |
while 1:
n = eval(input())
if n == 0: break
que = sorted([int(input()) for i in range(n)])
print(sum([sum(que[:i]) for i in range(1,n)])) | while 1:
n = eval(input())
if n == 0: break
q = sorted([int(input()) for i in range(n)])
t = [0]*n
for i in range(1,n):
t[i] = t[i-1] + q[i-1]
print(sum(t)) | p00112 |
while 1:
n=eval(input())
if n==0: break
x=sorted([eval(input()) for _ in [0]*n])
s=0
a=0
for e in x[:-1]: a+=e; s+=a
print(s) | while 1:
n=eval(input())
if n==0: break
x=sorted([int(input()) for _ in [0]*n])
s=0
a=0
for e in x[:-1]: a+=e; s+=a
print(s) | p00112 |
while 1:
n=int(input())
if n==0: break
x=sorted([int(input()) for _ in [0]*n])
s=0
a=0
for e in x[:-1]: a+=e; s+=a
print(s) | while 1:
n=int(input())
if n==0: break
x=sorted(map(int,[input() for _ in [0]*n]))
s=a=0
for e in x[:-1]: a+=e; s+=a
print(s) | p00112 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
v = []
for i in range(5):
v.append(I())
# 全探索？
# 1の位が一に一番近いものを求める
str_v = [str(i) for i in v]
min_first_digit = None
for sidx, s in enumerate(str_v):
if s[-1] == '0':
continue
if min_first_digit == None:
min_first_digit = [sidx , s[-1]]
continue
if s[-1] < min_first_digit[1]:
min_first_digit = [sidx, s[-1]]
if min_first_digit == None:
print(sum(v))
else:
result = 0
for vidx, item in enumerate(v):
if vidx != min_first_digit[0]:
result += item
if item % 10 != 0:
result += 10 - item % 10
result += v[min_first_digit[0]]
print(result)
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
dishes=[I() for i in range(0,5)]
rounded = []
for i in dishes:
if i%10 != 0:
i += 10 - i % 10
rounded.append(i)
result=10**10
for i in range(len(dishes)):
# order i in the end
result = min(result, sum([r for ridx, r in enumerate(rounded) if ridx != i]) + dishes[i])
print(result)
| p03076 |
import math
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
ceil = lambda number: math.ceil(number / 10) * 10
minutes = [A, B, C, D, E]
ceiled_minutes = list(map(ceil, minutes))
maximum_diff = 0
for minute in minutes:
ceiled = ceil(minute)
diff = ceiled - minute
if diff == 0: continue
if maximum_diff is None or diff > maximum_diff:
maximum_diff = diff
answer = sum(ceiled_minutes) - maximum_diff
print(answer)
| import math
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
ceil = lambda number: math.ceil(number / 10) * 10
minutes = [A, B, C, D, E]
ceiled_minutes = list(map(ceil, minutes))
minimum = 10
for minute in minutes:
digit_1st = minute % 10
if digit_1st == 0: continue
if minimum is None or digit_1st < minimum:
minimum = digit_1st
diff = 10 - minimum
answer = sum(ceiled_minutes) - diff
print(answer)
| p03076 |
a = [ int(eval(input())) for _ in range(5)]
n = float("inf")
for i in range(5):
if 0 < a[i] % 2 < 10:
n = min(n,a[i] % 10)
else:
if n == float("inf"):
n = 10
print((sum([(-a[i]//10)*-10 for i in range(5)]) -(10-n))) | a = [int(eval(input())) for _ in range(5)]
b = 10-min([a[i]%10 for i in range(5) if 0 < a[i]%10] or [10])
print((sum([(-(-a[i]//10)) for i in range(5)])*10-b)) | p03076 |
A = sorted( [input()[::-1] for i in range(5)] )
while (A[0][0] == "0"):
tmp = A.pop(0)
A.append(tmp)
A = [int(a[::-1]) for a in A][::-1]
def roundUp(n):
return n if n%10==0 else n + (10-n%10)
print((sum([roundUp(A[i]) for i in range(4)]) + A[4]))
| A = sorted( [input()[::-1] for i in range(5)] )
c = 0
while (A[0][0] == "0" and c<5):
tmp = A.pop(0)
A.append(tmp)
c+=1
A = [int(a[::-1]) for a in A][::-1]
def roundUp(n):
return n if n%10==0 else n + (10-n%10)
print((sum([roundUp(A[i]) for i in range(4)]) + A[4]))
| p03076 |
from itertools import permutations
l = [int(eval(input())) for _ in range(5)]
minT = 10000
for a in permutations(l,5):
t = 0
for dish in a:
if t%10 != 0:
t += 10 - t%10
t += dish
minT = min(minT,t)
print(minT)
|
a = [int(eval(input())) for _ in range(5)]
b = []
for i in range(len(a)):
if a[i] % 10 == 0:
b.append(0)
else:
b.append(10 - (a[i] % 10))
c = b.index(max(b))
ans = 0
for i in range(5):
if i !=c:
if a[i] % 10 == 0:
ans += a[i]
else:
ans += ((a[i] // 10) + 1) * 10
print((ans+a[c]))
| p03076 |
A=list(int(eval(input()))for i in range(5))
ans=0
num=0
com=0
for a in A:
if a%10==0:
ans+=a
else:
tmp=10-a%10
ans+=(a//10+1)*10
if com<tmp:
com=tmp
num=a
if num==0:
print(ans)
else:
ans-=(num//10+1)*10
ans+=num
print(ans)
| A=list(int(eval(input()))for i in range(5))
B=[a-a%10+10 if a%10!=0 else a for a in A]
diff=[(b-a)for a,b in zip(A,B)]
print((sum(B)-max(diff)))
| p03076 |
from itertools import permutations
foods = [int(eval(input())) for i in range(5)]
ans = 1230
for i in permutations(foods):
tmp = 0
for j in range(4):
tmp += -(-i[j] // 10)
tmp *= 10
tmp += i[4]
ans = min(ans, tmp)
print(ans) | foods = [int(eval(input())) for i in range(5)]
amari = [i % 10 for i in foods]
kiriage = [-(-i//10) for i in foods]
min_amari = 10
for i in amari:
if 1 <= i < min_amari:
min_amari = i
print((sum(kiriage) * 10 - (10 - (10 if max(amari) == 0 else min_amari)))) | p03076 |
#!/usr/bin/env python3
import re
a = []
b = []
for i in range(5):
x = int(eval(input()))
a.append(x)
x = x%10
b.append(x)
count = 0
min = 123
k = 0
for i in range(5):
if(b[i] != 0 and min > b[i]):
min = b[i]
k = i
for i in range(5):
if(i != k and b[i] != 0):
count += a[i] + 10 - b[i]
elif(i == k or b[i] == 0):
count += a[i]
print(count)
| #!/usr/bin/env python3
#ABC123 B
LI = [int(eval(input())) for _ in range(5)]
LI2 = [LI[i] % 10 for i in range(5)]
x = [(LI[i],LI2[i]) for i in range(5)]
#print(x)
ans = 0
x = sorted(x, key = lambda x:x[1],reverse = True)
for i in range(5):
if x[i][1] == 0:
t = x[i]
x.remove(t)
x.insert(0,t)
#print(x)
for i in range(4):
if x[i][1] != 0:
ans += x[i][0] + (10 - x[i][1])
else:
ans += x[i][0]
ans += x[4][0]
print(ans) | p03076 |
a=int(eval(input()))
b=int(eval(input()))
c=int(eval(input()))
d=int(eval(input()))
e=int(eval(input()))
l=[a,b,c,d,e]
ansl=[]
import itertools
for v in itertools.permutations(l,5):
orderl=list(v)
#print(orderl)
t=0
for order_time in orderl:
if t%10!=0:
t=((t//10)+1)*10
t+=order_time
ansl.append(t)
print((min(ansl))) | tl=[int(eval(input())) for i in range(5)]
import itertools
ansl=[]
for tup in itertools.permutations(tl):
t=list(tup)
c=0
for i in range(4):
c+=t[i]
if c%10!=0:
c=(c//10 +1)*10
ansl.append(c+t[-1])
print((min(ansl))) | p03076 |
a=int(eval(input()))
b=int(eval(input()))
c=int(eval(input()))
d=int(eval(input()))
e=int(eval(input()))
def time(x):
return (x+9)//10*10
def last(x):
return time(x)-x
sum_time=time(a)+time(b)+time(c)+time(d)+time(e)
ans=sum_time-max(last(a),last(b),last(c),last(d),last(e))
print(ans) | a=int(eval(input()))
b=int(eval(input()))
c=int(eval(input()))
d=int(eval(input()))
e=int(eval(input()))
def time(x):
return (x+9)//10*10
def last(x):
return time(x)-x
sum_tim=time(a)+time(b)+time(c)+time(d)+time(e)
ans=sum_tim-max(last(a),last(b),last(c),last(d),last(e))
print(ans) | p03076 |
def round_up(i):
if i % 10 == 0:
return i
return 10 - i % 10 + i
minutes = [int(eval(input())) for i in range(5)]
m = [round_up(i) for i in minutes]
last = min((minutes[l] - 1) % 10 for l in range(5)) + 1
print((sum(m) + last - 10))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()
arr = [i_i() for _ in range(5)]
arr.sort(key=lambda a: a%10)
flag = True
ans = 0
for x in arr:
if flag and x % 10 >= 1:
ans += x
flag = False
else:
if x % 10 != 0:
ans += (x + 10) // 10 * 10
else:
ans += x // 10 * 10
print(ans) | p03076 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.