input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
sys.setrecursionlimit(10 ** 7)
class Tree:
C, RL = {}, {}
R, N, D, S, P, T = None, None, None, None, None, None
TL = None
def __init__(s, num):
s.N = num
def set(s, a, b):
if a in s.C: s.C[a].append(b)
else: s.C[a] = [b]
if b in s.C: s.C[b].append(a)
else: s.C[b] = [a]
def makeRank(s, root):
s.R = [0] * s.N #各ノードのランク
s.R[root] = 1
s.RL[1] = [root] #各ランクのノード
s.S = {} #各ノードの子ノード
s.P = [-1] * s.N #各ノードの親ノード
F = [root]
s.D = 2
while F != []:
Ft = []
s.RL[s.D] = []
for i in F:
for j in s.C[i]:
if s.R[j] == 0:
s.R[j] = s.D
Ft.append(j)
s.RL[s.D].append(j)
if i not in s.S:
s.S[i] = [j]
else:
s.S[i].append(j)
s.P[j] = i
s.D += 1
F = Ft
def dfs(s, x, y, r): #xからyまでの道O(M)
if x == y:
return [x]
for i in s.C[x]:
if i != r:
t = s.dfs(i, y, x)
if t != False:
return [x] + t
return False
def dist(s, x): #最遠のノード,距離
t = [-1] * s.N
S = [x]
ans = x
ansn = 0
t[x] = 0
while S != []:
k = S.pop()
for i in s.C[k]:
if t[i] == -1:
t[i] = t[k] + 1
S.append(i)
if t[i] > ansn:
ansn = t[i]
ans = i
return ans, ansn
def getDi(s, x = 0): #直径
a, _ = s.dfs(x)
b, ans = s.dfs(a)
return ans
def getDeep(s, x): #xの子孫のうち一番深い深さ
ans = 0
if x in s.S:
for i in s.S[x]:
ans = max(ans, s.getDeep(i))
return ans + 1
else:
return 0
def getParent(s, x, n): #xのn世代前の親
if n == 0:
return x
if s.P[x] == -1:
return -n
return s.getParent(s.P[x], n - 1)
def tour(s): #オイラーツアー
x = s.RL[1][0]
s.T = [] #ツアー
s.TL = [[] for _ in range(s.N)] #各ノードの出現位置
s.TL[x].append(len(s.T))
s.T.append(x)
for i in (s.S[s.RL[1][0]]):
s.tour_sub(i)
return s.T
def tour_sub(s, x): #オイラーツアーのサブ
s.TL[x].append(len(s.T))
s.T.append(x)
if x in s.S:
for i in (s.S[x]):
s.tour_sub(i)
s.TL[s.P[x]].append(len(s.T))
s.T.append(s.P[x])
def bottomUpDP(s):
s.dp_init()
for i in range(s.D - 1, 0, -1):
T = s.RL[i]
for j in T:
s.dp_sub(j)
def allDP(s):
bDP = s.bottomUpDP()
for i in range(2, s.D):
T = s.RL[i]
for j in T:
s.dp_sub_exe_inv(j, s.P[j])
def dp_init(s): #単位元で初期化
s.DP = [1] * N
s.sDP = [1] * N
def dp_sub(s, x):
if x not in s.S:
return 0
T = s.S[x]
for i in T:
s.dp_sub_exe(x, i)
def dp_sub_exe(s, x, y): #ボトムアップの処理
s.sDP[x] += s.sDP[y]
s.DP[x] = s.DP[x] * s.DP[y] * com.com(s.sDP[x] - 1, s.sDP[y]) % MOD
def dp_sub_exe_inv(s, x, y): #トップダウンの処理
t = com.com(s.sDP[y] - 1, s.sDP[x]) * s.DP[x] % MOD
t = s.DP[y] * s.inv(t, MOD)
k = s.sDP[y] - s.sDP[x]
k = com.com(s.sDP[y] - 1, k) % MOD
s.sDP[x] = s.sDP[y]
s.DP[x] = s.DP[x] * t * k % MOD
return
def inv(s, a, mod): #逆元
return pow(a, mod - 2, mod)
class comb():
F = [1, 1]
Fi = [1, 1]
I = [0, 1]
def __init__(self, num, mod):
self.MOD = mod
for i in range(2, num + 1):
self.F.append((self.F[-1] * i) % mod)
self.I.append(mod - self.I[mod % i] * (mod // i) % mod)
self.Fi.append(self.Fi[-1] * self.I[i] % mod)
def com(self, n, k):
if n < k: return 0
if n < 0 or k < 0: return 0
return self.F[n] * (self.Fi[k] * self.Fi[n - k] % self.MOD) % self.MOD
N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N - 1)]
MOD = 10 ** 9 + 7
com = comb(N, MOD)
T = Tree(N)
for a, b in ab:
a -= 1
b -= 1
T.set(a, b)
T.makeRank(0)
T.allDP()
for i in T.DP:
print(i) | import sys
sys.setrecursionlimit(10 ** 7)
class Tree:
C, RL = {}, {}
R, N, D, S, P, T = None, None, None, None, None, None
TL = None
def __init__(s, num):
s.N = num
def set(s, a, b):
if a in s.C: s.C[a].append(b)
else: s.C[a] = [b]
if b in s.C: s.C[b].append(a)
else: s.C[b] = [a]
def makeRank(s, root):
s.R = [0] * s.N #各ノードのランク
s.R[root] = 1
s.RL[1] = [root] #各ランクのノード
s.S = {} #各ノードの子ノード
s.P = [-1] * s.N #各ノードの親ノード
s.D = 1
while s.RL[s.D] != []:
s.D += 1
s.RL[s.D] = []
for i in s.RL[s.D - 1]:
for j in s.C[i]:
if s.R[j] == 0:
s.R[j] = s.D
s.RL[s.D].append(j)
if i not in s.S: s.S[i] = [j]
else: s.S[i].append(j)
s.P[j] = i
def bottomUpDP(s):
for i in range(s.D - 2, 0, -1):
T = s.RL[i]
for j in T:
if j not in s.S: continue
for k in s.S[j]:
s.dp_sub_exe(j, k)
def topDownDP(s):
for i in range(2, s.D):
T = s.RL[i]
for j in T:
s.dp_sub_exe_inv(j, s.P[j])
def allDP(s):
s.dp_init()
s.bottomUpDP()
s.topDownDP()
return s.DP
def dp_init(s): #単位元で初期化
s.DP = [1] * N
s.sDP = [1] * N
def dp_sub_exe(s, x, y): #ボトムアップの処理
s.sDP[x] += s.sDP[y]
s.DP[x] = s.DP[x] * s.DP[y] * com.com(s.sDP[x] - 1, s.sDP[y]) % MOD
def dp_sub_exe_inv(s, x, y): #トップダウンの処理
t = com.com(s.sDP[y] - 1, s.sDP[x]) * s.DP[x] % MOD
t = s.DP[y] * s.inv(t, MOD)
k = s.sDP[y] - s.sDP[x]
k = com.com(s.sDP[y] - 1, k) % MOD
s.sDP[x] = s.sDP[y]
s.DP[x] = s.DP[x] * t * k % MOD
def inv(s, a, mod): #逆元
return pow(a, mod - 2, mod)
class comb():
F = [1, 1]
Fi = [1, 1]
I = [0, 1]
def __init__(self, num, mod):
self.MOD = mod
for i in range(2, num + 1):
self.F.append((self.F[-1] * i) % mod)
self.I.append(mod - self.I[mod % i] * (mod // i) % mod)
self.Fi.append(self.Fi[-1] * self.I[i] % mod)
def com(self, n, k):
if n < k: return 0
if n < 0 or k < 0: return 0
return self.F[n] * (self.Fi[k] * self.Fi[n - k] % self.MOD) % self.MOD
N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N - 1)]
MOD = 10 ** 9 + 7
com = comb(N, MOD)
T = Tree(N)
for a, b in ab:
a -= 1
b -= 1
T.set(a, b)
T.makeRank(0)
DP = T.allDP()
for i in DP:
print(i) | p02728 |
def rerooting(n, edges, identity, merge, add_node):
# 全方位木 dp
# 参考: https://qiita.com/keymoon/items/2a52f1b0fb7ef67fb89e
G = [[] for _ in range(n)]
G_idxs = [[] for _ in range(n)] # 自分を指すノードのインデックス
for a, b in edges:
G_idxs[a].append(len(G[b]))
G_idxs[b].append(len(G[a]))
G[a].append(b)
G[b].append(a)
# step 1
parents = [0] * n
order = [] # 行きがけ順
stack = [0]
parents[0] = -1
while stack:
v = stack.pop()
p = parents[v]
order.append(v)
for u in G[v]:
if p != u:
stack.append(u)
parents[u] = v
subtree_res = [[0]*len(Gv) for Gv in G]
# 下から登る
for v in order[:0:-1]:
p = parents[v]
result = identity
for idx_Gv, (u, subtree_res_v_i) in enumerate(zip(G[v], subtree_res[v])):
if p == u:
parent_idx = idx_Gv
else:
result = merge(result, subtree_res_v_i)
idx_p2v = G_idxs[v][parent_idx]
subtree_res[p][idx_p2v] = add_node(result, v)
# step 2
# 上から降りる
results = [0] * n
for v in order:
subtree_res_v = subtree_res[v]
cum = identity
cum_from_tail = [identity]
for r in subtree_res_v[:0:-1]:
cum = merge(r, cum)
cum_from_tail.append(cum)
cum_from_tail.reverse()
cum = identity
for r, cum_t, u, idx_u2v in zip(subtree_res_v, cum_from_tail, G[v], G_idxs[v]):
result = add_node(merge(cum, cum_t), v)
subtree_res[u][idx_u2v] = result
cum = merge(cum, r)
results[v] = add_node(cum, v)
return results
class Combination:
def __init__(self, n_max, mod=10**9+7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1):
f = f * i % mod
fac.append(f)
f = pow(f, mod-2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
def __call__(self, n, r): # self.C と同じ
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
N = int(eval(input()))
AB = [list([int(x)-1 for x in input().split()]) for _ in range(N-1)]
mod = 10**9 + 7
comb = Combination(202020)
identity = (1, 0)
merge = lambda a, b: (a[0] * b[0] % mod * comb(a[1]+b[1], a[1]) % mod, a[1] + b[1])
add_node = lambda value, idx: (value[0], value[1]+1)
Ans = rerooting(N, AB, identity, merge, add_node)
print(("\n".join(str(ans) for ans, _ in Ans)))
| def rerooting(n, edges, identity, merge, add_node):
# 全方位木 dp
# 参考: https://qiita.com/keymoon/items/2a52f1b0fb7ef67fb89e
G = [[] for _ in range(n)]
G_idxs = [[] for _ in range(n)] # 自分を指すノードのインデックス
for a, b in edges:
G_idxs[a].append(len(G[b]))
G_idxs[b].append(len(G[a]))
G[a].append(b)
G[b].append(a)
# step 1
parents = [0] * n
order = [] # 行きがけ順
stack = [0]
parents[0] = -1
while stack:
v = stack.pop()
p = parents[v]
order.append(v)
for u in G[v]:
if p != u:
stack.append(u)
parents[u] = v
subtree_res = [[0]*len(Gv) for Gv in G]
# 下から登る
for v in order[:0:-1]:
p = parents[v]
result = identity
for idx_Gv, (u, subtree_res_v_i) in enumerate(zip(G[v], subtree_res[v])):
if p == u:
parent_idx = idx_Gv
else:
result = merge(result, subtree_res_v_i)
idx_p2v = G_idxs[v][parent_idx]
subtree_res[p][idx_p2v] = add_node(result, v)
# step 2
# 上から降りる
results = [0] * n
for v in order:
subtree_res_v = subtree_res[v]
cum = identity
cum_from_tail = [identity]
for r in subtree_res_v[:0:-1]:
cum = merge(r, cum)
cum_from_tail.append(cum)
cum_from_tail.reverse()
cum = identity
for r, cum_t, u, idx_u2v in zip(subtree_res_v, cum_from_tail, G[v], G_idxs[v]):
result = add_node(merge(cum, cum_t), v)
subtree_res[u][idx_u2v] = result
cum = merge(cum, r)
results[v] = add_node(cum, v)
return results
class Combination:
def __init__(self, n_max, mod=10**9+7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1):
f = f * i % mod
fac.append(f)
f = pow(f, mod-2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
def __call__(self, n, r): # self.C と同じ
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def main():
N = int(eval(input()))
AB = [list([int(x)-1 for x in input().split()]) for _ in range(N-1)]
mod = 10**9 + 7
comb = Combination(202020)
identity = (1, 0)
merge = lambda a, b: (a[0] * b[0] % mod * comb(a[1]+b[1], a[1]) % mod, a[1] + b[1])
add_node = lambda value, idx: (value[0], value[1]+1)
Ans = rerooting(N, AB, identity, merge, add_node)
print(("\n".join(str(ans) for ans, _ in Ans)))
main()
| p02728 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n =I()
G = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = LI()
G[a - 1] += [b - 1]
G[b - 1] += [a - 1]
fac = [1] * (n + 1)
inv = [1] * (n + 1)
for j in range(1, n + 1):
fac[j] = fac[j-1] * j % mod
inv[n] = pow(fac[n], mod-2, mod)
for j in range(n-1, -1, -1):
inv[j] = inv[j+1] * (j+1) % mod
def comb(n, r):
if r > n or n < 0 or r < 0:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
v_num = [-1] * n
par = [-1] * n
def f(u):
ret = 1
for v in G[u]:
if v == par[u]:
continue
par[v] = u
ret += f(v)
v_num[u] = ret
if u: return ret
f(0)
dp = [0] * n
def tree_dp(x):
c = 1
remain_v = v_num[x] - 1
for y in G[x]:
if y == par[x]:
continue
c = c * tree_dp(y) * comb(remain_v, v_num[y]) % mod
remain_v -= v_num[y]
dp[x] = c
if x: return c
tree_dp(0)
ans = [0] * n
def dfs(d):
e = 1
inv_e = pow(comb(n - 1, v_num[d]) * dp[d], mod - 2, mod)
ans[d] = dp[d] * ans[par[d]] * comb(n - 1, v_num[d] - 1) * inv_e % mod
q = deque([0])
ans[0] = dp[0]
while q:
g = q.pop()
for h in G[g]:
if h == par[g]:
continue
dfs(h)
q += [h]
for j in ans:
print(j)
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod=10**9+7
n=I()
fac = [1] * (n + 1)
inv = [1] * (n + 1)
for j in range(1, n + 1):
fac[j] = fac[j-1] * j % mod
inv[n] = pow(fac[n], mod-2, mod)
for j in range(n-1, -1, -1):
inv[j] = inv[j+1] * (j+1) % mod
def comb(n, r):
if r > n or n < 0 or r < 0:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
G=[[]for _ in range(n)]
for _ in range(n-1):
a,b=LI()
G[a-1]+=[b-1]
G[b-1] += [a-1]
cnt=[-1]*n
par=[-1]*n
def f(x):
ret=1
for y in G[x]:
if par[x]==y:
continue
par[y]=x
ret+=f(y)
cnt[x]=ret
return ret
f(0)
D=[0]*n
def tree_dp(x):
c = 1
remain_v = cnt[x] - 1
for y in G[x]:
if y == par[x]:
continue
c = c * tree_dp(y) * comb(remain_v, cnt[y]) % mod
remain_v -= cnt[y]
D[x] = c
if x: return c
tree_dp(0)
ans=[0]*n
ans[0]=D[0]
q=deque([0])
while q:
e=q.pop()
for d in G[e]:
if d==par[e]:
continue
ans[d]=pow(comb(n-1,cnt[d])*D[d],mod-2,mod)*ans[e]*comb(n-1,cnt[d]-1)*D[d]%mod
q+=[d]
print(*ans,sep="\n")
| p02728 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
vec = [[] for _ in range(N)]
for _ in range(N - 1) :
a, b = list(map(int, input().split()))
vec[a - 1].append(b - 1)
vec[b - 1].append(a - 1)
mod = 10 ** 9 + 7
fac = [1]
for i in range(1, N + 1) :
fac.append(fac[-1] * i)
inv = [pow(fac[-1], mod - 2, mod)]
for i in range(N, 0, -1) :
inv.append(inv[-1] * i % mod)
inv = inv[::-1]
def comb(n, r) :
return fac[n] * inv[n-r] * inv[r] % mod
pattern = [1] * N
subtree = [0] * N
# DFS
stack = [(0, -1, 0)]
while stack :
cur, pre, op = stack.pop()
if op == 0 :
stack.append((cur, pre, 1))
for nex in vec[cur] :
if nex == pre : continue
stack.append((nex, cur, 0))
else :
for nex in vec[cur] :
pattern[cur] *= pattern[nex] * comb(subtree[cur] + subtree[nex], subtree[nex]) % mod
pattern[cur] %= mod
subtree[cur] += subtree[nex]
subtree[cur] += 1
# BFS
q = [(0, -1)]
while q :
cur, pre = q.pop()
for nex in vec[cur] :
if nex == pre : continue
pattern[nex] = pattern[cur] * subtree[nex] * inv[N - subtree[nex]] * fac[N - subtree[nex] - 1] % mod
q.append((nex, cur))
for i in range(N) :
print((pattern[i])) | import sys
input = sys.stdin.readline
N = int(eval(input()))
vec = [[] for _ in range(N)]
for _ in range(N - 1) :
a, b = list(map(int, input().split()))
vec[a - 1].append(b - 1)
vec[b - 1].append(a - 1)
mod = 10 ** 9 + 7
fac = [1]
for i in range(1, N + 1) :
fac.append(fac[-1] * i % mod)
inv = [pow(fac[-1], mod - 2, mod)]
for i in range(N, 0, -1) :
inv.append(inv[-1] * i % mod)
inv = inv[::-1]
def comb(n, r) :
return fac[n] * inv[n-r] * inv[r] % mod
pattern = [1] * N
subtree = [0] * N
# DFS
stack = [(0, -1, 0)]
while stack :
cur, pre, op = stack.pop()
if op == 0 :
stack.append((cur, pre, 1))
for nex in vec[cur] :
if nex == pre : continue
stack.append((nex, cur, 0))
else :
for nex in vec[cur] :
pattern[cur] *= pattern[nex] * comb(subtree[cur] + subtree[nex], subtree[nex]) % mod
pattern[cur] %= mod
subtree[cur] += subtree[nex]
subtree[cur] += 1
# BFS
queue = [(0, -1)]
while queue :
cur, pre = queue.pop()
for nex in vec[cur] :
if nex == pre : continue
pattern[nex] = pattern[cur] * subtree[nex] * inv[N - subtree[nex]] * fac[N - subtree[nex] - 1] % mod
queue.append((nex, cur))
for i in range(N) :
print((pattern[i])) | p02728 |
def main():
n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in [0]*(n-1)]
g = [[] for _ in [0]*n]
[g[a-1].append(b-1) for a, b in ab]
[g[b-1].append(a-1) for a, b in ab]
mod = 10**9+7
fact = [1, 1]
for i in range(2, n+1):
fact.append(fact[-1]*i % mod)
def inv_n(n):
return pow(n, mod-2, mod)
def nCr(n, r, mod=10**9+7):
return pow(fact[n-r]*fact[r] % mod, mod-2, mod)*fact[n] % mod
class rerooting():
# addは頂点iに頂点jを根とする部分木（DPの値：x）をくっつけるときの補正
def __init__(self, tree, ini):
# merge:頂点aにbをマージするときのモノイド
# adj_bu:ボトムアップ時の調整（a:値,i:頂点）
# adj_td:トップダウン時の調整（a:値,i:頂点,p:親）
# adj_fin:最終調整（a:値,i:頂点）
def merge(a, b): return a * b % mod
def adj_bu(a, i): return a * inv_n(size[i]) % mod
def adj_td(a, i, p): return a * inv_n(n-size[i]) % mod
def adj_fin(a, i): return a * fact[n-1] % mod
# トポロジカルソートをする
# T:木の隣接グラフ表現をset化
# P:親
# q:キュー
# order:トポソしたもの
T = [set(i) for i in tree]
P = [-1]*n
q = [0]
order = []
while q:
i = q.pop()
order.append(i)
for a in T[i]:
if a != P[i]:
P[a] = i
T[a].remove(i)
q.append(a)
# Tをリストに変換
T = [list(i) for i in T]
# サイズの処理を先に行う
# size[i]:0を根とする根付き木における、iを根とする部分木の大きさ
size = [1]*n
for i in order[1:][::-1]:
size[P[i]] += size[i]
# ボトムアップ処理をする
# ME:マージした値を一時保存
# DP:DP値、MEを調整したもの
ME = [ini]*n
DP = [0]*n
for i in order[1:][::-1]:
DP[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], DP[i])
DP[order[0]] = adj_fin(ME[order[0]], order[0])
TD = [ini]*n
# トップダウン処理をする
for i in order:
# 左からDP（結果はTDに入れている）
ac = TD[i]
for j in T[i]:
TD[j] = ac
ac = merge(ac, DP[j])
# 右からDP（結果はacに入れている、一度しか使わないのでacで問題ない）
ac = ini
for j in T[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, DP[j])
DP[j] = adj_fin(merge(ME[j], TD[j]), j)
for i in DP:
print(i)
rerooting(g, 1)
main() | def main():
from sys import stdin
input = stdin.readline
n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in [0]*(n-1)]
g = [set() for _ in [0]*n]
for a, b in ab:
g[a-1].add(b-1)
g[b-1].add(a-1)
mod = 10**9+7
fact = [1, 1]
inv = [pow(i, mod-2, mod) for i in range(n+1)]
for i in range(2, n+1):
fact.append(fact[-1]*i % mod)
class rerooting():
# addは頂点iに頂点jを根とする部分木（DPの値：x）をくっつけるときの補正
def __init__(self, tree, ini):
# merge:頂点aにbをマージするときのモノイド
# adj_bu:ボトムアップ時の調整（a:値,i:頂点）
# adj_td:トップダウン時の調整（a:値,i:頂点,p:親）
# adj_fin:最終調整（a:値,i:頂点）
def merge(a, b): return a * b % mod
def adj_bu(a, i): return a * inv[size[i]] % mod
def adj_td(a, i, p): return a * inv[n-size[i]] % mod
def adj_fin(a, i): return a * fact[n-1] % mod
# トポロジカルソートをする
# T:木の隣接グラフ表現をset化
# P:親
# q:キュー
# order:トポソしたもの
T = g
P = [-1]*n
q = [0]
order = []
while q:
i = q.pop()
order.append(i)
for a in T[i]:
if a != P[i]:
P[a] = i
T[a].remove(i)
q.append(a)
# Tをリストに変換
T = [list(i) for i in T]
# サイズの処理を先に行う
# size[i]:0を根とする根付き木における、iを根とする部分木の大きさ
size = [1]*n
for i in order[1:][::-1]:
size[P[i]] += size[i]
# ボトムアップ処理をする
# ME:マージした値を一時保存
# DP:DP値、MEを調整したもの
ME = [ini]*n
DP = [0]*n
for i in order[1:][::-1]:
DP[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], DP[i])
DP[order[0]] = adj_fin(ME[order[0]], order[0])
TD = [ini]*n
# トップダウン処理をする
for i in order:
# 左からDP（結果はTDに入れている）
ac = TD[i]
for j in T[i]:
TD[j] = ac
ac = merge(ac, DP[j])
# 右からDP（結果はacに入れている、一度しか使わないのでacで問題ない）
ac = ini
for j in T[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, DP[j])
DP[j] = adj_fin(merge(ME[j], TD[j]), j)
for i in DP:
print(i)
rerooting(g, 1)
main()
| p02728 |
def main():
from sys import stdin
input = stdin.readline
n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in [0]*(n-1)]
g = [set() for _ in [0]*n]
for a, b in ab:
g[a-1].add(b-1)
g[b-1].add(a-1)
mod = 10**9+7
fact = [1, 1]
inv = [pow(i, mod-2, mod) for i in range(n+1)]
for i in range(2, n+1):
fact.append(fact[-1]*i % mod)
class rerooting():
# addは頂点iに頂点jを根とする部分木（DPの値：x）をくっつけるときの補正
def __init__(self, tree, ini):
# merge:頂点aにbをマージするときのモノイド
# adj_bu:ボトムアップ時の調整（a:値,i:頂点）
# adj_td:トップダウン時の調整（a:値,i:頂点,p:親）
# adj_fin:最終調整（a:値,i:頂点）
def merge(a, b): return a * b % mod
def adj_bu(a, i): return a * inv[size[i]] % mod
def adj_td(a, i, p): return a * inv[n-size[i]] % mod
def adj_fin(a, i): return a * fact[n-1] % mod
# トポロジカルソートをする
# T:木の隣接グラフ表現をset化
# P:親
# q:キュー
# order:トポソしたもの
T = g
P = [-1]*n
q = [0]
order = []
while q:
i = q.pop()
order.append(i)
for a in T[i]:
if a != P[i]:
P[a] = i
T[a].remove(i)
q.append(a)
# Tをリストに変換
T = [list(i) for i in T]
# サイズの処理を先に行う
# size[i]:0を根とする根付き木における、iを根とする部分木の大きさ
size = [1]*n
for i in order[1:][::-1]:
size[P[i]] += size[i]
# ボトムアップ処理をする
# ME:マージした値を一時保存
# DP:DP値、MEを調整したもの
ME = [ini]*n
DP = [0]*n
for i in order[1:][::-1]:
DP[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], DP[i])
DP[order[0]] = adj_fin(ME[order[0]], order[0])
TD = [ini]*n
# トップダウン処理をする
for i in order:
# 左からDP（結果はTDに入れている）
ac = TD[i]
for j in T[i]:
TD[j] = ac
ac = merge(ac, DP[j])
# 右からDP（結果はacに入れている、一度しか使わないのでacで問題ない）
ac = ini
for j in T[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, DP[j])
DP[j] = adj_fin(merge(ME[j], TD[j]), j)
for i in DP:
print(i)
rerooting(g, 1)
main()
| def main():
from sys import stdin
input = stdin.readline
n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in [0]*(n-1)]
g = [[] for _ in [0]*n]
for a, b in ab:
g[a-1].append(b-1)
g[b-1].append(a-1)
mod = 10**9+7
fact = [1, 1]
inv = [pow(i, mod-2, mod) for i in range(n+1)]
for i in range(2, n+1):
fact.append(fact[-1]*i % mod)
# merge:頂点aにbをマージするときのモノイド
# adj_bu:ボトムアップ時の調整（a:値,i:頂点）
# adj_td:トップダウン時の調整（a:値,i:頂点,p:親）
# adj_fin:最終調整（a:値,i:頂点）
def merge(a, b): return a * b % mod
def adj_bu(a, i): return a * inv[size[i]] % mod
def adj_td(a, i, p): return a * inv[n-size[i]] % mod
def adj_fin(a, i): return a * fact[n-1] % mod
# トポロジカルソートをする
# T:木の隣接グラフ表現をset化
# P:親
# q:キュー
# order:トポソしたもの
T = g
P = [-1]*n
q = [0]
ini = 1
order = []
while q:
i = q.pop()
order.append(i)
for a in T[i]:
if a != P[i]:
P[a] = i
T[a].remove(i)
q.append(a)
# サイズの処理を先に行う
# size[i]:0を根とする根付き木における、iを根とする部分木の大きさ
size = [1]*n
for i in order[1:][::-1]:
size[P[i]] += size[i]
# ボトムアップ処理をする
# ME:マージした値を一時保存
# DP:DP値、MEを調整したもの
ME = [ini]*n
DP = [0]*n
for i in order[1:][::-1]:
DP[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], DP[i])
DP[order[0]] = adj_fin(ME[order[0]], order[0])
TD = [ini]*n
# トップダウン処理をする
for i in order:
# 左からDP（結果はTDに入れている）
ac = TD[i]
for j in T[i]:
TD[j] = ac
ac = merge(ac, DP[j])
# 右からDP（結果はacに入れている、一度しか使わないのでacで問題ない）
ac = ini
for j in T[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, DP[j])
DP[j] = adj_fin(merge(ME[j], TD[j]), j)
for i in DP:
print(i)
main()
| p02728 |
def main():
from sys import stdin
input = stdin.readline
n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in [0]*(n-1)]
g = [[] for _ in [0]*n]
for a, b in ab:
g[a-1].append(b-1)
g[b-1].append(a-1)
mod = 10**9+7
fact = [1, 1]
inv = [pow(i, mod-2, mod) for i in range(n+1)]
for i in range(2, n+1):
fact.append(fact[-1]*i % mod)
# merge:頂点aにbをマージするときのモノイド
# adj_bu:ボトムアップ時の調整（a:値,i:頂点）
# adj_td:トップダウン時の調整（a:値,i:頂点,p:親）
# adj_fin:最終調整（a:値,i:頂点）
def merge(a, b): return a * b % mod
def adj_bu(a, i): return a * inv[size[i]] % mod
def adj_td(a, i, p): return a * inv[n-size[i]] % mod
def adj_fin(a, i): return a * fact[n-1] % mod
# トポロジカルソートをする
# T:木の隣接グラフ表現をset化
# P:親
# q:キュー
# order:トポソしたもの
T = g
P = [-1]*n
q = [0]
ini = 1
order = []
while q:
i = q.pop()
order.append(i)
for a in T[i]:
if a != P[i]:
P[a] = i
T[a].remove(i)
q.append(a)
# サイズの処理を先に行う
# size[i]:0を根とする根付き木における、iを根とする部分木の大きさ
size = [1]*n
for i in order[1:][::-1]:
size[P[i]] += size[i]
# ボトムアップ処理をする
# ME:マージした値を一時保存
# DP:DP値、MEを調整したもの
ME = [ini]*n
DP = [0]*n
for i in order[1:][::-1]:
DP[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], DP[i])
DP[order[0]] = adj_fin(ME[order[0]], order[0])
TD = [ini]*n
# トップダウン処理をする
for i in order:
# 左からDP（結果はTDに入れている）
ac = TD[i]
for j in T[i]:
TD[j] = ac
ac = merge(ac, DP[j])
# 右からDP（結果はacに入れている、一度しか使わないのでacで問題ない）
ac = ini
for j in T[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, DP[j])
DP[j] = adj_fin(merge(ME[j], TD[j]), j)
for i in DP:
print(i)
main()
| def main():
from sys import stdin
input = stdin.readline
n = int(eval(input()))
g = [[] for _ in [0]*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)
mod = 10**9+7
fact = [1, 1]
inv = [1]*(n+1)
for i in range(2, n+1):
fact.append(fact[-1]*i % mod)
temp = pow(fact[-1], mod-2, mod)
for i in range(n, 0, -1):
inv[i] = temp*fact[i-1] % mod
temp = temp*i % mod
class rerooting():
# addは頂点iに頂点jを根とする部分木（DPの値：x）をくっつけるときの補正
def __init__(self, tree, ini):
# merge:頂点aにbをマージするときのモノイド
# adj_bu:ボトムアップ時の調整（a:値,i:頂点）
# adj_td:トップダウン時の調整（a:値,i:頂点,p:親）
# adj_fin:最終調整（a:値,i:頂点）
def merge(a, b): return a * b % mod
def adj_bu(a, i): return a * inv[size[i]] % mod
def adj_td(a, i, p): return a * inv[n-size[i]] % mod
def adj_fin(a, i): return a * fact[n-1] % mod
# トポロジカルソートをする
# T:木の隣接グラフ表現をset化
# P:親
# q:キュー
# order:トポソしたもの
T = g
P = [-1]*n
q = [0]
order = []
while q:
i = q.pop()
order.append(i)
for a in T[i]:
if a != P[i]:
P[a] = i
T[a].remove(i)
q.append(a)
# サイズの処理を先に行う
# size[i]:0を根とする根付き木における、iを根とする部分木の大きさ
size = [1]*n
for i in order[1:][::-1]:
size[P[i]] += size[i]
# ボトムアップ処理をする
# ME:マージした値を一時保存
# DP:DP値、MEを調整したもの
ME = [ini]*n
DP = [0]*n
for i in order[1:][::-1]:
DP[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], DP[i])
DP[order[0]] = adj_fin(ME[order[0]], order[0])
TD = [ini]*n
# トップダウン処理をする
for i in order:
# 左からDP（結果はTDに入れている）
ac = TD[i]
for j in T[i]:
TD[j] = ac
ac = merge(ac, DP[j])
# 右からDP（結果はacに入れている、一度しか使わないのでacで問題ない）
ac = ini
for j in T[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, DP[j])
DP[j] = adj_fin(merge(ME[j], TD[j]), j)
for i in DP:
print(i)
rerooting(g, 1)
main()
| p02728 |
import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n = int(eval(input()))
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)
mod = 10**9+7
kkai = [1]
for i in range(1, 2*10 ** 5):
kkai.append(kkai[-1] * i % mod)
def kai(x, p=mod):
return kkai[x]
def comb(a, b, p=mod):
if a < 0 or b < 0:
return 0
elif a < b:
return 0
if b == 0:
return 1
c = 1
c *= kai(a, p)
c *= pow(kai(b, p), p - 2, p)
c *= pow(kai(a - b, p), p - 2, p)
return c % p
child = [0] * n
def dfs1(i=0, r=-1):
s = 1
for j in e[i]:
if j == r:
continue
s += dfs1(j, i)
child[i] = s
return s
dfs1()
a = [0] * n
def dfs2(i=0, r=-1):
s = 1
t = 0
for j in e[i]:
if j == r:
continue
t += child[j]
s *= dfs2(j, i)
s %= mod
s *= comb(t, child[j])
s %= mod
a[i] = s
return s
dfs2()
b = [0] * n
def dfs3(i=0, r=-1):
if r == -1:
b[i] = a[i]
else:
s = b[r] * comb(n-1, child[i]-1) % mod
re = comb(n-1, child[i])
s *= pow(re, mod - 2, mod)
s %= mod
b[i] = s
for j in e[i]:
if j == r:
continue
dfs3(j, i)
dfs3()
print(("\n".join(map(str, b))))
| import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n = int(eval(input()))
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)
mod = 10**9+7
kkai = [1]
for i in range(1, 2*10 ** 5):
kkai.append(kkai[-1] * i % mod)
def kai(x, p=mod):
return kkai[x]
def comb(a, b, p=mod):
if a < 0 or b < 0:
return 0
elif a < b:
return 0
if b == 0:
return 1
c = 1
c *= kai(a, p)
c *= pow(kai(b, p), p - 2, p)
c *= pow(kai(a - b, p), p - 2, p)
return c % p
child = [0] * n
def dfs1(i=0, r=-1):
s = 1
for j in e[i]:
if j == r:
continue
s += dfs1(j, i)
child[i] = s
return s
dfs1()
a = [0] * n
def dfs2(i=0, r=-1):
s = kai(child[i]-1)
t = 1
for j in e[i]:
if j == r:
continue
s *= dfs2(j, i)
s %= mod
t *= kai(child[j])
t %= mod
s *= pow(t, mod - 2, mod)
s %= mod
a[i] = s
return s
dfs2()
b = [0] * n
def dfs3(i=0, r=-1):
if r == -1:
b[i] = a[i]
else:
s = b[r] * child[i] % mod
s *= pow(n-child[i], mod - 2, mod)
s %= mod
b[i] = s
for j in e[i]:
if j == r:
continue
dfs3(j, i)
dfs3()
print(("\n".join(map(str, b))))
| p02728 |
import math
import sys
from collections import deque
to = [0]
treenum = [0]
dpv = [0]
N = 0
NMAX = 2*(10**5)
MOD = 10**9+7
fact = [0 for i in range(NMAX+1)]
fact[0] = 1
invfact = [0 for i in range(NMAX+1)]
invfact[0] = 1
def pways(v, parent):
global to, dpv, treenum, fact, invfact, MOD
if dpv[parent][v] != 0:
return dpv[parent][v], treenum[parent][v]
ans = 1
num = 1
for i in to[v]:
if i != parent and i != v:
c_ans, c_num = pways(i, v)
num += c_num
ans = (ans*c_ans) *invfact[c_num] % (MOD)
treenum[parent][v] = num
treenum[v][v] = N
dpv[parent][v] = ans * fact[num-1] % (MOD)
return dpv[parent][v], treenum[parent][v]
def revways(v, parent):
global dpv, treenum, N, fact, invfact, MOD
if dpv[parent][parent] == 0:
treenum[parent][v] = N-treenum[v][parent]
#dpv[parent][v] = (dpv[v][v]*invfact[treenum[v][v]-1]*fact[treenum[v][v]-1-treenum[v][parent]]*fact[treenum[v][parent]]% (MOD)/dpv[v][parent]) % (MOD)
val = (dpv[v][v]*invfact[treenum[v][v]-1]*fact[treenum[v][v]-1-treenum[v][parent]]*fact[treenum[v][parent]]% (MOD)) % (MOD)
dpv[parent][parent] = val *invfact[treenum[parent][v]] *invfact[treenum[v][parent]-1] * fact[N-1] % (MOD)
def main():
global to, N, dpv, treenum, fact, invfact, NMAX, MOD
input = sys.stdin.readline
N = int(eval(input()))
to = [[] for i in range(N+1)]
dpv = [[0 for i in range(N+1)] for j in range(N+1)]
treenum = [[0 for i in range(N+1)] for j in range(N+1)]
for i in range(N-1):
a,b = [int(i) for i in input().split()]
to[a].append(b)
to[b].append(a)
for i in range(NMAX):
fact[i+1] = fact[i]*(i+1)%(MOD)
invfact[NMAX] = pow(fact[NMAX], MOD-2, MOD)
for i in range(NMAX-1,0,-1):
invfact[i] = invfact[i+1] * (i+1) % MOD
pways(1,1)
bfs = deque([])
for i in range(1, N+1):
if i in to[1]:
bfs.append([1,i])
while len(bfs) != 0:
i = bfs.popleft()
revways(i[0], i[1])
for j in range(1, N+1):
if j != i[0] and j in to[i[1]]:
bfs.append([i[1],j])
for i in range(1,N+1):
print((int(dpv[i][i])))
main() | import math
import sys
from collections import deque
sys.setrecursionlimit(10 ** 9)
to = {0:[0]}
treenum = {(0,0):0}
dpv = {(0,0):0}
N = 0
NMAX = 2*(10**5)
MOD = 10**9+7
fact = [0 for i in range(NMAX+1)]
fact[0] = 1
invfact = [0 for i in range(NMAX+1)]
invfact[0] = 1
def pways(v, parent):
global to, dpv, treenum, fact, invfact, MOD
ans = 1
num = 1
for i in to[v]:
if i != parent and i != v:
c_ans, c_num = pways(i, v)
num += c_num
ans = (ans*c_ans) *invfact[c_num] % (MOD)
treenum[(parent,v)] = num
treenum[(v,v)] = N
dpv[(parent,v)] = ans * fact[num-1] % (MOD)
return dpv[(parent,v)], treenum[(parent,v)]
def revways(v, parent):
global dpv, treenum, N, fact, invfact, MOD
# if dpv.get(parent,parent) == None:
treenum[(parent,v)] = N-treenum[(v,parent)]
#dpv[parent][v] = (dpv[v][v]*invfact[treenum[v][v]-1]*fact[treenum[v][v]-1-treenum[v][parent]]*fact[treenum[v][parent]]% (MOD)/dpv[v][parent]) % (MOD)
val = (dpv[(v,v)]*invfact[treenum[(v,v)]-1]*fact[treenum[(v,v)]-1-treenum[(v,parent)]]*fact[treenum[(v,parent)]]% (MOD)) % (MOD)
dpv[(parent,parent)] = val *invfact[treenum[(parent,v)]] *invfact[treenum[(v,parent)]-1] * fact[N-1] % (MOD)
def main():
global to, N, dpv, treenum, fact, invfact, NMAX, MOD
input = sys.stdin.readline
N = int(eval(input()))
to = [[] for i in range(N+1)]
for i in range(N-1):
a,b = [int(i) for i in input().split()]
to[a].append(b)
to[b].append(a)
for i in range(NMAX):
fact[i+1] = fact[i]*(i+1)%(MOD)
invfact[NMAX] = pow(fact[NMAX], MOD-2, MOD)
for i in range(NMAX-1,0,-1):
invfact[i] = invfact[i+1] * (i+1) % MOD
pways(1,1)
bfs = deque([])
for i in range(1, N+1):
if i in to[1]:
bfs.append([1,i])
while len(bfs) != 0:
i = bfs.popleft()
revways(i[0], i[1])
for j in range(1, N+1):
if j != i[0] and j in to[i[1]]:
bfs.append([i[1],j])
for i in range(1,N+1):
print((int(dpv[(i,i)])))
main() | p02728 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
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 = ans[x]
nf = fx*inv[s[x]-1]%mod
sx = s[x]
for y in v[x]:
sy = s[y]
nsx = sx-sy
nsy = s[x]
if ans[y] == None:
fy = nf*s[y]*f[nsy-1]*pow(nsx,mod-2,mod)%mod
ans[y] = fy
s[x] = nsx
s[y] = nsy
dfs(y)
s[x] = sx
s[y] = sy
n = I()
f = [1]
for i in range(1,n+1):
f.append(f[-1]*i%mod)
inv = [None]*(n+1)
inv[n] = pow(f[n],mod-2,mod)
for i in range(n)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
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)
d = [0]*n
d[0] = 1
q = deque([0])
p = [None]*n
while q:
x = q.popleft()
nd = d[x]+1
for y in v[x]:
if not d[y]:
d[y] = nd
p[y] = x
q.append(y)
V = list(range(n))
V.sort(key = lambda x:-d[x])
m = d[V[0]]
s = [0]*n
res = 1
for i in V:
j = p[i]
s[i] += 1
if j != None:
s[j] += s[i]
res *= inv[s[i]]
if d[i] == m:
continue
res *= f[s[i]-1]
res %= mod
ans = [None]*n
ans[0] = res
dfs(0)
for i in ans:
print(i)
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
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 = ans[x]
nf = fx*inv[s[x]-1]%mod
sx = s[x]
for y in v[x]:
sy = s[y]
nsx = sx-sy
nsy = s[x]
if ans[y] == None:
fy = nf*s[y]*f[nsy-1]*p[nsx]%mod
ans[y] = fy
s[x] = nsx
s[y] = nsy
dfs(y)
s[x] = sx
s[y] = sy
n = I()
f = [1]
for i in range(1,n+1):
f.append(f[-1]*i%mod)
inv = [None]*(n+1)
inv[n] = pow(f[n],mod-2,mod)
for i in range(n)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
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)
d = [0]*n
d[0] = 1
q = deque([0])
p = [None]*n
while q:
x = q.popleft()
nd = d[x]+1
for y in v[x]:
if not d[y]:
d[y] = nd
p[y] = x
q.append(y)
V = list(range(n))
V.sort(key = lambda x:-d[x])
m = d[V[0]]
s = [0]*n
res = 1
for i in V:
j = p[i]
s[i] += 1
if j != None:
s[j] += s[i]
res *= inv[s[i]]
if d[i] == m:
continue
res *= f[s[i]-1]
res %= mod
ans = [None]*n
ans[0] = res
p = [pow(i,mod-2,mod) for i in range(n+1)]
dfs(0)
for i in ans:
print(i)
return
#Solve
if __name__ == "__main__":
solve()
| p02728 |
def ABC67_B():
N, K = LI()
L = LI()
L.sort(reverse=True)
ans = sum(L[:K])
print(ans)
return
def ABC100_C():
def factorization_2(n):
arr = defaultdict(int)
temp = n
i = 2
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr[i] = cnt
if temp != 1:
arr[temp] = 1
if arr == []:
arr[n] = 1
return arr[2]
N = I()
A = LI()
ans = 0
for a in A:
ans += factorization_2(a)
print(ans)
return
def ARC68_C():
X = I()
ans = 0
ans += 2*(X//11)
rest = X%11
if rest>0:
ans += 1
if rest>=7:
ans += 1
print(ans)
return
def ABC49_C():
S = SI()
T = {"maerd","remaerd","esare","resare"}
stack = ""
for s in S[::-1]:
stack += s
if stack in T:
stack = ""
if stack:
print("NO")
else:
print("YES")
return
def ABC142_E():
N, M = LI()
A = [0]*M
C = [[]for _ in range(M)]
for i in range(M):
A[i], b = LI()
C[i] = LI()
mask = 2**N
dp = [[inf]*mask for _ in range(M+1)]
dp[0][0] = 0
for i in range(M):
key = 0
for j in C[i]:
key += 2**(j-1)
#print(key)
for now in range(mask):
dp[i + 1][now] = min(dp[i + 1][now], dp[i][now])
if key|now==now:
continue
dp[i+1][now|key] = min(dp[i+1][now|key],dp[i][now]+A[i])
if dp[M][mask-1]==inf:
print((-1))
else:
ans = dp[M][mask-1]
print(ans)
#print(dp)
return
def ABC160_F():
class combination():
# 素数のmod取るときのみ 速い
def __init__(self, n, mod):
self.n = n
self.mod = mod
self.fac = [1] * (n + 1)
self.inv = [1] * (n + 1)
for j in range(1, n + 1):
self.fac[j] = self.fac[j - 1] * j % mod
self.inv[n] = pow(self.fac[n], mod - 2, mod)
for j in range(n - 1, -1, -1):
self.inv[j] = self.inv[j + 1] * (j + 1) % mod
def comb(self, n, r):
if r > n or n < 0 or r < 0:
return 0
return self.fac[n] * self.inv[n - r] * self.inv[r] % self.mod
N = I()
V = [[]for _ in range(N)]
for _ in range(N-1):
a, b = LI()
a -= 1; b -= 1
V[a].append(b)
V[b].append(a)
C = combination(N,mod)
children = [-1] * N
A = [0] * N
def dfs(s):
size = 1
nowchild = []
cur = 1
children[s] = 0
for i in V[s]:
if children[i] != -1:
continue
ns, nc = dfs(i)
nowchild.append(ns)
size += ns
cur *= nc
cur %= mod
children[s] = size
rest = size - 1
for k in nowchild:
cur *= C.comb(rest, k)
rest -= k
cur %= mod
A[s] = cur
return size, cur
rep = [0] * N
def dfs2(s, p):
cur = 1
rest = N - 1
for to in V[s]:
cur *= A[to]
cur %= mod
for to in V[s]:
cur *= C.comb(rest, children[to])
rest -= children[to]
cur %= mod
rep[s] = cur
n = len(V[s])
L = [0] * n; R = [0] * n
L2 = [0] * n; R2 = [0] * n
for i, ne in enumerate(V[s]):
L[i] = R[i] = A[ne] * C.inv[children[ne]] % mod
L2[i] = R2[i] = children[ne]
for i in range(1, n):
L[i] *= L[i - 1]
L[i] %= mod
L2[i] += L2[i - 1]
for i in range(1, n - 1)[::-1]:
R[i] *= R[i + 1]
R[i] %= mod
R2[i] += R2[i + 1]
for i, ne in enumerate(V[s]):
if ne == p:
continue
A[s] = 1
children[s] = 1
if i > 0:
A[s] *= L[i - 1]
A[s] %= mod
children[s] += L2[i - 1]
if i + 1 < n:
A[s] *= R[i + 1]
A[s] %= mod
children[s] += R2[i + 1]
A[s] *= C.fac[N - children[ne] - 1]
A[s] %= mod
dfs2(ne, s)
return
dfs(0)
dfs2(0,-1)
for ans in rep:
print(ans)
return
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**6)
if __name__ == '__main__':
ABC160_F()
"""
""" | def ABC67_B():
N, K = LI()
L = LI()
L.sort(reverse=True)
ans = sum(L[:K])
print(ans)
return
def ABC100_C():
def factorization_2(n):
arr = defaultdict(int)
temp = n
i = 2
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr[i] = cnt
if temp != 1:
arr[temp] = 1
if arr == []:
arr[n] = 1
return arr[2]
N = I()
A = LI()
ans = 0
for a in A:
ans += factorization_2(a)
print(ans)
return
def ARC68_C():
X = I()
ans = 0
ans += 2*(X//11)
rest = X%11
if rest>0:
ans += 1
if rest>=7:
ans += 1
print(ans)
return
def ABC49_C():
S = SI()
T = {"maerd","remaerd","esare","resare"}
stack = ""
for s in S[::-1]:
stack += s
if stack in T:
stack = ""
if stack:
print("NO")
else:
print("YES")
return
def ABC142_E():
N, M = LI()
A = [0]*M
C = [[]for _ in range(M)]
for i in range(M):
A[i], b = LI()
C[i] = LI()
mask = 2**N
dp = [[inf]*mask for _ in range(M+1)]
dp[0][0] = 0
for i in range(M):
key = 0
for j in C[i]:
key += 2**(j-1)
#print(key)
for now in range(mask):
dp[i + 1][now] = min(dp[i + 1][now], dp[i][now])
if key|now==now:
continue
dp[i+1][now|key] = min(dp[i+1][now|key],dp[i][now]+A[i])
if dp[M][mask-1]==inf:
print((-1))
else:
ans = dp[M][mask-1]
print(ans)
#print(dp)
return
def ABC160_F():
class combination():
# 素数のmod取るときのみ 速い
def __init__(self, n, mod):
self.n = n
self.mod = mod
self.fac = [1] * (n + 1)
self.inv = [1] * (n + 1)
for j in range(1, n + 1):
self.fac[j] = self.fac[j - 1] * j % mod
self.inv[n] = pow(self.fac[n], mod - 2, mod)
for j in range(n - 1, -1, -1):
self.inv[j] = self.inv[j + 1] * (j + 1) % mod
def comb(self, n, r):
if r > n or n < 0 or r < 0:
return 0
return self.fac[n] * self.inv[n - r] * self.inv[r] % self.mod
N = I()
V = [[]for _ in range(N)]
for _ in range(N-1):
a, b = LI()
a -= 1; b -= 1
V[a].append(b)
V[b].append(a)
C = combination(N,mod)
children = [-1] * N
A = [0] * N
rep = [0] * N
def dfs(s):
size = 1
nowchild = []
cur = 1
children[s] = 0
for i in V[s]:
if children[i] != -1:
continue
ns, nc = dfs(i)
nowchild.append(ns)
size += ns
cur *= nc
cur %= mod
children[s] = size
rest = size - 1
for k in nowchild:
cur *= C.comb(rest, k)
rest -= k
cur %= mod
A[s] = cur
return size, cur
def dfs2(s, p=-1):
cur = 1
rest = N - 1
for to in V[s]:
cur *= A[to]
cur %= mod
for to in V[s]:
cur *= C.comb(rest, children[to])
rest -= children[to]
cur %= mod
rep[s] = cur
n = len(V[s])
L = [0] * n; R = [0] * n
L2 = [0] * n; R2 = [0] * n
for i, ne in enumerate(V[s]):
L[i] = R[i] = A[ne] * C.inv[children[ne]] % mod
L2[i] = R2[i] = children[ne]
for i in range(1, n):
L[i] *= L[i - 1]
L[i] %= mod
L2[i] += L2[i - 1]
for i in range(1, n - 1)[::-1]:
R[i] *= R[i + 1]
R[i] %= mod
R2[i] += R2[i + 1]
for i, ne in enumerate(V[s]):
if ne == p:
continue
A[s] = 1
children[s] = 1
if i > 0:
A[s] *= L[i - 1]
A[s] %= mod
children[s] += L2[i - 1]
if i + 1 < n:
A[s] *= R[i + 1]
A[s] %= mod
children[s] += R2[i + 1]
A[s] *= C.fac[N - children[ne] - 1]
A[s] %= mod
dfs2(ne, s)
return
dfs(0)
dfs2(0)
for ans in rep:
print(ans)
return
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**6)
if __name__ == '__main__':
ABC160_F()
"""
""" | p02728 |
MOD = 10 ** 9 + 7
MAX_N = 2 * 10 ** 5
fact = [1] * (MAX_N + 1)
inverse = [1] * (MAX_N + 1)
inv_fact = [1] * (MAX_N + 1)
for i in range(2, MAX_N + 1):
fact[i] = fact[i-1] * i % MOD
inverse[i] = -inverse[MOD % i] * (MOD // i) % MOD
inv_fact[i] = inv_fact[i-1] * inverse[i] % MOD
n = int(eval(input()))
edge = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
for root in range(n):
stack = [root]
parent = [root] * n
route = []
while stack:
vertex = stack.pop()
route.append(vertex)
for child in edge[vertex]:
if parent[vertex] != child:
parent[child] = vertex
stack.append(child)
dp = [1] * n
size = [1] * n
for vertex in route[:0:-1]:
pa = parent[vertex]
sz = size[vertex]
dp[vertex] = dp[vertex] * fact[sz-1] % MOD
dp[pa] = dp[pa] * dp[vertex] * inv_fact[sz] % MOD
size[pa] += sz
print((dp[root] * fact[size[root] - 1] % MOD)) | MOD = 10 ** 9 + 7
MAX_N = 2 * 10 ** 5
fact = [1] * MAX_N
inverse = [1] * MAX_N
inv_fact = [1] * MAX_N
for i in range(2, MAX_N):
fact[i] = fact[i-1] * i % MOD
inverse[i] = -inverse[MOD % i] * (MOD // i) % MOD
inv_fact[i] = inv_fact[i-1] * inverse[i] % MOD
n = int(eval(input()))
edge = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
stack = [0]
parent = [0] * n
route = []
while stack:
vertex = stack.pop()
route.append(vertex)
for child in edge[vertex]:
if parent[vertex] != child:
parent[child] = vertex
stack.append(child)
dp = [1] * n
size = [1] * n
for vertex in route[:0:-1]:
pa = parent[vertex]
sz = size[vertex]
dp[vertex] = dp[vertex] * fact[sz-1] % MOD
dp[pa] = dp[pa] * dp[vertex] * inv_fact[sz] % MOD
size[pa] += sz
dp[0] = dp[0] * fact[n-1] % MOD
for vertex in route[1:]:
pa = parent[vertex]
sz = size[vertex]
tmp = dp[pa] * pow(dp[vertex], MOD - 2, MOD) * sz * inverse[n-sz] % MOD
dp[vertex] = dp[vertex] * tmp % MOD
for value in dp:
print(value) | p02728 |
MOD = 10 ** 9 + 7
MAX_N = 2 * 10 ** 5
fact = [1] * MAX_N
inverse = [1] * MAX_N
inv_fact = [1] * MAX_N
for i in range(2, MAX_N):
fact[i] = fact[i-1] * i % MOD
inverse[i] = -inverse[MOD % i] * (MOD // i) % MOD
inv_fact[i] = inv_fact[i-1] * inverse[i] % MOD
n = int(eval(input()))
edge = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
stack = [0]
parent = [0] * n
route = []
while stack:
vertex = stack.pop()
route.append(vertex)
for child in edge[vertex]:
if parent[vertex] != child:
parent[child] = vertex
stack.append(child)
dp = [1] * n
size = [1] * n
for vertex in route[:0:-1]:
pa = parent[vertex]
sz = size[vertex]
dp[vertex] = dp[vertex] * fact[sz-1] % MOD
dp[pa] = dp[pa] * dp[vertex] * inv_fact[sz] % MOD
size[pa] += sz
dp[0] = dp[0] * fact[n-1] % MOD
for vertex in route[1:]:
pa = parent[vertex]
sz = size[vertex]
tmp = dp[pa] * pow(dp[vertex], MOD - 2, MOD) * sz * inverse[n-sz] % MOD
dp[vertex] = dp[vertex] * tmp % MOD
for value in dp:
print(value) | # modulo
MOD = 10 ** 9 + 7
# number of vertices
n = int(eval(input()))
# adjacency list
edge = [[] for _ in range(n)]
# 0-index
for _ in range(n-1):
a, b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
# factorial and inverse and inverse of factorial
fact = [1] * n
inverse = [1] * n
inv_fact = [1] * n
for i in range(2, n):
fact[i] = fact[i-1] * i % MOD
inverse[i] = -inverse[MOD % i] * (MOD // i) % MOD
inv_fact[i] = inv_fact[i-1] * inverse[i] % MOD
# regarding index 0 as root of tree
# calculating parents of vertices and route from root with DFS
stack = [0]
parent = [0] * n
route = []
while stack:
vertex = stack.pop()
route.append(vertex)
for child in edge[vertex]:
if parent[vertex] != child:
parent[child] = vertex
stack.append(child)
# tree DP regarding index 0 as root of tree
# process from leaves to root
dp = [1] * n
size = [1] * n
for vertex in route[:0:-1]:
pa = parent[vertex]
sz = size[vertex]
dp[vertex] = dp[vertex] * fact[sz-1] % MOD
dp[pa] = dp[pa] * dp[vertex] * inv_fact[sz] % MOD
size[pa] += sz
dp[0] = dp[0] * fact[n-1] % MOD
# rerooting
# process from root to leaves
for vertex in route[1:]:
pa = parent[vertex]
sz = size[vertex]
inv_dp = pow(dp[vertex], MOD - 2, MOD)
dp[vertex] = dp[vertex] * dp[pa] * inv_dp * sz * inverse[n-sz] % MOD
# printing result
for value in dp:
print(value) | p02728 |
import sys
input = sys.stdin.readline
N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
a,b=list(map(int,input().split()))
E[a].append(b)
E[b].append(a)
mod=10**9+7
FACT=[1]
for i in range(1,2*10**5+1):
FACT.append(FACT[-1]*i%mod)
FACT_INV=[pow(FACT[-1],mod-2,mod)]
for i in range(2*10**5,0,-1):
FACT_INV.append(FACT_INV[-1]*i%mod)
FACT_INV.reverse()
def Combi(a,b):
if 0<=b<=a:
return FACT[a]*FACT_INV[b]*FACT_INV[a-b]%mod
else:
return 0
TOP_SORT=[]
Q=[1]
P=[-1]*(N+1)
P[1]=0
P[0]=0
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if P[to]==-1:
P[to]=x
Q.append(to)
Children=[1]*(N+1)
ANS_UP=[1]*(N+1)
for x in TOP_SORT[::-1]:
sumchild=0
for to in E[x]:
if to==P[x]:
continue
sumchild+=Children[to]
ANS_UP[x]=ANS_UP[x]*Combi(sumchild,Children[to])%mod
Children[P[x]]+=Children[x]
ANS_UP[P[x]]=ANS_UP[P[x]]*ANS_UP[x]%mod
ANS_DOWN=[1]*(N+1)
for x in TOP_SORT:
sumchild=0
for to in E[P[x]]:
if to==x:
continue
if to==P[P[x]]:
sumchild+=N-Children[P[x]]
ANS_DOWN[x]=ANS_DOWN[x]*ANS_DOWN[P[x]]*Combi(sumchild,N-Children[P[x]])%mod
else:
sumchild+=Children[to]
ANS_DOWN[x]=ANS_DOWN[x]*ANS_UP[to]*Combi(sumchild,Children[to])%mod
for i in range(1,N+1):
if i==1:
print((ANS_UP[1]))
else:
ANS=ANS_DOWN[i]%mod
sumchild=0
for to in E[i]:
if to==P[i]:
sumchild+=N-Children[i]
ANS=ANS*Combi(sumchild,N-Children[i])%mod
else:
sumchild+=Children[to]
ANS=ANS*ANS_UP[to]*Combi(sumchild,Children[to])%mod
print(ANS) | import sys
input = sys.stdin.readline
N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
a,b=list(map(int,input().split()))
E[a].append(b)
E[b].append(a)
mod=10**9+7
FACT=[1]
for i in range(1,2*10**5+1):
FACT.append(FACT[-1]*i%mod)
FACT_INV=[pow(FACT[-1],mod-2,mod)]
for i in range(2*10**5,0,-1):
FACT_INV.append(FACT_INV[-1]*i%mod)
FACT_INV.reverse()
def Combi(a,b):
if 0<=b<=a:
return FACT[a]*FACT_INV[b]*FACT_INV[a-b]%mod
else:
return 0
TOP_SORT=[]
Q=[1]
P=[-1]*(N+1)
P[1]=0
P[0]=0
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if P[to]==-1:
P[to]=x
Q.append(to)
Children=[1]*(N+1)
ANS_UP=[1]*(N+1)
for x in TOP_SORT[::-1]:
sumchild=0
for to in E[x]:
if to==P[x]:
continue
sumchild+=Children[to]
ANS_UP[x]=ANS_UP[x]*Combi(sumchild,Children[to])%mod
Children[P[x]]+=Children[x]
ANS_UP[P[x]]=ANS_UP[P[x]]*ANS_UP[x]%mod
ANS_DOWN=[1]*(N+1)
for x in TOP_SORT:
if x==1:
continue
ANS_DOWN[x]=ANS_DOWN[P[x]]*ANS_UP[P[x]]*Combi(N-Children[x]-1,N-Children[P[x]])*pow(ANS_UP[x],mod-2,mod)*pow(Combi(Children[P[x]]-1,Children[x]),mod-2,mod)%mod
for i in range(1,N+1):
if i==1:
print((ANS_UP[1]))
else:
ANS=ANS_DOWN[i]%mod
sumchild=0
for to in E[i]:
if to==P[i]:
sumchild+=N-Children[i]
ANS=ANS*Combi(sumchild,N-Children[i])%mod
else:
sumchild+=Children[to]
ANS=ANS*ANS_UP[to]*Combi(sumchild,Children[to])%mod
print(ANS) | p02728 |
import sys
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
def prepare(n):
global MOD
modFacts = [0] * (n + 1)
modFacts[0] = 1
for i in range(n):
modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD
invs = [1] * (n + 1)
invs[n] = pow(modFacts[n], MOD - 2, MOD)
for i in range(n, 1, -1):
invs[i - 1] = (invs[i] * i) % MOD
return modFacts, invs
def dfs(pv, v):
global MOD
for e in edge[v]:
if e != pv and e not in list(V[v].keys()):
nc, nvar = dfs(v, e)
V[v][e] = (nc, nvar)
childs = 0
var = 1
for key in [i for i in list(V[v].keys()) if i != pv]:
cn, cvar = V[v][key]
childs += cn
var *= cvar
var %= MOD
var *= invs[cn]
var %= MOD
var *= modFacts[childs]
var %= MOD
return childs + 1, var
N = int(eval(input()))
edge = [[] for _ in range(N)]
for s in sys.stdin.readlines():
a, b = list(map(int, s.split()))
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
modFacts, invs = prepare(N)
V = [{} for _ in range(N)]
for i in range(N):
dfs(-1, i)
for i in range(N):
ans = 1
cnt = 0
for n, var in list(V[i].values()):
ans *= var
ans %= MOD
ans *= invs[n]
ans %= MOD
cnt += n
ans *= modFacts[cnt]
print((ans % MOD))
| import sys
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
def prepare(n):
global MOD
modFacts = [0] * (n + 1)
modFacts[0] = 1
for i in range(n):
modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD
invs = [1] * (n + 1)
invs[n] = pow(modFacts[n], MOD - 2, MOD)
for i in range(n, 1, -1):
invs[i - 1] = (invs[i] * i) % MOD
return modFacts, invs
def dfs(v):
global MOD
childs = 0
var = 1
for e in edge[v]:
if path[e] == 0:
path[e] = 1
nc, nvar = dfs(e)
childs += nc
V[v][e] = (nc, nvar)
var *= nvar
var %= MOD
var *= invs[nc]
var %= MOD
var *= modFacts[childs]
var %= MOD
return childs + 1, var
def dfs2(v):
global MOD
tNodes = 0
tVar = 1
for n, var in V[v].values():
tNodes += n
tVar *= var
tVar %= MOD
tVar *= invs[n]
tVar %= MOD
tVar *= modFacts[tNodes]
tVar %= MOD
dp[v] = tVar
for e in edge[v]:
if dp[e] == 0:
eNodes, eVar = V[v][e]
nVar = (tVar * invs[tNodes] * modFacts[eNodes] * modFacts[tNodes - eNodes]) % MOD
nVar *= pow(eVar, MOD - 2, MOD)
nVar %= MOD
V[e][v] = (tNodes - eNodes + 1, nVar)
dfs2(e)
N = int(input())
edge = [[] for _ in range(N)]
for s in sys.stdin.readlines():
a, b = map(int, s.split())
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
modFacts, invs = prepare(N)
V = [{} for _ in range(N)]
path = [0] * N
dp = [0] * N
path[0] = 1
dfs(0)
dfs2(0)
print(*dp, sep='\n')
| p02728 |
# -*- coding: utf-8 -*-
"""
Created on Fri May 8 12:10:59 2020
@author: ybt07
"""
import sys
import time
sys.setrecursionlimit(3*10**5) # 繰り返し制限
# 組み合わせ
N = 2*10**5 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
# modint
# https://qiita.com/wotsushi/items/c936838df992b706084c
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
# / : 商。 逆元はフェルマーの小定理を利用している
def __truediv__(self, other):
return (
ModInt(
self.x * inv[other.x]
) if isinstance(other, ModInt) else
ModInt(self.x * inv[other])
)
# ** : 指数
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
# x が Modint、y が通常の int の場合に、y.__add__(x) に対して、何を適用するか、定義している（→ x.__add__(y)を呼べ）
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return ModInt(fac[n] * facinv[r] * facinv[n-r])
fac = [1, 1] # 元テーブル
facinv = [1, 1] #逆元テーブル
inv = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, N):
fac.append( ( fac[-1] * i ) % MOD )
inv.append( ( -inv[MOD % i] * (MOD//i) ) % MOD )
facinv.append( (facinv[-1] * inv[-1]) % MOD )
# 部分木のDP値を求めていく
# u : 求める頂点
# 親（親側に辿らないように） p
def dfs(u, p = -1):
global DP, CN, E
# tmp_ans = 1
# tmp_cn = 0 # （自分を含む）部分木のノード数
# u から出ている頂点 v
for v in E[u]:
if v != p: # 親への辺以外について
DP[v], CN[v] = dfs(v, u)
CN[u] += CN[v]
DP[u] *= DP[v] * cmb(CN[u], CN[v])
CN[u] += 1
return DP[u], CN[u]
# 各頂点の真のDP値を求めていく
def bfs(u, p=-1):
global DP, E
for v in E[u]: # 各vに対して「真のDP値」を求めていく
if v == p:
continue
# DP[u] と DP[v] から DP[v <- u] を求める
cnv = CN[v]
tmp_cn = N - cnv # v から見たときの u の部分木の要素数
DP[v] = DP[u] * cnv / tmp_cn
bfs(v, u)
return
# 入力処理
N = int(eval(input())) # 頂点数
E = [[] for _ in range(N)] # 辺の情報
for _ in range(N - 1):
a, b = list(map(int, input().split()))
E[a-1].append(b-1) # 双方向の情報
E[b-1].append(a-1)
DP = [1] * N
CN = [0] * N
dfs(0)
bfs(0)
for i in DP:
print(i) | # -*- coding: utf-8 -*-
"""
Created on Fri May 8 12:10:59 2020
@author: ybt07
"""
import sys
import time
sys.setrecursionlimit(3*10**5) # 繰り返し制限
# 組み合わせ
N = 2*10**5 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
# modint
# https://qiita.com/wotsushi/items/c936838df992b706084c
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
# / : 商。 逆元はフェルマーの小定理を利用している
def __truediv__(self, other):
return (
ModInt(
self.x * inv[other.x]
) if isinstance(other, ModInt) else
ModInt(self.x * inv[other])
)
# ** : 指数
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
# x が Modint、y が通常の int の場合に、y.__add__(x) に対して、何を適用するか、定義している（→ x.__add__(y)を呼べ）
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * inv[self.x]
) if isinstance(other, ModInt) else
ModInt(other * inv[self.x])
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return fac[n] * facinv[r] * facinv[n-r] % MOD
fac = [1, 1] # 元テーブル
facinv = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N):
fac.append( ( fac[-1] * i ) % MOD )
inv.append( ( -inv[MOD % i] * (MOD//i) ) % MOD )
facinv.append( (facinv[-1] * inv[-1]) % MOD )
# 部分木のDP値を求めていく
# u : 求める頂点
# 親（親側に辿らないように） p
def dfs(u, p = -1):
global DP, CN, E
# tmp_ans = 1
# tmp_cn = 0 # （自分を含む）部分木のノード数
# u から出ている頂点 v
for v in E[u]:
if not v == p: # 親への辺以外について
DP[v], CN[v] = dfs(v, u)
CN[u] += CN[v]
DP[u] *= DP[v] * cmb(CN[u], CN[v])
CN[u] += 1
return DP[u], CN[u]
# 各頂点の真のDP値を求めていく
def bfs(u, p=-1):
global DP, E
for v in E[u]: # 各vに対して「真のDP値」を求めていく
if v == p:
continue
# DP[u] と DP[v] から DP[v <- u] を求める
cnv = CN[v]
tmp_cn = N - cnv # v から見たときの u の部分木の要素数
DP[v] = DP[u] * cnv / tmp_cn
bfs(v, u)
return
# 入力処理
N = int(input()) # 頂点数
E = [[] for _ in range(N)] # 辺の情報
for _ in range(N - 1):
a, b = map(int, input().split())
E[a-1].append(b-1) # 双方向の情報
E[b-1].append(a-1)
DP = [ModInt(1)] * N
CN = [0] * N
dfs(0)
bfs(0)
print(*DP, sep="\n")
| p02728 |
# -*- coding: utf-8 -*-
"""
Created on Fri May 8 12:10:59 2020
@author: ybt07
"""
import sys
import time
sys.setrecursionlimit(3*10**5) # 繰り返し制限
# 組み合わせ
N = 2*10**5 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
# modint
# https://qiita.com/wotsushi/items/c936838df992b706084c
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
# / : 商。 逆元はフェルマーの小定理を利用している
def __truediv__(self, other):
return (
ModInt(
self.x * inv[other.x]
) if isinstance(other, ModInt) else
ModInt(self.x * inv[other])
)
# ** : 指数
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
# x が Modint、y が通常の int の場合に、y.__add__(x) に対して、何を適用するか、定義している（→ x.__add__(y)を呼べ）
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * inv[self.x]
) if isinstance(other, ModInt) else
ModInt(other * inv[self.x])
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return fac[n] * facinv[r] * facinv[n-r] % MOD
fac = [1, 1] # 元テーブル
facinv = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N):
fac.append( ( fac[-1] * i ) % MOD )
inv.append( ( -inv[MOD % i] * (MOD//i) ) % MOD )
facinv.append( (facinv[-1] * inv[-1]) % MOD )
# 部分木のDP値を求めていく
# u : 求める頂点
# 親（親側に辿らないように） p
def dfs(u, p = -1):
global DP, CN, E
# tmp_ans = 1
# tmp_cn = 0 # （自分を含む）部分木のノード数
# u から出ている頂点 v
for v in E[u]:
if not v == p: # 親への辺以外について
DP[v], CN[v] = dfs(v, u)
CN[u] += CN[v]
DP[u] *= DP[v] * cmb(CN[u], CN[v])
CN[u] += 1
return DP[u], CN[u]
# 各頂点の真のDP値を求めていく
def bfs(u, p=-1):
global DP, E
for v in E[u]: # 各vに対して「真のDP値」を求めていく
if v == p:
continue
# DP[u] と DP[v] から DP[v <- u] を求める
cnv = CN[v]
tmp_cn = N - cnv # v から見たときの u の部分木の要素数
DP[v] = DP[u] * cnv / tmp_cn
bfs(v, u)
return
# 入力処理
N = int(input()) # 頂点数
E = [[] for _ in range(N)] # 辺の情報
for _ in range(N - 1):
a, b = map(int, input().split())
E[a-1].append(b-1) # 双方向の情報
E[b-1].append(a-1)
DP = [ModInt(1)] * N
CN = [0] * N
dfs(0)
bfs(0)
print(*DP, sep="\n")
| # -*- coding: utf-8 -*-
"""
Created on Fri May 8 12:10:59 2020
@author: ybt07
"""
import sys
sys.setrecursionlimit(3*10**5) # 繰り返し制限
# 組み合わせ
N = 2*10**5 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
# 入力高速化
input = lambda : sys.stdin.readline().rstrip()
# modint
# https://qiita.com/wotsushi/items/c936838df992b706084c
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
# / : 商。 逆元はフェルマーの小定理を利用している
def __truediv__(self, other):
return (
ModInt(
self.x * inv[other.x]
) if isinstance(other, ModInt) else
ModInt(self.x * inv[other])
)
# ** : 指数
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
# x が Modint、y が通常の int の場合に、y.__add__(x) に対して、何を適用するか、定義している（→ x.__add__(y)を呼べ）
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * inv[self.x]
) if isinstance(other, ModInt) else
ModInt(other * inv[self.x])
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return fac[n] * facinv[r] * facinv[n-r] % MOD
fac = [1, 1] # 元テーブル
facinv = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N):
fac.append( ( fac[-1] * i ) % MOD )
inv.append( ( -inv[MOD % i] * (MOD//i) ) % MOD )
facinv.append( (facinv[-1] * inv[-1]) % MOD )
# 部分木のDP値を求めていく
# u : 求める頂点
# 親（親側に辿らないように） p
def dfs(u, p = -1):
global DP, CN, E
# tmp_ans = 1
# tmp_cn = 0 # （自分を含む）部分木のノード数
# u から出ている頂点 v
for v in E[u]:
if not v == p: # 親への辺以外について
DP[v], CN[v] = dfs(v, u)
CN[u] += CN[v]
DP[u] *= DP[v] * cmb(CN[u], CN[v])
CN[u] += 1
return DP[u], CN[u]
# 各頂点の真のDP値を求めていく
def bfs(u, p=-1):
global DP, E
for v in E[u]: # 各vに対して「真のDP値」を求めていく
if v == p:
continue
# DP[u] と DP[v] から DP[v <- u] を求める
cnv = CN[v]
tmp_cn = N - cnv # v から見たときの u の部分木の要素数
DP[v] = DP[u] * cnv / tmp_cn
bfs(v, u)
return
# 入力処理
N = int(input()) # 頂点数
E = [[] for _ in range(N)] # 辺の情報
for _ in range(N - 1):
a, b = map(int, input().split())
E[a-1].append(b-1) # 双方向の情報
E[b-1].append(a-1)
DP = [ModInt(1)] * N
CN = [0] * N
dfs(0)
bfs(0)
print(*DP, sep="\n")
| p02728 |
import sys
input = lambda: sys.stdin.readline().rstrip()
#MOD
P = 10**9 + 7
N = 200001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2, N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b): return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#全方位木dp
#-------------------------------------------------------------------
#扱うクラス
class T:
num = 1
child = 0
def __init__(self, a, b):
self.num = a
self.child = b
#零元
zero = T(1, 0)
#一個上に遷移した時の変化
def step(x):
return T(x.num, x.child+1)
#マージ
def merge(x, y):
return T((x.num*y.num*comb(x.child+y.child, x.child))%P, x.child+y.child)
G = [[] for _ in range(N)]
down_data = [zero for _ in range(N)]
dat = [zero for _ in range(N)]
rev_data = [zero for _ in range(N)]
class p:
num = -1
parent = -1
def __init__(self, x, y):
self.num = x
self.parent = y
node_list = []
def makeNodeList(root):
#dfsでの探索順の作成
stack = []
stack.append(p(root, -1))
while len(stack) != 0:
now = stack.pop()
node_list.append(now)
for to in G[now.num]:
if to == now.parent: continue
stack.append(p(to, now.num))
node_list.reverse()
def dfs(root):
for now in node_list:
for to in G[now.num]:
if to == now.parent: continue
down_data[now.num] = merge(down_data[now.num], step(down_data[to]))
def dfs_rev(root):
for now in node_list:
#累積
rev = rev_data[now.num]
left = []
right = []
cnt = 0
for to in G[now.num]:
if to==now.parent: continue
if len(left)==0: left.append(step(down_data[to]))
else: left.append(merge(left[cnt-1], step(down_data[to])))
cnt += 1
cnt = 0
for to in reversed(G[now.num]):
if to==now.parent: continue
if len(right)==0: right.append(step(down_data[to]))
else: right.append(merge(right[cnt-1], step(down_data[to])))
cnt += 1
dat[now.num] = merge(rev, down_data[now.num])
cnt = 0
for to in G[now.num]:
if to==now.parent: continue
x = zero if cnt==0 else left[cnt-1]
y = zero if cnt==len(right)-1 else right[len(right)-2-cnt]
rev_data[to] = step(merge(rev, merge(x, y)))
cnt += 1
def calc(data_num):
root = -1
for i in range(1, data_num+1):
if len(G[i]) == 1:
root = i
break
makeNodeList(root)
dfs(root)
node_list.reverse()
dfs_rev(root)
#-------------------------------------------------------------------
def main():
n = int(eval(input()))
for i in range(n-1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
calc(n)
for i in range(1, n+1): print((dat[i].num))
if __name__ == "__main__": main()
| import sys
input = lambda: sys.stdin.readline().rstrip()
#MOD
P = 10**9 + 7
N = 200001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2, N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b): return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#全方位木dp
#-------------------------------------------------------------------
#扱うクラス
class T:
num = 1
child = 0
def __init__(self, a, b):
self.num = a
self.child = b
#零元
zero = T(1, 0)
#一個上に遷移した時の変化
def step(x):
return T(x.num, x.child+1)
#マージ
def merge(x, y):
return T((x.num*y.num*comb(x.child+y.child, x.child))%P, x.child+y.child)
G = [[] for _ in range(N)]
down_data = [zero] * N
dat = [zero] * N
rev_data = [zero] * N
class p:
num = -1
parent = -1
def __init__(self, x, y):
self.num = x
self.parent = y
node_list = []
def makeNodeList(root):
#dfsでの探索順の作成
stack = []
stack.append(p(root, -1))
while len(stack) != 0:
now = stack.pop()
node_list.append(now)
for to in G[now.num]:
if to == now.parent: continue
stack.append(p(to, now.num))
node_list.reverse()
def dfs(root):
for now in node_list:
for to in G[now.num]:
if to == now.parent: continue
down_data[now.num] = merge(down_data[now.num], step(down_data[to]))
def dfs_rev(root):
for now in node_list:
#累積
rev = rev_data[now.num]
left = []
right = []
cnt = 0
for to in G[now.num]:
if to==now.parent: continue
if len(left)==0: left.append(step(down_data[to]))
else: left.append(merge(left[cnt-1], step(down_data[to])))
cnt += 1
cnt = 0
for to in reversed(G[now.num]):
if to==now.parent: continue
if len(right)==0: right.append(step(down_data[to]))
else: right.append(merge(right[cnt-1], step(down_data[to])))
cnt += 1
dat[now.num] = merge(rev, down_data[now.num])
cnt = 0
for to in G[now.num]:
if to==now.parent: continue
x = zero if cnt==0 else left[cnt-1]
y = zero if cnt==len(right)-1 else right[len(right)-2-cnt]
rev_data[to] = step(merge(rev, merge(x, y)))
cnt += 1
def calc(data_num):
root = -1
for i in range(1, data_num+1):
if len(G[i]) == 1:
root = i
break
makeNodeList(root)
dfs(root)
node_list.reverse()
dfs_rev(root)
#-------------------------------------------------------------------
def main():
n = int(eval(input()))
for i in range(n-1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
calc(n)
for i in range(1, n+1): print((dat[i].num))
if __name__ == "__main__": main()
| p02728 |
from collections import deque
import sys
input=sys.stdin.readline
def abc():
global qqq
for i in range(len(ppp)-1,0,-1):
qqq=qqq*cmb(ppp[i],ppp[i-1])%mod
return qqq
mod=10**9+7
MAX=2*10**5+100
g1=[1,1]
g2=[1,1]
for i in range(2,MAX+1):
num_1=g1[-1]*i%mod
g1.append(num_1)
g2.append(pow(num_1,mod-2,mod))
def cmb(n,r):
return g1[n]*g2[r]*g2[n-r]%mod
N=int(eval(input()))
AB=[list(map(int,input().split())) for i in range(N-1)]
data=[[] for i in range(N+1)]
for A,B in AB:
data[A].append(B)
data[B].append(A)
parent=[0]*(N+1)
flag=[0]*(N+1)
child=[0]*(N+1)
parent[1]=-1
flag[1]=1
que=[1]
ddd=deque([])
while que:
h=[]
for u in que:
for v in data[u]:
if flag[v]==0:
flag[v]=1
h.append(v)
parent[v]=u
child[u]+=1
if child[u]==0:
ddd.append(u)
que=h
size=[0]*(N+1)
lst=[0]*(N+1)
while ddd:
u=ddd.pop()
size[u]=1
qqq=1
ppp=[]
for v in data[u]:
if v==parent[u]:
child[v]-=1
if child[v]==0:
ddd.appendleft(v)
continue
else:
size[u]+=size[v]
if ppp:
ppp.append(size[v]+ppp[-1])
else:
ppp.append(size[v])
qqq=qqq*lst[v]%mod
lst[u]=abc()
que=deque(data[1][:])
ans=[0]*(N+1)
lsls=[0]*(N+1)
ans[1]=lst[1]
lsls[1]=1
while que:
u=que.pop()
par=parent[u]
qqq=1
qqq*=lsls[par]
ppp=N-size[par]
for v in data[par]:
if v==u:
continue
if v==parent[par]:
continue
else:
qqq=qqq*lst[v]*cmb(size[v]+ppp,ppp)%mod
ppp+=size[v]
lsls[u]=qqq
ppp=N-size[u]
for v in data[u]:
if v==parent[u]:
continue
else:
qqq=qqq*lst[v]*cmb(size[v]+ppp,ppp)%mod
ppp+=size[v]
que.appendleft(v)
ans[u]=qqq
for i in range(1,N+1):
print((ans[i])) | from collections import deque
import sys
input=sys.stdin.readline
def abc():
global qqq
for i in range(len(ppp)-1,0,-1):
qqq=qqq*cmb(ppp[i],ppp[i-1])%mod
return qqq
mod=10**9+7
MAX=2*10**5+100
g1=[1,1]
g2=[1,1]
for i in range(2,MAX+1):
num_1=g1[-1]*i%mod
g1.append(num_1)
g2.append(pow(num_1,mod-2,mod))
def cmb(n,r):
return g1[n]*g2[r]*g2[n-r]%mod
N=int(eval(input()))
AB=[list(map(int,input().split())) for i in range(N-1)]
data=[[] for i in range(N+1)]
for A,B in AB:
data[A].append(B)
data[B].append(A)
parent=[0]*(N+1)
flag=[0]*(N+1)
child=[0]*(N+1)
parent[1]=-1
flag[1]=1
que=[1]
ddd=deque([])
while que:
h=[]
for u in que:
for v in data[u]:
if flag[v]==0:
flag[v]=1
h.append(v)
parent[v]=u
child[u]+=1
if child[u]==0:
ddd.append(u)
que=h
#sizeは、子の数
size=[0]*(N+1)
#lstは、書く順番の総数
lst=[0]*(N+1)
while ddd:
u=ddd.pop()
size[u]=1
qqq=1
ppp=[]
for v in data[u]:
if v==parent[u]:
child[v]-=1
if child[v]==0:
ddd.appendleft(v)
continue
else:
size[u]+=size[v]
if ppp:
ppp.append(size[v]+ppp[-1])
else:
ppp.append(size[v])
qqq=qqq*lst[v]%mod
lst[u]=abc()
que=deque(data[1][:])
#iを根としたときの答え
ans=[0]*(N+1)
#lslsは親方向の場合の数
lsls=[0]*(N+1)
ans[1]=lst[1]
lsls[1]=1
while que:
#uに対する場合の数を求める
u=que.pop()
par=parent[u]
ppp=N-size[par]
num=lst[u]*cmb(size[par]-1,size[u])
qqq=lst[par]*pow(num,mod-2,mod)%mod
qqq=qqq*lsls[par]*cmb(ppp+size[par]-size[u]-1,ppp)%mod
lsls[u]=qqq
ppp=N-size[u]
qqq=qqq*cmb(N-1,size[u]-1)*lst[u]%mod
ans[u]=qqq
for v in data[u]:
if v==par:
continue
else:
que.appendleft(v)
for i in range(1,N+1):
print((ans[i]))
| p02728 |
from functools import *
from collections import *
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.buffer.readline
M = 10**9+7
@lru_cache(maxsize=None)
def mod_inv(x):
if x == 1:
return 1
return M // x * -mod_inv(M%x) % M
@lru_cache(maxsize=None)
def calc_subtree(v):
ret = 1
size = 1
for child in Edge[v]:
Edge[child].remove(v)
r, s = calc_subtree(child)
ret = ret * r % M
size += s
ret = ret * size % M
return ret, size
ans = {}
def set_ans(v, a):
ans[v] = a
for child in Edge[v]:
n = calc_subtree(child)[1]
set_ans(child, ans[v] * n * mod_inv(N-n) % M)
N = int(eval(input()))
Edge = defaultdict(set)
fact = N
for i in range(1, N):
fact = fact * i % M
a, b = list(map(int, input().split()))
Edge[a].add(b)
Edge[b].add(a)
set_ans(1, mod_inv(calc_subtree(1)[0]) * fact % M)
for i in range(1, N+1):
print((ans[i]))
| from functools import *
from collections import *
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.buffer.readline
M = 10**9+7
N = int(eval(input()))
@lru_cache(maxsize=None)
def mod_inv(x):
if x == 1:
return 1
return M // x * -mod_inv(M%x) % M
weight = [0]*(N+1)
size = [0]*(N+1)
def calc_subtree(v):
W = 1
S = 1
for child in Edge[v]:
Edge[child].remove(v)
w, s = calc_subtree(child)
W = W * w % M
S += s
weight[v] = W * S % M
size[v] = S
return weight[v], size[v]
ans = [0]*(N+1)
def set_ans(v, a):
ans[v] = a
for child in Edge[v]:
n = size[child]
set_ans(child, ans[v] * n * mod_inv(N-n) % M)
Edge = defaultdict(set)
fact = N
for i in range(1, N):
fact = fact * i % M
a, b = list(map(int, input().split()))
Edge[a].add(b)
Edge[b].add(a)
calc_subtree(1)
set_ans(1, mod_inv(weight[1]) * fact % M)
for i in range(1, N+1):
print((ans[i]))
| p02728 |
from functools import *
from collections import *
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.buffer.readline
M = 10**9+7
N = int(eval(input()))
@lru_cache(maxsize=None)
def mod_inv(x):
if x == 1:
return 1
return M // x * -mod_inv(M%x) % M
weight = [0]*(N+1)
size = [0]*(N+1)
def calc_subtree(v):
W = 1
S = 1
for child in Edge[v]:
Edge[child].remove(v)
w, s = calc_subtree(child)
W = W * w % M
S += s
weight[v] = W * S % M
size[v] = S
return weight[v], size[v]
ans = [0]*(N+1)
def set_ans(v, a):
ans[v] = a
for child in Edge[v]:
n = size[child]
set_ans(child, ans[v] * n * mod_inv(N-n) % M)
Edge = defaultdict(set)
fact = N
for i in range(1, N):
fact = fact * i % M
a, b = list(map(int, input().split()))
Edge[a].add(b)
Edge[b].add(a)
calc_subtree(1)
set_ans(1, mod_inv(weight[1]) * fact % M)
for i in range(1, N+1):
print((ans[i]))
| from functools import *
from itertools import *
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.buffer.readline
M = 10**9+7
N = int(eval(input()))
@lru_cache(maxsize=None)
def mod_inv(x):
return 1 if x == 1 else M // x * -mod_inv(M%x) % M
Weight = [0]*(N+1)
Size = [0]*(N+1)
def calc_subtree(v):
W, S = 1, 1
for child in Edge[v]:
Edge[child].remove(v)
w, s = calc_subtree(child)
W = W * w % M
S += s
Weight[v] = W * S % M
Size[v] = S
return Weight[v], Size[v]
Ans = [0]*(N+1)
def calc_ans(v, a):
Ans[v] = a
for child in Edge[v]:
n = Size[child]
calc_ans(child, Ans[v] * n * mod_inv(N-n) % M)
Edge = [set() for i in range(N+1)]
fact = N
for i in range(1, N):
fact = fact * i % M
a, b = list(map(int, input().split()))
Edge[a].add(b)
Edge[b].add(a)
calc_subtree(1)
calc_ans(1, mod_inv(Weight[1]) * fact % M)
for a in islice(Ans, 1, None):
print(a)
| p02728 |
import sys
from functools import lru_cache
sys.setrecursionlimit(1000000000)
def input(): return sys.stdin.readline().rstrip()
MOD = 10 ** 9 + 7
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
def inverse(x):
_, _, ans = egcd(MOD, x)
return (ans % MOD + MOD) % MOD
def memoize_fast(size):
def decorator(f):
memo = [-1] * size
def wrapper(i):
if memo[i] != -1:
return memo[i]
val = f(i)
memo[i] = val
return val
return wrapper
return decorator
@memoize_fast(3 * 10 ** 5)
def factorial(x):
if x <= 1:
return 1
return x * factorial(x - 1) % MOD
def combination(a, b):
return factorial(a) * inverse(factorial(b)) % MOD * inverse(factorial(a - b)) % MOD
N = int(eval(input()))
graph = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
graph[b].append(a)
children = [[] for _ in range(N)]
parent = [-1 for _ in range(N)]
visited = set()
def visit(node):
visited.add(node)
for n in graph[node]:
if n not in visited:
children[node].append(n)
parent[n] = node
visit(n)
visit(0)
@memoize_fast(3 * 10 ** 5)
def count(node):
c = 1
for child in children[node]:
c += count(child)
return c
@memoize_fast(3 * 10 ** 5)
def order(node):
ans = 1
counts = []
for child in children[node]:
ans *= order(child)
ans %= MOD
counts.append(count(child))
_sum = sum(counts)
while len(counts) > 0:
ans *= combination(_sum, counts[-1])
ans %= MOD
_sum -= counts.pop()
return ans
@memoize_fast(3 * 10 ** 5)
def order_all(node):
if parent[node] == -1:
return order(node)
return order_all(parent[node]) * inverse(order(node)) % MOD * inverse(combination(N - 1, count(node))) % MOD * order(node) % MOD * combination(N - 1, count(node) - 1) % MOD
for node in range(N):
print((order_all(node)))
| import sys
from functools import lru_cache
sys.setrecursionlimit(1000000000)
def input(): return sys.stdin.readline().rstrip()
MOD = 10 ** 9 + 7
def memoize_fast(size):
def decorator(f):
memo = [-1] * size
def wrapper(i):
if memo[i] != -1:
return memo[i]
val = f(i)
memo[i] = val
return val
return wrapper
return decorator
@memoize_fast(3 * 10 ** 5)
def factorial(x):
if x <= 1:
return 1
return x * factorial(x - 1) % MOD
@lru_cache(maxsize=None)
def inverse(x):
return pow(x, MOD - 2, MOD)
def combination(a, b):
return factorial(a) * inverse(factorial(b)) % MOD * inverse(factorial(a - b)) % MOD
N = int(eval(input()))
graph = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
graph[b].append(a)
children = [[] for _ in range(N)]
parent = [-1 for _ in range(N)]
visited = set()
def visit(node):
visited.add(node)
for n in graph[node]:
if n not in visited:
children[node].append(n)
parent[n] = node
visit(n)
visit(0)
@memoize_fast(3 * 10 ** 5)
def count(node):
c = 1
for child in children[node]:
c += count(child)
return c
@memoize_fast(3 * 10 ** 5)
def order(node):
ans = 1
counts = []
for child in children[node]:
ans *= order(child)
ans %= MOD
counts.append(count(child))
_sum = sum(counts)
while len(counts) > 0:
ans *= combination(_sum, counts[-1])
ans %= MOD
_sum -= counts.pop()
return ans
@memoize_fast(3 * 10 ** 5)
def order_all(node):
if parent[node] == -1:
return order(node)
return order_all(parent[node]) * inverse(order(node)) % MOD * inverse(combination(N - 1, count(node))) % MOD * order(node) % MOD * combination(N - 1, count(node) - 1) % MOD
for node in range(N):
print((order_all(node)))
| p02728 |
import sys
input = sys.stdin.readline
from collections import deque
nn = 202020
mod = 10 ** 9 + 7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
C = lambda a, b: fa[a] * fainv[b] * fainv[a-b] % mod if 0 <= b <= a else 0
N = int(eval(input()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 0
for j in X[i]:
a = a * BU[j] * fainv[SI[j]] % mod
s += SI[j]
SI[i] = s + 1
BU[i] = fa[s] * a % mod
for i in R:
a = TD[i] * fainv[N - SI[i]]
for j in X[i]:
a = a * BU[j] * fainv[SI[j]] % mod
for j in X[i]:
TD[j] = a * pow(BU[j], mod-2, mod) % mod * fa[SI[j]] % mod * fa[N - 1 - SI[j]] % mod
for i in range(N):
print((BU[i] * TD[i] % mod * C(N-1, SI[i] - 1) % mod)) | import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
C = lambda a, b: fa[a] * fainv[b] % mod * fainv[a-b] % mod if 0 <= b <= a else 0
N = int(eval(input()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 0
for j in X[i]:
a = a * BU[j] * fainv[SI[j]] % mod
s += SI[j]
SI[i] = s + 1
BU[i] = fa[s] * a % mod
for i in R:
c = len(X[i])
AL = [1] * (c + 1)
AR = [1] * (c + 1)
for j in range(c):
AL[j+1] = AL[j] * BU[X[i][j]] % mod * fainv[SI[X[i][j]]] % mod
for j in range(c)[::-1]:
AR[j] = AR[j+1] * BU[X[i][j]] % mod * fainv[SI[X[i][j]]] % mod
for j in range(c):
TD[X[i][j]] = TD[i] * fainv[N - SI[i]] % mod * AL[j] % mod * AR[j+1] % mod * fa[N - 1 - SI[X[i][j]]] % mod
for i in range(N):
print((BU[i] * TD[i] % mod * C(N-1, SI[i] - 1) % mod)) | p02728 |
import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
inv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i-1]
C = lambda a, b: fa[a] * fainv[b] % mod * fainv[a-b] % mod if 0 <= b <= a else 0
N = int(eval(input()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 1
for j in X[i]:
a = a * BU[j] % mod
s += SI[j]
SI[i] = s
BU[i] = inv[s] * a % mod
for i in R:
c = len(X[i])
AR = [1] * (c + 1)
AL = 1
for k in range(c-1, 0, -1):
j = X[i][k]
AR[k] = AR[k+1] * BU[j] % mod
for k, j in enumerate(X[i]):
TD[j] = TD[i] * AL % mod * AR[k+1] % mod * inv[N - SI[j]] % mod
AL = AL * BU[j] % mod
for i in range(N):
print((BU[i] * fa[SI[i]] % mod * TD[i] % mod * fa[N - SI[i]] % mod * C(N-1, SI[i] - 1) % mod)) | import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
inv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i-1]
C = lambda a, b: fa[a] * fainv[b] % mod * fainv[a-b] % mod if 0 <= b <= a else 0
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [1] * N
TD = [1] * N
SI = [1] * N
for i in R[::-1]:
a = 1
s = 1
for j in X[i]:
a = a * BU[j] % mod
s += SI[j]
SI[i] = s
BU[i] = inv[s] * a % mod
for i in R:
c = len(X[i])
AL = [1] * (c + 1)
AR = [1] * (c + 1)
for k, j in enumerate(X[i]):
AL[k+1] = AL[k] * BU[j] % mod
for k in range(c-1, 0, -1):
j = X[i][k]
AR[k] = AR[k+1] * BU[j] % mod
for k, j in enumerate(X[i]):
TD[j] = TD[i] * AL[k] % mod * AR[k+1] % mod * inv[N - SI[j]] % mod
print(*[BU[i] * fa[SI[i]] % mod * TD[i] % mod * fa[N - SI[i]] % mod * C(N-1, SI[i] - 1) % mod for i in range(N)], sep = "\n")
| p02728 |
import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
inv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i-1]
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
unit = 1
f = lambda a, b: a * b % mod
g_bu = lambda a, i=-1: a * inv[SI[i]] % mod
g_td = lambda a, i=-1: a * inv[N - SI[i]] % mod
SI = [1] * N
for i in R[::-1]:
for j in X[i]:
SI[i] += SI[j]
BU = [unit] * N
TD = [unit] * N
for i in R[::-1]:
a = 1
for j in X[i]:
a = f(a, BU[j])
BU[i] = g_bu(a, i)
AX = [1] * N
for i in R:
ac = unit
for j in X[i]:
AX[j] = ac
ac = f(ac, BU[j])
ac = unit
for j in X[i][::-1]:
AX[j] = f(AX[j], ac)
TD[j] = g_td(f(TD[i], AX[j]), j)
ac = f(ac, BU[j])
print(*[BU[i] * SI[i] % mod * TD[i] % mod * fa[N - 1] % mod for i in range(N)], sep = "\n")
| import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
inv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i-1]
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
unit = 1
f = lambda a, b: a * b % mod
g_bu = lambda a, i=-1: a * inv[SI[i]] % mod
g_td = lambda a, i=-1: a * inv[N - SI[i]] % mod
SI = [1] * N
for i in R[1:][::-1]:
SI[P[i]] += SI[i]
BU = [unit] * N
TD = [unit] * N
for i in R[1:][::-1]:
BU[i] = g_bu(BU[i], i)
p = P[i]
BU[p] = f(BU[p], BU[i])
BU[0] = g_bu(BU[0], 0)
AX = [1] * N
for i in R:
ac = unit
for j in X[i]:
AX[j] = ac
ac = f(ac, BU[j])
ac = unit
for j in X[i][::-1]:
AX[j] = f(AX[j], ac)
TD[j] = g_td(f(TD[i], AX[j]), j)
ac = f(ac, BU[j])
print(*[BU[i] * SI[i] % mod * TD[i] % mod * fa[N - 1] % mod for i in range(N)], sep = "\n")
| p02728 |
import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
inv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
for i in range(1, nn)[::-1]:
inv[i] = fainv[i] * fa[i-1]
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
unit = 1
f = lambda a, b: a * b % mod
g_bu = lambda a, i=-1: a * inv[SI[i]] % mod
g_td = lambda a, i=-1: a * inv[N - SI[i]] % mod
SI = [1] * N
for i in R[1:][::-1]:
SI[P[i]] += SI[i]
BU = [unit] * N
TD = [unit] * N
for i in R[1:][::-1]:
BU[i] = g_bu(BU[i], i)
p = P[i]
BU[p] = f(BU[p], BU[i])
BU[0] = g_bu(BU[0], 0)
AX = [1] * N
for i in R:
ac = unit
for j in X[i]:
AX[j] = ac
ac = f(ac, BU[j])
ac = unit
for j in X[i][::-1]:
AX[j] = f(AX[j], ac)
TD[j] = g_td(f(TD[i], AX[j]), j)
ac = f(ac, BU[j])
print(*[BU[i] * SI[i] % mod * TD[i] % mod * fa[N - 1] % mod for i in range(N)], sep = "\n")
| import sys
input = sys.stdin.readline
from collections import deque
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
inv = lambda i: fainv[i] * fa[i-1] % mod
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
unit = 1
f = lambda a, b: a * b % mod
g_bu = lambda a, i=-1: a * inv(SI[i]) % mod
g_td = lambda a, i=-1: a * inv(N - SI[i]) % mod
SI = [1] * N
for i in R[1:][::-1]:
SI[P[i]] += SI[i]
BU = [unit] * N
TD = [unit] * N
for i in R[1:][::-1]:
BU[i] = g_bu(BU[i], i)
p = P[i]
BU[p] = f(BU[p], BU[i])
BU[R[0]] = g_bu(BU[R[0]], R[0])
AX = [1] * N
for i in R:
ac = unit
for j in X[i]:
AX[j] = ac
ac = f(ac, BU[j])
ac = unit
for j in X[i][::-1]:
AX[j] = f(AX[j], ac)
TD[j] = g_td(f(TD[i], AX[j]), j)
ac = f(ac, BU[j])
print(*[BU[i] * SI[i] % mod * TD[i] % mod * fa[N - 1] % mod for i in range(N)], sep = "\n")
| p02728 |
import sys
input = sys.stdin.readline
from collections import deque
mod = 10 ** 9 + 7
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
##### Settings
unit = 1
merge = lambda a, b: a * b % mod
adj_bu = lambda a, i: a * inv(SIZE[i]) % mod
adj_td = lambda a, i, p: a * inv(N-SIZE[i]) % mod
adj_butd = lambda a, i: a * inv(N) % mod
#####
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
inv = lambda i: fainv[i] * fa[i-1] % mod
SIZE = [1] * N
for i in R[1:][::-1]:
SIZE[P[i]] += SIZE[i]
ME = [unit] * N
XX = [0] * N
TD = [unit] * N
for i in R[1:][::-1]:
XX[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], XX[i])
XX[R[0]] = adj_bu(ME[R[0]], R[0])
for i in R:
ac = TD[i]
for j in X[i]:
TD[j] = ac
ac = merge(ac, XX[j])
ac = unit
for j in X[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, XX[j])
XX[j] = adj_butd(merge(ME[j], TD[j]), j)
XX = [x * fa[N] % mod for x in XX]
print(*XX, sep = "\n")
| import sys
input = sys.stdin.readline
from collections import deque
mod = 10 ** 9 + 7
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
##### Settings
unit = 1
merge = lambda a, b: a * b % mod
adj_bu = lambda a, i: a * inv(SIZE[i]) % mod
adj_td = lambda a, i, p: a * inv(N-SIZE[i]) % mod
adj_fin = lambda a, i: a * fa[N-1] % mod
#####
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
inv = lambda i: fainv[i] * fa[i-1] % mod
SIZE = [1] * N
for i in R[1:][::-1]:
SIZE[P[i]] += SIZE[i]
ME = [unit] * N
XX = [0] * N
TD = [unit] * N
for i in R[1:][::-1]:
XX[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], XX[i])
XX[R[0]] = adj_fin(ME[R[0]], R[0])
for i in R:
ac = TD[i]
for j in X[i]:
TD[j] = ac
ac = merge(ac, XX[j])
ac = unit
for j in X[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, XX[j])
XX[j] = adj_fin(merge(ME[j], TD[j]), j)
print(*XX, sep = "\n")
| p02728 |
import sys
input = sys.stdin.readline
from collections import deque
mod = 10 ** 9 + 7
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
##### Settings
unit = 1
merge = lambda a, b: a * b % mod
adj_bu = lambda a, i: a * inv(SIZE[i]) % mod
adj_td = lambda a, i, p: a * inv(N-SIZE[i]) % mod
adj_fin = lambda a, i: a * fa[N-1] % mod
#####
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
inv = lambda i: fainv[i] * fa[i-1] % mod
SIZE = [1] * N
for i in reversed(R[1:]):
SIZE[P[i]] += SIZE[i]
ME = [unit] * N
XX = [0] * N
TD = [unit] * N
for i in reversed(R[1:]):
XX[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], XX[i])
XX[R[0]] = adj_fin(ME[R[0]], R[0])
for i in R:
ac = TD[i]
for j in X[i]:
TD[j] = ac
ac = merge(ac, XX[j])
ac = unit
for j in reversed(X[i]):
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, XX[j])
XX[j] = adj_fin(merge(ME[j], TD[j]), j)
print(*XX, sep = "\n")
| import sys
input = sys.stdin.readline
from collections import deque
mod = 10 ** 9 + 7
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
##### Settings
unit = 1
merge = lambda a, b: a * b % mod
adj_bu = lambda a, i: a * inv(SIZE[i]) % mod
adj_td = lambda a, i, p: a * inv(N-SIZE[i]) % mod
adj_fin = lambda a, i: a * fa[N-1] % mod
#####
nn = 200200
mod = 10**9+7
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % mod
fainv[-1] = pow(fa[-1], mod-2, mod)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % mod
inv = lambda i: fainv[i] * fa[i-1] % mod
SIZE = [1] * N
for i in R[1:][::-1]:
SIZE[P[i]] += SIZE[i]
ME = [unit] * N
XX = [0] * N
TD = [unit] * N
for i in R[1:][::-1]:
XX[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], XX[i])
XX[R[0]] = adj_fin(ME[R[0]], R[0])
for i in R:
ac = TD[i]
for j in X[i]:
TD[j] = ac
ac = merge(ac, XX[j])
ac = unit
for j in X[i][::-1]:
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, XX[j])
XX[j] = adj_fin(merge(ME[j], TD[j]), j)
print(*XX, sep = "\n")
| p02728 |
def main():
import sys
from collections import deque
input = sys.stdin.readline
# comb init
mod = 1000000007
nmax = 2*10 ** 5 + 10 # change here
fac = [0] * nmax
finv = [0] * nmax
inv = [0] * nmax
fac[0] = 1
fac[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, nmax):
fac[i] = fac[i - 1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i - 1] * inv[i] % mod
def comb(n, r):
if n < r:
return 0
else:
return (fac[n] * ((finv[r] * finv[n - r]) % mod)) % mod
N = int(eval(input()))
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)
que = deque()
que.append(1)
seen = [-1] * (N+1)
seen[1] = 0
par = [0] * (N+1)
child = [[] for _ in range(N+1)]
seq = []
while que:
v = que.popleft()
seq.append(v)
for u in adj[v]:
if seen[u] == -1:
seen[u] = seen[v] + 1
par[u] = v
child[v].append(u)
que.append(u)
seq.reverse()
dp = [1] * (N+1)
size = [1] * (N+1)
for v in seq:
for u in child[v]:
size[v] += size[u]
L = size[v] - 1
for u in child[v]:
dp[v] = (dp[v] * (dp[u] * comb(L, size[u]))%mod)%mod
L -= size[u]
seq.reverse()
dp2 = [0] * (N+1)
for v in seq:
if v == 1:
dp2[1] = dp[1]
continue
p = par[v]
dp2[v] = dp[v]
PP = (dp2[p] * pow((dp[v] * comb(N-1, size[v]))%mod, mod-2, mod))%mod
dp2[v] = (dp2[v] * PP * comb(N-1, size[v]-1))%mod
for v in range(1, N+1):
print((dp2[v]))
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.readline
# comb init
mod = 1000000007
nmax = 2 * 10 ** 5 + 10 # change here
fac = [0] * nmax
finv = [0] * nmax
inv = [0] * nmax
fac[0] = 1
fac[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, nmax):
fac[i] = fac[i - 1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i - 1] * inv[i] % mod
def comb(n, r):
if n < r:
return 0
else:
return (fac[n] * ((finv[r] * finv[n - r]) % mod)) % mod
N = int(eval(input()))
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)
"""ここから変更"""
# op: 普通に根を固定した木DPで子の情報を親に集めるときの演算
def op(a, b):
return (((a[0] * b[0])%mod * comb(a[1]+b[1]+1, a[1]))%mod, a[1]+b[1]+1)
ident_op = (1, -1)
# cum_merge: 累積opどうしをマージするときの演算
def cum_merge(a, b):
return (((a[0] * b[0])%mod * comb(a[1]+b[1], a[1]))%mod, a[1]+b[1])
# 単位元(cum_merge(ident, x) = x)
ident_cum_merge = (1, 0)
"""ここまで変更"""
# root=1でまず普通に木DPをする
# 並行して各頂点につき、子の値の累積opを左右から求めておく
# その後根から順番に、親からの寄与を求めていく(from_par)
def Rerooting(adj):
N = len(adj) - 1
st = [1]
seen = [0] * (N + 1)
seen[1] = 1
par = [0] * (N + 1)
child = [[] for _ in range(N + 1)]
seq = []
while st:
v = st.pop()
seq.append(v)
for u in adj[v]:
if not seen[u]:
seen[u] = 1
par[u] = v
child[v].append(u)
st.append(u)
seq.reverse()
dp = [ident_op] * (N + 1)
left = [ident_cum_merge] * (N + 1)
right = [ident_cum_merge] * (N + 1)
for v in seq:
tmp = ident_cum_merge
for u in child[v]:
left[u] = tmp
tmp = op(tmp, dp[u])
tmp = ident_cum_merge
for u in reversed(child[v]):
right[u] = tmp
tmp = op(tmp, dp[u])
dp[v] = tmp
seq.reverse()
from_par = [ident_op] * (N + 1)
for v in seq:
if v == 1:
continue
from_par[v] = op(cum_merge(left[v], right[v]), from_par[par[v]])
dp[v] = op(dp[v], from_par[v])
return dp
dp = Rerooting(adj)
for v in range(1, N+1):
print((dp[v][0]))
if __name__ == '__main__':
main()
| p02728 |
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
from collections import deque
MOD = 10**9 + 7
N = int(input())
tree = dict(zip(range(N), [[] for i in range(N)]))
edge_id = {}
c = 0
for i in range(N-1):
a, b = map(int, input().split())
a, b = a-1, b-1
tree[a].append(b)
tree[b].append(a)
edge_id[(a, b)] = c
edge_id[(b, a)] = c + 1
c += 2
# 部分木のサイズ
# 頂点v1 -> v2の向きを考えたときに、頂点v2を根とする部分木のサイズを計算する
size = [0] * 2*(N-1)
def calc_size(v1, v2):
global size
idx = edge_id[(v1, v2)]
if size[idx]:
return size[idx]
children = tree[v2]
s = 1
for child in children:
if child == v1:
continue
s += calc_size(v2, child)
size[idx] = s
idx_inv = edge_id[(v2, v1)]
size[idx_inv] = N - s
return s
# 階乗、組合せの計算
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
MOD = 10**9+7
for i in range(2, 2*10**5+1):
g1.append((g1[-1] * i) % MOD)
inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)
g2.append((g2[-1] * inverse[-1]) % MOD)
def comb(n, r, mod=MOD):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n-r] % mod
# 頂点iに1を書くときの場合の数
ans = [0] * N
dp = [0] * 2*(N-1)
def calc_dp(v1, v2):
global dp
idx = edge_id[(v1, v2)]
if dp[idx]:
return dp[idx]
children = tree[v2]
s = calc_size(v1, v2)
res = g1[s-1]
for child in children:
if child == v1:
continue
res *= calc_dp(v2, child)
res %= MOD
_s = calc_size(v2, child)
res *= g2[_s]
res %= MOD
dp[idx] = res
return res
def calc_ans(i):
global ans
global dp
if ans[i]:
return ans[i]
children = tree[i]
res = g1[N-1]
for child in children:
res *= calc_dp(i, child)
res %= MOD
_s = calc_size(i, child)
res *= g2[_s]
res %= MOD
ans[i] = res
return res
# 頂点0に1と記入する場合の数を求める
calc_ans(0)
# そこからはbfsで子に伝搬させていく
# 伝搬の漸化式はnode -> childのとき
# ans[child] = ans[node] * size[(node, child)]/size[(child, node)]
d = deque([[0, -1]])
c = 0
while d:
node, par = d.popleft()
c += 1
children = tree[node]
for child in children:
if child == par:
continue
s = calc_size(node, child)
r = s * pow(N-s, MOD-2, MOD) % MOD
ans[child] = ans[node] * r % MOD
d.append([child, node])
print(*ans, sep='\n')
| import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
from collections import deque
MOD = 10**9 + 7
N = int(input())
tree = dict(zip(range(N), [[] for i in range(N)]))
edge_id = {}
c = 0
for i in range(N-1):
a, b = map(int, input().split())
a, b = a-1, b-1
tree[a].append(b)
tree[b].append(a)
edge_id[(a, b)] = c
edge_id[(b, a)] = c + 1
c += 2
# 部分木のサイズ
# 頂点v1 -> v2の向きを考えたときに、頂点v2を根とする部分木のサイズを計算する
size = [0] * 2*(N-1)
def calc_size(v1, v2):
global size
idx = edge_id[(v1, v2)]
if size[idx]:
return size[idx]
children = tree[v2]
s = 1
for child in children:
if child == v1:
continue
s += calc_size(v2, child)
size[idx] = s
idx_inv = edge_id[(v2, v1)]
size[idx_inv] = N - s
return s
# 階乗、組合せの計算
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
MOD = 10**9+7
for i in range(2, 2*10**5+1):
g1.append((g1[-1] * i) % MOD)
inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)
g2.append((g2[-1] * inverse[-1]) % MOD)
def comb(n, r, mod=MOD):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n-r] % mod
# 頂点iに1を書くときの場合の数
ans = [0] * N
dp = [0] * 2*(N-1)
def calc_dp(v1, v2):
global dp
idx = edge_id[(v1, v2)]
if dp[idx]:
return dp[idx]
children = tree[v2]
s = calc_size(v1, v2)
res = g1[s-1]
for child in children:
if child == v1:
continue
res *= calc_dp(v2, child)
res %= MOD
_s = calc_size(v2, child)
res *= g2[_s]
res %= MOD
dp[idx] = res
return res
def calc_ans(i):
global ans
global dp
if ans[i]:
return ans[i]
children = tree[i]
res = g1[N-1]
for child in children:
res *= calc_dp(i, child)
res %= MOD
_s = calc_size(i, child)
res *= g2[_s]
res %= MOD
ans[i] = res
return res
# 頂点0に1と記入する場合の数を求める
calc_ans(0)
# そこからはbfsで子に伝搬させていく
# 伝搬の漸化式はnode -> childのとき
# ans[child] = ans[node] * size[(node, child)]/size[(child, node)]
d = deque([[0, -1]])
c = 0
while d:
node, par = d.popleft()
c += 1
children = tree[node]
for child in children:
if child == par:
continue
s1 = calc_size(node, child)
s2 = N - s1
r = (g1[s1] * g1[s2-1] % MOD) * (g2[s1-1] * g2[s2] % MOD) % MOD
ans[child] = ans[node] * r % MOD
d.append([child, node])
print(*ans, sep='\n')
| p02728 |
import sys;input=sys.stdin.readline
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0: return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else: return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
def div2(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
NNN = (10**6)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
from collections import deque
N, = list(map(int, input().split()))
d = [list() for _ in range(N+1)]
d2 = [list() for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
d[a].append(b)
d[b].append(a)
queue=deque([1])
vs = set([1])
vs_bfs = list()
parents = [0] * (N+1)
while queue:
v = queue.popleft()
vs_bfs.append(v)
for u in d[v]:
if u in vs:
continue
parents[u] = v
vs.add(u)
queue.append(u)
d2[v].append(u)
dp1 = [0 for _ in range(N+1)]
sss = [0 for _ in range(N+1)]
for v in vs_bfs[::-1]:
t = 1
ts = []
for u in d2[v]:
t = mul(dp1[u], t)
ts.append(sss[u])
st = sum(ts)
sss[v] = st + 1
for tt in ts:
t = mul(cmb(st, tt, mod), t)
st -= tt
dp1[v] = t
#print(dp1)
dp2 = [0]*(N+1)
for v in vs_bfs:
if v == 1:
dp2[v] = dp1[v]
continue
p = parents[v]
# print(dp2[p])
t = div2(dp2[p], mul(dp1[v], cmb(N-1, sss[v], mod)))
dp2[v] = mul(mul(dp1[v], t), cmb(N-1, N-sss[v], mod))
#print(dp2)
for x in dp2[1:]:
print(x)
| import sys;input=sys.stdin.readline
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0: return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else: return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
def div2(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
NNN = (10**6)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
from collections import deque
N, = list(map(int, input().split()))
d = [list() for _ in range(N+1)]
d2 = [list() for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
d[a].append(b)
d[b].append(a)
queue=deque([1])
vs = set([1])
vs_bfs = list()
parents = [0] * (N+1)
while queue:
v = queue.popleft()
vs_bfs.append(v)
for u in d[v]:
if u in vs:
continue
parents[u] = v
vs.add(u)
queue.append(u)
d2[v].append(u)
dp1 = [0 for _ in range(N+1)]
sss = [0 for _ in range(N+1)]
for v in vs_bfs[::-1]:
t = 1
ts = []
for u in d2[v]:
t = mul(dp1[u], t)
ts.append(sss[u])
st = sum(ts)
sss[v] = st + 1
for tt in ts:
t = mul(cmb(st, tt, mod), t)
st -= tt
dp1[v] = t
#print(dp1)
for v in vs_bfs:
if v == 1:
continue
p = parents[v]
# print(dp2[p])
dp1[v] = mul(
div2(dp1[p], cmb(N-1, sss[v], mod)),
cmb(N-1, N-sss[v], mod))
#print(dp2)
for x in dp1[1:]:
print(x)
| p02728 |
import sys;input=sys.stdin.readline
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0: return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else: return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
def div2(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
NNN = (10**6)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
from collections import deque
N, = list(map(int, input().split()))
d = [list() for _ in range(N+1)]
d2 = [list() for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
d[a].append(b)
d[b].append(a)
queue=deque([1])
vs = set([1])
vs_bfs = list()
parents = [0] * (N+1)
while queue:
v = queue.popleft()
vs_bfs.append(v)
for u in d[v]:
if u in vs:
continue
parents[u] = v
vs.add(u)
queue.append(u)
d2[v].append(u)
dp1 = [0 for _ in range(N+1)]
sss = [0 for _ in range(N+1)]
for v in vs_bfs[::-1]:
t = 1
ts = []
for u in d2[v]:
t = mul(dp1[u], t)
ts.append(sss[u])
st = sum(ts)
sss[v] = st + 1
for tt in ts:
t = mul(cmb(st, tt, mod), t)
st -= tt
dp1[v] = t
#print(dp1)
for v in vs_bfs:
if v == 1:
continue
p = parents[v]
# print(dp2[p])
dp1[v] = mul(
div2(dp1[p], cmb(N-1, sss[v], mod)),
cmb(N-1, N-sss[v], mod))
#print(dp2)
for x in dp1[1:]:
print(x)
| import sys;input=sys.stdin.readline
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0: return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else: return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
def div2(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
NNN = (2*10**5)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
from collections import deque
N, = list(map(int, input().split()))
d = [list() for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
d[a].append(b)
d[b].append(a)
vs = set([1])
stack = [1]
vs_bfs = list()
parents = [0] * (N+1)
while stack:
v = stack.pop()
vs_bfs.append(v)
for u in d[v]:
if u in vs:
continue
parents[u] = v
vs.add(u)
stack.append(u)
dp1 = [0 for _ in range(N+1)]
sss = [0 for _ in range(N+1)]
for v in vs_bfs[::-1]:
t = 1
ts = []
for u in d[v]:
if u == parents[v]:
continue
t = mul(dp1[u], t)
ts.append(sss[u])
st = sum(ts)
sss[v] = st + 1
for tt in ts:
t = mul(cmb(st, tt, mod), t)
st -= tt
dp1[v] = t
for v in vs_bfs:
if v == 1:
continue
p = parents[v]
dp1[v] = mul(
div2(dp1[p], cmb(N-1, sss[v], mod)),
cmb(N-1, N-sss[v], mod))
for x in dp1[1:]:
print(x)
| p02728 |
import sys;input=sys.stdin.readline
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0: return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else: return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
def div2(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
NNN = (2*10**5)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
from collections import deque
N, = list(map(int, input().split()))
d = [list() for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
d[a].append(b)
d[b].append(a)
vs = set([1])
stack = [1]
vs_bfs = list()
parents = [0] * (N+1)
while stack:
v = stack.pop()
vs_bfs.append(v)
for u in d[v]:
if u in vs:
continue
parents[u] = v
vs.add(u)
stack.append(u)
dp1 = [0 for _ in range(N+1)]
sss = [0 for _ in range(N+1)]
for v in vs_bfs[::-1]:
t = 1
ts = []
for u in d[v]:
if u == parents[v]:
continue
t = mul(dp1[u], t)
ts.append(sss[u])
st = sum(ts)
sss[v] = st + 1
for tt in ts:
t = mul(cmb(st, tt, mod), t)
st -= tt
dp1[v] = t
for v in vs_bfs:
if v == 1:
continue
p = parents[v]
dp1[v] = mul(
div(dp1[p], cmb(N-1, sss[v], mod)),
cmb(N-1, N-sss[v], mod))
for x in dp1[1:]:
print(x)
| import sys;input=sys.stdin.readline
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
NNN = (2*10**5)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N, = list(map(int, input().split()))
d = [list() for _ in range(N+1)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
d[a].append(b)
d[b].append(a)
vs = set([1])
stack = [1]
vs_bfs = list()
parents = [0] * (N+1)
while stack:
v = stack.pop()
vs_bfs.append(v)
for u in d[v]:
if u in vs:
continue
parents[u] = v
vs.add(u)
stack.append(u)
dp1 = [0 for _ in range(N+1)]
sss = [0 for _ in range(N+1)]
for v in vs_bfs[::-1]:
t = 1
ts = []
for u in d[v]:
if u == parents[v]:
continue
t = mul(dp1[u], t)
ts.append(sss[u])
st = sum(ts)
sss[v] = st + 1
for tt in ts:
t = mul(cmb(st, tt, mod), t)
st -= tt
dp1[v] = t
for v in vs_bfs:
if v == 1:
continue
p = parents[v]
dp1[v] = mul(
div(dp1[p], cmb(N-1, sss[v], mod)),
cmb(N-1, N-sss[v], mod)
)
for x in dp1[1:]:
print(x)
| p02728 |
#!/usr/bin/env python3
import sys
from collections import defaultdict
from functools import lru_cache
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 1000000007 # type: int
class Graph(object):
def __init__(self, N):
self.N = N
self.E = defaultdict(list)
def add_edge(self, src, dest, w=1):
self.E[src].append((dest, w))
self.E[dest].append((src, w))
def div(a, b):
return (a * pow(b, MOD-2, MOD)) % MOD
class Combination(object):
def __init__(self, N, mod=MOD):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
@lru_cache(maxsize=None)
def __call__(self, n, k):
# print("A", n, k)
if n < k:
return 0
if n < 0 or k < 0:
return 0
fac = self.fac
finv = self.finv
mod = self.MOD
# print("B", n, k, n-k)
return fac[n] * (finv[k]*finv[n-k] % mod) % mod
class DP(object):
def __init__(self, dp0=1, t0=0):
self.dp = dp0
self.t = t0
pass
def __iadd__(self, a):
self.dp *= cmb(self.t+a.t, a.t)
self.dp *= a.dp
self.t += a.t
return self
def __sub__(self, a):
dp = DP()
dp.dp = div(self.dp, cmb(self.t-1, a.t))
dp.dp = div(dp.dp, a.dp)
dp.t = self.t - a.t
return dp
def add_root(self):
self.t += 1
return self
def __str__(self):
return "({}通り, {}個)".format(self.dp, self.t)
def solve(N: int, a: "List[int]", b: "List[int]"):
# print(div(3, 2))
# 全方位木DPをやるぞ！
# 1. 木DPによって頂点ごとにhogeを求める
# 2. 木DPで求めたhogeを使って、上手く求める
# グラフの構築
g = Graph(N)
for aa, bb in zip(a, b):
g.add_edge(aa-1, bb-1)
# 組み合わせの初期化
cmb = Combination(N)
dp = [1]*N # 節点vを根とした部分木の塗り方dp[v]
size = [0]*N # 節点vを根とした部分木のサイズsize[v]+1
# 木DPを行うDFS
def dfs(v, p=-1):
# print("dfs start", v, p)
for u, _ in g.E[v]:
if u == p:
continue
dfs(u, v)
# print("dfs", u, v)
size[v] += size[u]+1
dp[v] *= cmb(size[v], size[u]+1)
dp[v] %= MOD
dp[v] *= dp[u]
dp[v] %= MOD
# print("dfs end", v, (size[v], dp[v]))
return
dfs(0, -1)
# print(*[(d, s) for d, s in zip(dp, size)])
# 節点0には木の根としての値を求めた。
# 0以外の節点には部分木の根としての値を求めた。
# 木の根としての値を求めた節点を親としてもつ節点は、自身を木の根とした値を求めることができる
# 全方位木DPを行うBFS
def bfs(v, p=-1):
for u, _ in g.E[v]:
if u == p:
continue
d = div(dp[v], cmb(size[v], size[u]+1))
d = div(d, dp[u])
dp[u] *= cmb(N-1, size[u])
dp[u] %= MOD
dp[u] *= d
dp[u] %= MOD
size[u] = N-1
bfs(u, v)
bfs(0, -1)
for v in dp:
print(v)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N - 1) # type: "List[int]"
b = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, a, b)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from collections import defaultdict
from functools import lru_cache
from collections import deque
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 1000000007 # type: int
class Graph(object):
def __init__(self, N):
self.N = N
self.E = defaultdict(list)
def add_edge(self, src, dest, w=1):
self.E[src].append((dest, w))
self.E[dest].append((src, w))
@lru_cache(maxsize=None)
def div(a, b):
return (a * pow(b, MOD-2, MOD)) % MOD
class Combination(object):
def __init__(self, N, mod=MOD):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
@lru_cache(maxsize=None)
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
b = (self.finv[k]*self.finv[n-k] % self.MOD)
return (self.fac[n] * b) % self.MOD
def solve(N: int, a: "List[int]", b: "List[int]"):
# print(div(3, 2))
# 全方位木DPをやるぞ！
# 1. 木DPによって頂点ごとにhogeを求める
# 2. 木DPで求めたhogeを使って、上手く求める
# グラフの構築
g = Graph(N)
for aa, bb in zip(a, b):
g.add_edge(aa-1, bb-1)
# 組み合わせの初期化
cmb = Combination(N)
dp = [1]*N # 節点vを根とした部分木の塗り方dp[v]
size = [0]*N # 節点vを根とした部分木のサイズsize[v]+1
# 木DPを行うDFS
queue = [(0, -1)]
seen = [False]*N
while queue:
v, p = queue[-1]
flag = True
if seen[v] is False:
for u, _ in g.E[v]:
if u == p:
continue
if seen[u] is False:
queue.append((u, v))
flag = False
if flag is True:
# 処理
for u, _ in g.E[v]:
if u == p:
continue
size[v] += size[u]+1
dp[v] *= cmb(size[v], size[u]+1)
dp[v] %= MOD
dp[v] *= dp[u]
dp[v] %= MOD
# print(v, p)
queue.pop()
seen[v] = True
# print(*queue)
# print(*[(d, s) for d, s in zip(dp, size)])
# 節点0には木の根としての値を求めた。
# 0以外の節点には部分木の根としての値を求めた。
# 木の根としての値を求めた節点を親としてもつ節点は、自身を木の根とした値を求めることができる
# 全方位木DPを行うBFS
queue = deque()
queue.append((0, -1))
while len(queue) > 0:
v, p = queue.popleft()
for u, _ in g.E[v]:
if u == p:
continue
d = div(dp[v], cmb(N-1, size[u]+1))
d = div(d, dp[u])
dp[u] *= cmb(N-1, size[u])
dp[u] %= MOD
dp[u] *= d
dp[u] %= MOD
queue.append((u, v))
for v in dp:
print(v)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N - 1) # type: "List[int]"
b = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, a, b)
if __name__ == '__main__':
main()
| p02728 |
#!/usr/bin/env python3
import sys
from collections import defaultdict
from functools import lru_cache
from collections import deque
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 1000000007 # type: int
class Graph(object):
def __init__(self, N):
self.N = N
self.E = defaultdict(list)
def add_edge(self, src, dest, w=1):
self.E[src].append((dest, w))
self.E[dest].append((src, w))
@lru_cache(maxsize=None)
def div(a, b):
return (a * pow(b, MOD-2, MOD)) % MOD
class Combination(object):
def __init__(self, N, mod=MOD):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
@lru_cache(maxsize=None)
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
b = (self.finv[k]*self.finv[n-k] % self.MOD)
return (self.fac[n] * b) % self.MOD
def solve(N: int, a: "List[int]", b: "List[int]"):
# print(div(3, 2))
# 全方位木DPをやるぞ！
# 1. 木DPによって頂点ごとにhogeを求める
# 2. 木DPで求めたhogeを使って、上手く求める
# グラフの構築
g = Graph(N)
for aa, bb in zip(a, b):
g.add_edge(aa-1, bb-1)
# 組み合わせの初期化
cmb = Combination(N)
dp = [1]*N # 節点vを根とした部分木の塗り方dp[v]
size = [0]*N # 節点vを根とした部分木のサイズsize[v]+1
# 木DPを行うDFS
queue = [(0, -1)]
seen = [False]*N
while queue:
v, p = queue[-1]
flag = True
if seen[v] is False:
for u, _ in g.E[v]:
if u == p:
continue
if seen[u] is False:
queue.append((u, v))
flag = False
if flag is True:
# 処理
for u, _ in g.E[v]:
if u == p:
continue
size[v] += size[u]+1
dp[v] *= cmb(size[v], size[u]+1)
dp[v] %= MOD
dp[v] *= dp[u]
dp[v] %= MOD
# print(v, p)
queue.pop()
seen[v] = True
# print(*queue)
# print(*[(d, s) for d, s in zip(dp, size)])
# 節点0には木の根としての値を求めた。
# 0以外の節点には部分木の根としての値を求めた。
# 木の根としての値を求めた節点を親としてもつ節点は、自身を木の根とした値を求めることができる
# 全方位木DPを行うBFS
queue = deque()
queue.append((0, -1))
while len(queue) > 0:
v, p = queue.popleft()
for u, _ in g.E[v]:
if u == p:
continue
d = div(dp[v], cmb(N-1, size[u]+1))
d = div(d, dp[u])
dp[u] *= cmb(N-1, size[u])
dp[u] %= MOD
dp[u] *= d
dp[u] %= MOD
queue.append((u, v))
for v in dp:
print(v)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N - 1) # type: "List[int]"
b = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, a, b)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from collections import defaultdict
from functools import lru_cache
from collections import deque
MOD = 1000000007 # type: int
class Graph(object):
def __init__(self, N):
self.N = N
self.E = defaultdict(list)
def add_edge(self, src, dest, w=1):
self.E[src].append((dest, w))
self.E[dest].append((src, w))
@lru_cache(maxsize=None)
def div(a, b):
return (a * pow(b, MOD-2, MOD)) % MOD
class Combination(object):
def __init__(self, N, mod=MOD):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
b = (self.finv[k]*self.finv[n-k] % self.MOD)
return (self.fac[n] * b) % self.MOD
def solve(N: int, a: "List[int]", b: "List[int]"):
# グラフの構築
g = Graph(N)
for aa, bb in zip(a, b):
g.add_edge(aa-1, bb-1)
# 組み合わせの初期化
cmb = Combination(N)
# BFSの入り順を構成する
curr = -1
downward = [0]
parent = [-1]*N
while len(downward) < N:
curr += 1
v = downward[curr]
for u, _ in g.E[v]:
if u == parent[v]:
continue
parent[u] = v
downward.append(u)
# print(downward)
# 節点vを根とした部分木の塗り方dp[v]
dp = [1]*N
# 節点vを根とした部分木のサイズsize[v]+1
size = [0]*N
# 葉から根へ向かう探索
for v in reversed(downward):
for u, _ in g.E[v]:
if u == parent[v]:
continue
size[v] += size[u]+1
dp[v] *= cmb(size[v], size[u]+1)
dp[v] %= MOD
dp[v] *= dp[u]
dp[v] %= MOD
# 全方位木DP
# 根から葉へ向かう探索
for v in downward:
for u, _ in g.E[v]:
if u == parent[v]:
continue
d = div(dp[v], cmb(N-1, size[u]+1))
d = div(d, dp[u])
dp[u] *= cmb(N-1, size[u])
dp[u] %= MOD
dp[u] *= d
dp[u] %= MOD
for v in dp:
print(v)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N - 1) # type: "List[int]"
b = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, a, b)
if __name__ == '__main__':
main()
| p02728 |
#!/usr/bin/env python3
import sys
from collections import defaultdict
from functools import lru_cache
MOD = 1000000007 # type: int
@lru_cache(maxsize=None)
def div(a, b):
return (a * pow(b, MOD-2, MOD)) % MOD
class Combination(object):
def __init__(self, N, mod=MOD):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
b = (self.finv[k]*self.finv[n-k] % self.MOD)
return (self.fac[n] * b) % self.MOD
def solve(N: int, a: "List[int]", b: "List[int]"):
# グラフの構築
E = [[] for _ in range(N)]
for aa, bb in zip(a, b):
E[aa-1].append(bb-1)
E[bb-1].append(aa-1)
# 組み合わせの初期化
cmb = Combination(N)
# BFSの入り順を構成する
curr = -1
downward = [0]
parent = [-1]*N
while len(downward) < N:
curr += 1
v = downward[curr]
for u in E[v]:
if u == parent[v]:
continue
parent[u] = v
downward.append(u)
# print(downward)
# 節点vを根とした部分木の塗り方dp[v]
dp = [1]*N
# 節点vを根とした部分木のサイズsize[v]+1
size = [0]*N
# 木DP
# 葉から根へ向かう探索
for v in reversed(downward):
for u in E[v]:
if u == parent[v]:
continue
size[v] += size[u]+1
dp[v] *= cmb.finv[size[u]+1]
dp[v] %= MOD
dp[v] *= dp[u]
dp[v] %= MOD
dp[v] *= cmb.fac[size[v]]
dp[v] %= MOD
# 全方位木DP
# 根から葉へ向かう探索
for v in downward:
for u in E[v]:
if u == parent[v]:
continue
dp[u] = dp[v]
dp[u] *= (size[u]+1)*cmb.inv[N-(size[u]+1)]
dp[u] %= MOD
for v in dp:
print(v)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N - 1) # type: "List[int]"
b = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, a, b)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from collections import defaultdict
MOD = 1000000007 # type: int
class Combination(object):
def __init__(self, N, mod=MOD):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
b = (self.finv[k]*self.finv[n-k] % self.MOD)
return (self.fac[n] * b) % self.MOD
def solve(N: int, a: "List[int]", b: "List[int]"):
# グラフの構築
E = [[] for _ in range(N)]
for aa, bb in zip(a, b):
E[aa-1].append(bb-1)
E[bb-1].append(aa-1)
# 組み合わせの初期化
cmb = Combination(N)
# BFSの入り順を構成する
front, back = -1, 1
downward = [0]*N
parent = [-1]*N
for _ in range(N-1):
front += 1
v = downward[front]
for u in E[v]:
if u == parent[v]:
continue
parent[u] = v
downward[back] = u
back += 1
# print(downward)
# 節点vを根とした部分木の塗り方dp[v]
dp = [1]*N
# 節点vを根とした部分木のサイズsize[v]+1
size = [0]*N
# 木DP
# 葉から根へ向かう探索
for v in reversed(downward):
for u in E[v]:
if u == parent[v]:
continue
size[v] += size[u]+1
dp[v] *= cmb.finv[size[u]+1]
dp[v] %= MOD
dp[v] *= dp[u]
dp[v] %= MOD
dp[v] *= cmb.fac[size[v]]
dp[v] %= MOD
# 全方位木DP
# 根から葉へ向かう探索
for v in downward:
for u in E[v]:
if u == parent[v]:
continue
dp[u] = dp[v]
dp[u] *= (size[u]+1)*cmb.inv[N-(size[u]+1)]
dp[u] %= MOD
for v in dp:
print(v)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N - 1) # type: "List[int]"
b = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, a, b)
if __name__ == '__main__':
main()
| p02728 |
import sys
def solve():
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 7)
mod = 10 ** 9 + 7
def comb(n, r):
if r > n: return 0
return fac[n] * inv[r] * inv[n - r] % mod
def dfs(v, Pa=-1):
for u in to[v]:
if u == Pa: continue
dfs(u, v)
size[v] += size[u]
dp[v] *= dp[u] % mod
dp[v] *= comb(size[v], size[u]) % mod
size[v] += 1
def bfs(v, Pa=-1, P_val=1, P_sz=0):
ans[v] = P_val * dp[v] * comb(n - 1, P_sz) % mod
for u in to[v]:
if u == Pa: continue
val = ans[v] * INV(dp[u] * comb(n - 1, size[u])) % mod
bfs(u, v, val, n - size[u])
n = int(input())
to = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = map(lambda x: int(x) - 1, input().split())
to[a].append(b)
to[b].append(a)
fac = [1] * (n + 2)
inv = [1] * (n + 2)
for i in range(2, n + 1):
fac[i] = fac[i - 1] * i % mod
INV = lambda x: pow(x, mod - 2, mod)
inv[n] = INV(fac[n])
for i in range(n - 1, 1, -1):
inv[i] = inv[i + 1] * (i + 1) % mod
dp = [1] * n
size = [0] * n
ans = [0] * n
dfs(0)
bfs(0)
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| import sys
def solve():
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 7)
mod = 10 ** 9 + 7
def comb(n, r):
if r > n: return 0
return fac[n] * inv[r] * inv[n - r] % mod
def dfs(v, Pa=-1):
for u in to[v]:
if u == Pa: continue
dfs(u, v)
size[v] += size[u]
dp[v] *= dp[u] % mod
dp[v] *= inv[size[u]] % mod
dp[v] *= fac[size[v]] % mod
size[v] += 1
def bfs(v, Pa=-1, P_val=1, P_sz=0):
ans[v] = P_val * dp[v] * comb(n - 1, P_sz) % mod
for u in to[v]:
if u == Pa: continue
val = ans[v] * INV(dp[u] * comb(n - 1, size[u])) % mod
bfs(u, v, val, n - size[u])
n = int(input())
to = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = map(lambda x: int(x) - 1, input().split())
to[a].append(b)
to[b].append(a)
fac = [1] * (n + 2)
inv = [1] * (n + 2)
for i in range(2, n + 1):
fac[i] = fac[i - 1] * i % mod
INV = lambda x: pow(x, mod - 2, mod)
inv[n] = INV(fac[n])
for i in range(n - 1, 1, -1):
inv[i] = inv[i + 1] * (i + 1) % mod
dp = [1] * n
size = [0] * n
ans = [0] * n
dfs(0)
bfs(0)
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| p02728 |
# _*_ coding:utf-8 _*_
# Atcoder_Beginners_Contest071-B
# TODO https://atcoder.jp/contests/abc071/tasks/abc071_b
def firstCharNotFound(givenString):
# initialize for char
checkList = [False for _ in range(0,26,+1)]
stringLength = list(range(0,len(givenString),+1))
for pos in stringLength:
charIntVersion = ord(givenString[pos])
checkList[charIntVersion-97]=True
charRange = list(range(0,26,+1))
firstPosition = -1
for pos in charRange:
if checkList[pos]==False:
firstPosition = pos
break
if firstPosition == -1:
return "None"
else :
return chr(firstPosition+97)
if __name__ == '__main__':
S = input().strip()
solution=firstCharNotFound(S)
print(("{}".format(solution))) | # Problem:
# Python Try
import sys
# from collections import defaultdict
# import heapq,copy
# from collections import deque
def II(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def initSet():
result = set()
for j in range(ord('a'),ord('z')+1):
result.add(chr(j))
return result
def solver(inputString,allCharSet):
result = ''
inputSet = set(inputString)
# print("INPUT={}".format(inputSet))
# print("ALL={}".format(allCharSet))
diffset = allCharSet - inputSet
# print("DIFF={}".format(diffset))
difflist = list(diffset)
difflist.sort()
# print("{}".format(difflist))
if len(difflist) == 0:
result = "None"
else:
result = difflist[0]
return result
if __name__ == "__main__":
S = sys.stdin.readline().split('\n')
allset = initSet()
print(("{}".format(solver(S[0],allset))))
| p03624 |
diff = set(chr(ord("a") + i) for i in range(26)) - set(input().rstrip("\n"))
print(((list(sorted(diff))+["None"])[0])) | [print(un_appearence[0] if un_appearence else "None") for un_appearence in [[chr(i) for i in range(ord('a'), ord('z') + 1) if chr(i) not in string] for string in [input()]]]
| p03624 |
S = input().strip()
C = {chr(i):0 for i in range(97,123)}
for i in range(len(S)):
C[S[i]] += 1
x = "None"
for i in range(97,123):
if C[chr(i)]==0:
x = chr(i)
break
print(x) | S = input().strip()
C = {chr(i):0 for i in range(97,123)}
for i in range(len(S)):
C[S[i]] += 1
flag = 0
a = 0
for i in range(97,123):
if C[chr(i)]==0:
a = chr(i)
flag = 1
break
if flag==1:
print(a)
else:
print("None") | p03624 |
a = list(map(int, input().split()))
print(("Yes" if sum(a) == max(a) * 2 else "No"))
| a, b, c = sorted(map(int, input().split()))
print((("No", "Yes")[a + b == c])) | p03943 |
s = list(map(int, input().split()))
s.sort()
if s[0] + s[1] == s[2]:
print('Yes')
else:
print('No') | s = list(map(int, input().split()))
s.sort()
print(('Yes' if s[0] + s[1] == s[2] else'No')) | p03943 |
a = list(map(int, input().split()))
total = sum(a)
for i in a:
if total - i in a:
print("Yes")
break
else:
print("No")
| a = list(map(int, input().split()))
if max(a) == sum(a) - max(a):
print("Yes")
else:
print("No")
| p03943 |
# 書き方を少し変えたver
packs = [int(candies) for candies in input().split()]
N = int(len(packs))
if sum(packs) % 2 == 0:
half = int(sum(packs) / 2)
else:
print('No')
exit()
dp = [[False] * (half + 1)] * (N + 1)
dp[0][0] = True
for i in range(N):
for j in range(half+1):
if dp[i][j]:
dp[i+1][j] = dp[i][j]
elif j >= packs[i]:
dp[i+1][j] = dp[i][j - packs[i]]
if dp[N][half]:
ans = "Yes"
else:
ans = "No"
print(ans) | packs = [int(candies) for candies in input().split()]
N = int(len(packs))
X = 2
if sum(packs) % X == 0:
A = int(sum(packs) / X)
else:
print('No')
exit()
dp = [[False] * (A + 1)] * (N + 1)
dp[0][0] = True
for i in range(N):
for j in range(A+1):
if dp[i][j]:
dp[i+1][j] = dp[i][j]
elif j >= packs[i]:
dp[i+1][j] = dp[i][j - packs[i]]
if dp[N][A]:
ans = "Yes"
else:
ans = "No"
print(ans) | p03943 |
a,b,c = (int(i) for i in input().split())
print(("Yes" if a+b == c or b+c == a or c+a == b else "No")) | def main():
a, b, c = (int(i) for i in input().split())
if a+b == c or b+c == a or b == c+a:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| p03943 |
a, b, c = list(map(int, input().split()))
candy_nums = sorted([a, b, c])
print(('Yes' if candy_nums[0] + candy_nums[1] == candy_nums[2] else 'No')) | a, b, c = list(map(int, input().split()))
L = sorted([a, b, c])
print(('Yes' if L[2] == L[0] + L[1] else 'No')) | p03943 |
a,b,c = list(map(int, input().split()))
x = a+b
y = b+c
z = c+a
if x ==c or y ==a or z ==b:
print('Yes')
else:
print('No')
| candy= list(map(int, input().split()))
candy.sort()
print(('Yes' if candy[0]+candy[1]==candy[2] else 'No')) | p03943 |
a,b,c = list(map(int, input().split()))
if a + b == c or a + c == b or b + c == a:
print('Yes')
else:
print('No') | a,b,c=list(map(int,input().split()))
print(('Yes' if a+b==c or b+c==a or a+c==b else 'No')) | p03943 |
a,b,c = list(map(int,input().split()))
if a+b == c or a+c == b or b+c == a:
print("Yes")
else:
print("No") | a,b,c = list(map(int,input().split()))
ans = 0
if a+b == c:
ans += 1
elif a+c == b:
ans += 1
elif b+c == a:
ans += 1
if ans >0:
print("Yes")
else:
print("No") | p03943 |
a, b, c = sorted(map(int, input().split()))
print(('Yes' if a + b == c else 'No')) | a, b, c = list(map(int, input().split()))
print(('Yes' if a == (b + c) or b == (a + c) or c == (a+b) else 'No')) | p03943 |
l=sorted(list(map(int,input().split())))
print(("Yes" if l[0]+l[1]==l[2] else "No")) | a,b,c=sorted(map(int,input().split()))
print(("Yes" if a+b==c else "No")) | p03943 |
l=sorted(map(int,input().split()))
print(("Yes" if sum(l[:2])==l[2] else "No")) | a, b, c = sorted(map(int, input().split()))
print(("Yes" if a+b == c else "No")) | p03943 |
a, b, c = list(map(int,input().split()))
if a+b==c or b+c==a or c+a==b:
print("Yes")
else:
print("No")
| a, b, c = list(map(int,input().split()))
if a==b+c or b==a+c or c==b+a:
print("Yes")
else:
print("No")
| p03943 |
#!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, fractions
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a,b,c=list(map(int,input().split()))
for i in itertools.permutations([a,b,c],3):
if i[0]==sum(i[1:]) or sum(i[:2])==i[2]:
print("Yes")
exit()
print("No") | #!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, fractions
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a,b,c=list(map(int,input().split()))
# print(0)
for i in itertools.permutations([a,b,c],3):
if i[0]==sum(i[1:]) or sum(i[:2])==i[2]:
print("Yes")
exit()
print("No") | p03943 |
#!/usr/bin/env python3
import sys, math, itertools, heapq, collections
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a, b, c = list(map(int, input().split()))
for i in itertools.permutations([a, b, c], 3):
if i[0] == sum(i[1:]) or sum(i[:2]) == i[2]:
print("Yes")
exit()
print("No")
| #!/usr/bin/env python3
import sys, math, itertools, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a, b, c = list(map(int, input().split()))
for i in itertools.permutations([a, b, c], 3):
if i[0] == sum(i[1:]) or sum(i[:2]) == i[2]:
print("Yes")
exit()
print("No")
| p03943 |
#!/usr/bin/env python3
import sys, math, itertools
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a, b, c = list(map(int, input().split()))
for i in itertools.permutations([a, b, c], 3):
if i[0] == sum(i[1:]) or sum(i[:2]) == i[2]:
print("Yes")
exit()
print("No")
| #!/usr/bin/env python3
import sys, itertools
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a, b, c = list(map(int, input().split()))
for i in itertools.permutations([a, b, c], 3):
if i[0] == sum(i[1:]) or sum(i[:2]) == i[2]:
print("Yes")
exit()
print("No")
| p03943 |
# import time
# starttime=time.clock()
A,B,C =input().split()
a=int(A)
b=int(B)
c=int(C)
# print(a+c)
if a>b:
temp = a
a = b
b = temp
if b>c:
temp = b
b = c
c = temp
if (a+b)==c:
print("Yes")
# endtime = time.clock()
# print(endtime-starttime)
else:
print("No")
# endtime = time.clock()
# print(endtime-starttime)
#
| a,b,c = list(map(int,input().split()))
if a>b:
temp = a
a = b
b = temp
if b>c:
temp = b
b = c
c = temp
if (a+b)==c:
print("Yes")
else:
print("No")
| p03943 |
A = [int(i) for i in input().split()]
print(('Yes' if sum(A) == max(A) * 2 else 'No')) | a, b, c = list(map(int, input().split()))
if a + b == c or a + c == b or b + c == a:
print('Yes')
else:
print('No') | p03943 |
while 1:
n=int(input())
if n==0:break
d={}
for _ in[0]*n:
k,v=input().strip().split()
d[k]=v
for _ in[0]*int(input()):
e=input().strip()
print(d[e]if e in d else e,end='')
print()
| while 1:
n=int(eval(input()))
if n==0:break
d={}
for _ in[0]*n:
k,v=input().strip().split()
d[k]=v
a=''
for _ in[0]*int(eval(input())):
e=input().strip()
a+=d[e]if e in d else e
print(a)
| p00424 |
import sys
s=sys.stdin.readline
for n in iter(s,'0\n'):
d={}
for _ in[0]*int(n):
k,v=s()[:-1].split()
d[k]=v
print((''.join(d.get(*[s().strip()]*2)for _ in[0]*int(s()))))
| import sys
s=sys.stdin.readline
for n in iter(s,'0\n'):
d={}
for _ in[0]*int(n):
k,v=s()[:-1].split()
d[k]=v
print((''.join(d.get(*[s()[0]]*2)for _ in[0]*int(s()))))
| p00424 |
while True:
n = int(eval(input()))
if n == 0:break
c = {}
for _ in range(n):
a,b = input().split()
c[a] = b
m = int(eval(input()))
ans = ''
for _ in range(m):
a = input()[0]
ans+=c[a] if a in c else a
print(ans) | import sys
cin = sys.stdin
while True:
n = int(cin.readline())
if n == 0:break
c = {}
for _ in range(n):
a,b = cin.readline().strip().split()
c[a] = b
m = int(cin.readline())
ans = ''
for _ in range(m):
a = cin.readline().strip()
ans+=c[a] if a in c else a
print(ans) | p00424 |
import sys
while True:
n = int(sys.stdin.readline().rstrip())
if n == 0:
break;
x = {}
for i in range(n):
k,v = sys.stdin.readline().rstrip().split()
x[k] = v
n = int(sys.stdin.readline().rstrip())
y = []
for i in range(n):
a = sys.stdin.readline().rstrip()
if a in list(x.keys()):
y.append(x[a])
else:
y.append(a)
print((''.join(y))) | import sys
while True:
n = int(sys.stdin.readline().rstrip())
if n == 0:
break;
x = {}
for i in range(n):
k,v = sys.stdin.readline().rstrip().split()
x[k] = v
n = int(sys.stdin.readline().rstrip())
y = []
for i in range(n):
a = sys.stdin.readline().rstrip()
if a in x:
y.append(x[a])
else:
y.append(a)
print((''.join(y))) | p00424 |
while True:
x = int(eval(input()))
if x == 0:
break
dcl = {}
for i in range(x):
inp = list(map(str, input().split()))
dcl[inp[0]] = inp[1]
ans = ""
x = int(eval(input()))
for i in range(x):
y = str(input()[0])
if y in dcl:
ans += dcl[y]
else:
ans += y
print(ans) | while True:
n = int(eval(input()))
if n == 0:
break
d = {}
for _ in range(n):
a, b = input().split()
d[a] = b
m = int(eval(input()))
ans = ""
for _ in range(m):
a = input().strip()
ans += d.get(a, a)
print(ans) | p00424 |
while True:
n = int(eval(input()))
if n == 0:
break
d = {}
for _ in range(n):
a, b = input().split()
d[a] = b
m = int(eval(input()))
ans = ""
for _ in range(m):
a = input().strip()
try:
ans += d[a]
except:
ans += a
print(ans) | while True:
n = int(eval(input()))
if n == 0:
break
d = {}
for _ in range(n):
a, b = input().split()
d[a] = b
m = int(eval(input()))
ans = ""
for _ in range(m):
a = input().strip()
ans += d[a] if a in d else a
print(ans) | p00424 |
while True:
n = int(eval(input()))
if n == 0:
break
d = {}
for _ in range(n):
a, b = input().split()
d[a] = b
m = int(eval(input()))
ans = ""
for _ in range(m):
a = input().strip()
if a in d:
ans += d[a]
else:
ans += a
print(ans) | while True:
n = int(eval(input()))
if n == 0:
break
d = {}
for _ in range(n):
a, b = input().split()
d[a] = b
m = int(eval(input()))
ans = []
for _ in range(m):
a = input().strip()
if a in d:
ans.append(d[a])
else:
ans.append(a)
print(("".join(ans))) | p00424 |
while True:
dict = {}
n = eval(input())
if n == 0:break
for x in range(n):
a, b = input().split()
dict[a.strip()] = b.strip()
res = ""
for x in range(eval(input())):
a = input().strip()
if a in dict:
res += dict[a]
else:
res += a
print(res) | while True:
dict = {}
n = eval(input())
if n == 0:break
for x in range(n):
a, b = input().split()
dict[a] = b
res = ""
for x in range(eval(input())):
a = input()[0]
if a in dict:
res += dict[a]
else:
res += a
print(res) | p00424 |
"""
Writer: SPD_9X2
https://atcoder.jp/contests/diverta2019-2/tasks/diverta2019_2_e
Mの時、 a1<=a2<=a3…aN
を満たす通り数 X[M] が分かれば解ける(全ての順N!は等しいため)
当然、次のMにはa1から順に更新していくことになる(M+?にね)
Dの時
X[M] = (X[M-1] + X[M-2] + … + X[M-D]) * N
が成立かな
X[0] = 1
N=2
X[0]=1
X[1]=2
X[2]=6
N=3
X[0]=1
X[1]=9
X[M]の更新式
→これが間違ってそう
X[M] = (X[M-1] + X[M-2] + … + X[M-D]) * (1!+2!+3!+…N!)
→エスパーだけどなんか正しそう
X[H-1]を求めてN!を掛ければそれが答え
→サンプル合った！！
"""
import math
N,H,D = list(map(int,input().split()))
mod = 10**9+7
mul = 0
fac = 1
for i in range(1,N+1):
fac *= i
fac %= mod
mul += fac
mul %= mod
X = [1]
nsum = 1
for i in range(H-1):
#print (i,nsum,mul)
X.append(nsum*mul%mod)
nsum += X[-1]
if i >= D-1:
nsum -= X[i-D+1]
#print (X)
print((nsum * math.factorial(N) % mod))
|
"""
Writer: SPD_9X2
https://atcoder.jp/contests/diverta2019-2/tasks/diverta2019_2_e
Mの時、 a1<=a2<=a3…aN
を満たす通り数 X[M] が分かれば解ける(全ての順N!は等しいため)
当然、次のMにはa1から順に更新していくことになる(M+?にね)
Dの時
X[M] = (X[M-1] + X[M-2] + … + X[M-D]) * N
が成立かな
X[0] = 1
N=2
X[0]=1
X[1]=2
X[2]=6
N=3
X[0]=1
X[1]=9
X[M]の更新式
→これが間違ってそう
X[M] = (X[M-1] + X[M-2] + … + X[M-D]) * (1!+2!+3!+…N!)
→エスパーだけどなんか正しそう
X[H-1]を求めてN!を掛ければそれが答え
→サンプル合った！！
"""
import math
N,H,D = list(map(int,input().split()))
mod = 10**9+7
mul = 0
fac = 1
for i in range(1,N+1):
fac *= i
fac %= mod
mul += fac
mul %= mod
X = [1]
nsum = 1
for i in range(H-1):
#print (i,nsum,mul)
X.append(nsum*mul%mod)
nsum += X[-1]
nsum %= mod
if i >= D-1:
nsum -= X[i-D+1]
#print (X)
print((nsum * fac % mod))
| p03009 |
while 1:
N,M = list(map(int,input().split()))
if N == 0: break
T = [[0]*1261 for i in range(N)]
for i in range(eval(input())):
t,n,m,s = list(map(int,input().split()))
for ti in range(t,1261):
T[n-1][ti] = s*m
for i in range(eval(input())):
ts,te,m = list(map(int,input().split()))
print(sum(1 if any(T[n][t] == m for n in range(N)) else 0 for t in range(ts,te)))
| while 1:
N,M = list(map(int,input().split()))
if N == 0: break
T = [[0]*1261 for i in range(N)]
r = eval(input())
tnms = sorted([list(map(int,input().split())) for i in range(r)], key = lambda x:x[1])
for i in range(0,r,2):
t1,n,m,s = tnms[i]
t2,n,m,s = tnms[i+1]
T[n-1][t1:t2] = [m for j in range(t1,t2)]
for i in range(eval(input())):
ts,te,m = list(map(int,input().split()))
print(sum(1 if any(T[n][t] == m for n in range(N)) else 0 for t in range(ts,te)))
| p00729 |
while 1:
N,M = list(map(int,input().split()))
if N == 0: break
T = [[0]*1261 for i in range(N)]
r = eval(input())
tnms = sorted([list(map(int,input().split())) for i in range(r)], key = lambda x:x[1])
for i in range(0,r,2):
t1,n,m,s = tnms[i]
t2,n,m,s = tnms[i+1]
T[n-1][t1:t2] = [m for j in range(t1,t2)]
for i in range(eval(input())):
ts,te,m = list(map(int,input().split()))
print(sum(1 if any(T[n][t] == m for n in range(N)) else 0 for t in range(ts,te)))
| while 1:
N,M = list(map(int,input().split()))
if N == 0: break
T = [[0]*1261 for i in range(M)]
r = eval(input())
tnms = sorted([list(map(int,input().split())) for i in range(r)], key = lambda x:x[1])
for i in range(0,r,2):
t1,n,m,s = tnms[i]
t2,n,m,s = tnms[i+1]
T[m-1][t1:t2] = [1 for j in range(t1,t2)]
for i in range(eval(input())):
ts,te,m = list(map(int,input().split()))
print(sum(T[m-1][ts:te])) | p00729 |
while 1:
N,M = list(map(int,input().split()))
if N == 0: break
T = [[0]*1261 for i in range(M)]
r = eval(input())
tnms = sorted([list(map(int,input().split())) for i in range(r)], key = lambda x:x[1])
for i in range(0,r,2):
t1,n,m,s = tnms[i]
t2,n,m,s = tnms[i+1]
T[m-1][t1:t2] = [1 for j in range(t1,t2)]
for m in range(M):
c = 0
for i in range(1260):
if T[m-1][i]:
c += 1
T[m-1][i] = c - T[m-1][i+1]
for i in range(eval(input())):
ts,te,m = list(map(int,input().split()))
print(T[m-1][te] - T[m-1][ts]) | while 1:
N,M = list(map(int,input().split()))
if N == 0: break
T = [[0]*1261 for i in range(M)]
r = eval(input())
tnms = sorted([list(map(int,input().split())) for i in range(r)], key = lambda x:x[1])
for i in range(0,r,2):
t1,n,m,s = tnms[i]
t2,n,m,s = tnms[i+1]
T[m-1][t1:t2] = [1 for j in range(t1,t2)]
for m in range(M):
c = 0
for i in range(540,1260):
if T[m-1][i]:
c += 1
T[m-1][i] = c - T[m-1][i+1]
for i in range(eval(input())):
ts,te,m = list(map(int,input().split()))
print(T[m-1][te] - T[m-1][ts]) | p00729 |
l = (1260-540+1)
while True:
N,M = list(map(int,input().split(" ")))
if N == 0 and M == 0:
break
T = [[0]*l for _ in range(M)]
r = int(eval(input()))
for i in range(r):
t,n,m,s = list(map(int,input().split(" ")))
if s == 1:
T[m-1][t-540] += 1
else:
T[m-1][t-540] -= 1
T_range = [[] for _ in range(M)]
for i in range(M):
flg = True if T[i][0] >= 1 else False
lb = 0
for j in range(l-1):
T[i][j+1] += T[i][j]
if flg and T[i][j+1] == 0:
T_range[i].append((lb+ 540,j+1+540))
flg = False
elif (not flg) and T[i][j+1] >= 1:
flg = True
lb = (j+1)
if flg:
T_range[i].append((lb+540,l+540))
q = int(eval(input()))
for i in range(q):
t1,t2,m = list(map(int,input().split(" ")))
ans = 0
for a,b in T_range[m-1]:
if not (b < t1 or t2 < a):
ans += (min(t2,b) - max(t1,a))
print(ans)
| l = (1260-540)+1
while True:
N,M = list(map(int,input().split(" ")))
if N == 0 and M == 0:
break
T = [[0]*l for _ in range(M)]
r = int(eval(input()))
for i in range(r):
t,n,m,s = list(map(int,input().split(" ")))
if s == 1:
T[m-1][t-540] += 1
else:
T[m-1][t-540] -= 1
q = int(eval(input()))
used = {}
for i in range(q):
t1,t2,m = list(map(int,input().split(" ")))
if not (m-1) in used:
T_range = []
flg = True if T[m-1][0] >= 1 else False
lb = 0
for j in range(l-1):
T[m-1][j+1] += T[m-1][j]
if flg and T[m-1][j+1] == 0:
T_range.append((lb+540,j+1+540))
flg = False
elif (not flg) and T[m-1][j+1] >= 1:
flg = True
lb = (j+1)
if flg:
T_range.append((lb+540,1261))
used[m-1] = T_range
ans = 0
for a,b in used[m-1]:
if not (b < t1 or t2 < a):
ans += (min(t2,b) - max(t1,a))
print(ans)
| p00729 |
N,T = list(map(int,input().split()))
order = list(map(int,input().split()))
ov = 0
for i in range(N-1):
if (order[i+1]-order[i])<T:
ov += T-(order[i+1]-order[i])
print((N*T-ov)) | N,T = list(map(int,input().split()))
last, time = 0,-T
for temp in map(int,input().split()):
if temp - last < T:
time += T - (temp - last)
last = temp
print((N*T-time)) | p03731 |
n, t = list(map(int, input().split()))
a = list(map(int, input().split()))
time = 0
for i in range(n-1):
if a[i + 1] - a[i] < t:
time += a[i + 1] - a[i]
elif a[i + 1] - a[i] >= t:
time += t
print((time + t))
| n, t = list(map(int, input().split()))
a = list(map(int, input().split()))
time = 0
for i in range(n - 1):
time += min(t, a[i + 1] - a[i])
print((time + t)) | p03731 |
def solve():
[N, T] = [int(x) for x in input().split()]
ts = [int(x) for x in input().split()]
import collections
stack = collections.deque()
for t in ts:
if not stack:
stack.append((t, t+T))
continue
last = stack.pop()
if last[1] >= t:
stack.append((last[0], t+T))
else:
stack.append(last)
stack.append((t, t+T))
ans = 0
for t1, t2 in stack:
ans += (t2 - t1)
return ans
def main():
print((solve()))
if __name__ == '__main__':
main() | def solve():
[N, T] = [int(x) for x in input().split()]
ts = [int(x) for x in input().split()]
return sum([
min(T, t2-t1) for t2, t1 in zip(ts[1:], ts[:-1])
]) + T
def main():
print((solve()))
if __name__ == '__main__':
main() | p03731 |
n,t = list(map(int, input().split()))
lst = list(map(int, input().split()))
dif = [None for i in range(n-1)]
for i in range(n-1):
dif[i] = lst[i+1]-lst[i]
ans = 0
for i in range(n-1):
ans += min(t,dif[i])
ans += t
print(ans)
| n,t = list(map(int, input().split()))
lst = list(map(int, input().split()))
dif = [None for i in range(n-1)]
ans = 0
for i in range(n-1):
ans += min(t,lst[i+1]-lst[i])
ans += t
print(ans)
| p03731 |
n,t = (int(i) for i in input().split())
ni = [int(i) for i in input().split()]
total = 0
for i in range(1,len(ni)) :
delta = ni[i] - ni[i-1]
if delta < t :
total += delta
else :
total += t
print((total+t)) | def main():
N, T = list(map(int, input().split()))
t = list(map(int, input().split()))
s, e = 0, 0
ans = 0
for i in range(N):
if t[i] <= e:
e = t[i] + T
else:
ans += e - s
s = t[i]
e = t[i] + T
ans += e - s
print(ans)
main()
| p03731 |
N, T = list(map(int, input().split()))
t = list(map(int, input().split()))
s, e = 0, 0
ans = 0
for i in range(N):
if t[i] <= e:
e = t[i] + T
else:
ans += e - s
s = t[i]
e = t[i] + T
ans += e - s
print(ans)
| def main() :
n,t = (int(i) for i in input().split())
ni = [int(i) for i in input().split()]
total = 0
for i in range(1,len(ni)) :
delta = ni[i] - ni[i-1]
if delta < t :
total += delta
else :
total += t
print((total+t))
main() | p03731 |
# -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem C
if __name__ == '__main__':
n, intervel = list(map(int, input().split()))
ts = list(map(int, input().split()))
ts += [ts[-1] + intervel]
total_t = 0
previous_t = ts[0]
for i in range(1, n + 1):
current_t = ts[i]
if (previous_t + intervel) > current_t:
total_t += max(0, current_t - previous_t)
else:
total_t += intervel
previous_t = current_t
print(total_t)
| # -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem C
if __name__ == '__main__':
n, intervel = list(map(int, input().split()))
ts = list(map(int, input().split()))
ts += [ts[-1] + intervel]
total_t = 0
previous_t = ts[0]
# See:
# https://atcoder.jp/img/arc073/editorial.pdf
for i in range(1, n + 1):
current_t = ts[i]
total_t += min(current_t - previous_t, intervel)
previous_t = current_t
print(total_t)
| p03731 |
n,t = list(map(int,input().split()))
a = [int(i) for i in input().split()]
ans = t
for i in range(1,n):
if a[i]-a[i-1] < t:
ans += a[i]-a[i-1]
else:
ans += t
print(ans) | n,t = list(map(int,input().split()))
time = list(map(int,input().split()))
ans = 0
for i in range(n-1):
ans += min(time[i+1]-time[i],t)
print((ans+t)) | p03731 |
n,t=list(map(int,input().split()))
a=list(map(int,input().split()))
a.append(10**10)
cnt=0
for i in range(n):
fir=a[i]
if a[i]+t>a[i+1]:
las=a[i+1]
else:
las=a[i]+t
cnt+=las-fir
print(cnt) | n,t=list(map(int,input().split()))
a=list(map(int,input().split()))
a.append(10**10)
cnt=0
for i in range(n):
if a[i]+t>a[i+1]:
cnt+=a[i+1]-a[i]
else:
cnt+=t
print(cnt) | p03731 |
N, T = [int(i) for i in input().split()]
t = [int(t) for t in input().split()]
total = T
for i in range(N-1):
if t[i+1] - t[i] < T:
total += t[i+1] - t[i]
else:
total += T
print(total)
| import sys
n, T, *t = list(map(int, sys.stdin.read().split()))
def main():
start = 0
will_stop = T
running_time = 0
for i in range(1, n):
cur = t[i]
if cur < will_stop:
running_time += cur - start
else:
running_time += T
start = cur
will_stop = cur + T
running_time += T
return running_time
if __name__ == '__main__':
ans = main()
print(ans) | p03731 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def main():
N, T = list(map(int, input().split()))
t = list(map(int, input().split()))
s = set()
for x in t:
s |= set(range(x, x+T))
print((len(s)))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def main():
N, T = list(map(int, input().split()))
t = list(map(int, input().split()))
arr = [[]] * len(t)
for i in range(len(t)):
arr[i] = [t[i], t[i]+T]
ans = arr[0][1]
for i in range(len(t)-1):
_, t1 = arr[i]
f2, t2 = arr[i+1]
if t1 <= f2:
ans += t2 - f2
else:
ans += t2 - t1
print(ans)
if __name__ == '__main__':
main()
| p03731 |
N,T = list(map(int,input().split()))
A = list(map(int,input().split()))
ans = 0
for i in range(1,N):
if A[i] > A[i-1]+T:
ans += T
else:
ans += A[i]-A[i-1]
ans += T
print(ans)
| # atcoder : python3 (3.4.3)
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
mod = 10**9+7
# main
N,T = list(map(int,input().split()))
A = list(map(int,input().split()))
ans = 0
for i in range(1,N):
if A[i] > A[i-1]+T:
ans += T
else:
ans += A[i]-A[i-1]
ans += T
print(ans) | p03731 |
n, t = list(map(int, input().split()))
T = list(map(int, input().split()))
counter = 0
timer = 0
T_position = 0
for i in range(T[-1] + t):
# print(counter, timer, T_position)
if T[T_position] == i:
timer = t
if T_position != len(T) - 1:
T_position += 1
if timer > 0:
counter += 1
timer -= 1
print(counter) | n, t = list(map(int, input().split()))
T = list(map(int, input().split()))
counter = 0
for i in range(len(T) - 1):
if T[i+1] - T[i] < t:
counter += T[i+1] - T[i]
else:
counter += t
counter += t
print(counter) | p03731 |
n, T = list(map(int, input().split()))
t = tuple(map(int, input().split()))
ans = T
for i in range(n-1):
if t[i + 1] - t[i] <= T:
ans += t[i + 1] - t[i]
else:
ans += T
print(ans) | n, T = list(map(int, input().split()))
t = list(map(int, input().split()))
ans = T
for i in range(n-1):
if t[i + 1] - t[i] <= T:
ans += t[i + 1] - t[i]
else:
ans += T
print(ans)
| p03731 |
n,tt=list(map(int,input().split()))
t=list(map(int,input().split()))
x=0
t1=0
for i in range(1,n):
x=x+min(t[i]-t1,tt)
t1=t[i]
print((x+tt)) |
n,t=list(map(int,input().split()))
ti=list(map(int,input().split()))
tsum=0
for i in range(1,n):
tsum=tsum+min(t,ti[i]-ti[i-1])
print((tsum+t))
| p03731 |
N,T = list(map(int, input().split()))
t = list(map(int, input().split()))
x = T
for i in range(1,N):
if t[i]-t[i-1] >= T:
x += T
elif t[i]+T > T:
x += t[i]-t[i-1]
print(x)
| N,T = list(map(int, input().split()))
t = list(map(int, input().split()))
x = T
for i in range(1,N):
if t[i]-t[i-1] >= T:
x += T
else:
x += t[i]-t[i-1]
print(x)
| p03731 |
N, T = list(map(int, input().split()))
TL = [-T] + list(map(int, input().split()))
answer = 0
for i in range(1, N+1):
answer += T
answer -= max(0, TL[i-1] + T - TL[i])
print(answer) | N, T = list(map(int, input().split()))
TL = list(map(int, input().split()))
answer = T
for i in range(N-1):
answer += min(TL[i+1] - TL[i], T)
print(answer) | p03731 |
n,t = list(map(int,input().split()))
a = [int(i) for i in input().split()]
ans = t
for i in range(n-1):
if abs(a[i+1] - a[i]) > t:
ans += t
else:
ans += abs(a[i+1] - a[i])
print(ans) | n,t = list(map(int,input().split()))
a = [int(i) for i in input().split()]
ans = t
for i in range(n-1):
ans += min(abs(a[i+1] - a[i]), t)
print(ans) | p03731 |
N,T=list(map(int,input().split()))
t=list(map(int,input().split()))
a=T
for i in range(N-1):
a+=min(T,t[i+1]-t[i])
print(a) | N,T=list(map(int,input().split()))
t=list(map(int,input().split()))
a=[min(T,t[i+1]-t[i]) for i in range(N-1)]
print((sum(a)+T)) | p03731 |
_,T,*t=list(map(int,open(0).read().split()));print((sum(min(T,j-i)for i,j in zip(t,t[1:]))+T)) | _,T,*t=list(map(int,open(0).read().split()));print((sum(min(T,j-i)for i,j in zip([-T]+t,t)))) | p03731 |
n,T,*t=list(map(int,open(0).read().split()));print((T+sum(min(j-i,T)for i,j in zip(t,t[1:])))) | _,T,b,*t=list(map(int,open(0).read().split()))
a=T
for i in t:a+=min(i-b,T);b=i
print(a) | p03731 |
def main():
N, T = list(map(int, input().split()))
t = list(map(int, input().split()))
c = t[-1] + T + 1
a = [0 for _ in range(c)]
for i in t:
a[i] += 1
a[i+T] -= 1
count = 0
for i in range(c):
if(0 < i):
a[i] += a[i - 1]
if(a[i] != 0): count += 1
if(a[0] != 0): count += 1
print(count)
return 0
if __name__ == '__main__':
main() | n, t = list(map(int, input().split()))
T = list(map(int, input().split()))
ans = t
for t1, t2 in zip(T[:-1], T[1:]):
ans += min(t2 - t1, t)
print(ans) | p03731 |
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**9)
n,t=list(map(int,input().split()))
T=list(map(int,input().split()))
ans=t
for i in range(1,n):
ans+=min(T[i]-T[i-1],t)
print(ans) | n,t=list(map(int,input().split()))
T=list(map(int,input().split()))
ans=t
for i in range(1,n):
ans+=min(T[i]-T[i-1],t)
print(ans) | p03731 |
from sys import stdin
def main():
lines = stdin.readlines()
T = int(lines[0].split()[1])
tn = [int(ti) for ti in lines[1].split()]
ans = 0
for t1, t2 in zip(tn[0:], tn[1:]):
ans += min(T, t2 - t1)
ans += T
print(ans)
return
main()
| from sys import stdin
def main():
lines = stdin.readlines()
T = int(lines[0].split()[1])
tn = [int(ti) for ti in lines[1].split()]
print((tn[-1] + T - sum(t2 - t1 - T for t1, t2 in zip(tn[0:], tn[1:]) if t2 - t1 > T)))
return
main()
| p03731 |
n, T = list(map(int, input().split()))
t = list(map(int, input().split()))
ans = 0
for i in range(n-1):
x = t[i+1]-t[i]
if x < T:
ans += x
else:
ans += T
print((ans+T)) | n, T = list(map(int, input().split()))
t = list(map(int, input().split()))
ans = 0
for i in range(n-1):
x = t[i+1]-t[i]
ans += min(x, T)
print((ans+T)) | p03731 |
#N,Tの取得
l = list(map(int, input().split()))
N = l[0]
T = l[1]
#秒のリストを取得
tl = list(map(int, input().split()))
sw = 0 #スイッチオンオフの管理
bt = 0 #直前のスイッチを押した時間
gt = 0 #秒数総和
for i, t in enumerate(tl):
if sw == 1 and t - bt > T:
sw = 0 #全快スイッチを押してからT秒経過していたら、スイッチオフ
if sw == 0:
gt += T #スイッチオフの時はT秒追加
else:
gt += t - bt #スイッチがオンのとき、前回からの経過時間を加算
bt = t
sw = 1 #スイッチオン。
print((str(gt))) | #N,Tの取得
l = list(map(int, input().split()))
N = l[0]
T = l[1]
#秒のリストを取得
tl = list(map(int, input().split()))
bt = 0 #直前のスイッチを押した時間
gt = T #秒数総和
for t in tl[1:]:
if t - bt > T:
gt += T #スイッチオフの時はT秒追加
else:
gt += t - bt #スイッチがオンのとき、前回からの経過時間を加算
bt = t
print((str(gt))) | p03731 |
#N,Tの取得
l = list(map(int, input().split()))
N = l[0]
T = l[1]
#秒のリストを取得
tl = list(map(int, input().split()))
bt = 0 #直前のスイッチを押した時間
gt = T #秒数総和
for t in tl[1:]:
if t - bt > T:
gt += T #スイッチオフの時はT秒追加
else:
gt += t - bt #スイッチがオンのとき、前回からの経過時間を加算
bt = t
print((str(gt))) | #N,Tの取得
N,T = list(map(int, input().split()))
#秒のリストを取得
tl = list(map(int, input().split()))
bt = 0 #直前のスイッチを押した時間
gt = T #秒数総和
for t in tl[1:]:
if t - bt > T:
gt += T #スイッチオフの時はT秒追加
else:
gt += t - bt #スイッチがオンのとき、前回からの経過時間を加算
bt = t
print((str(gt))) | p03731 |
n, T= list(map(int, input().split()))
t = list(map(int, input().split()))
total = T
for i in range(1, n):
if t[i]-t[i-1]>=T:
total += T
else:
total += t[i]-t[i-1]
print(total) | n, T= list(map(int, input().split()))
t = list(map(int, input().split()))
total = T
for i in range(1, n):
total += min(T, t[i]-t[i-1])
print(total) | p03731 |
def LI(): return [int(x) for x in input().split(" ")]
def LS(): return [str(x) for x in input().split(" ")]
def ItoS(L): return [str(x) for x in L]
def StoI(L): return [int(c) for c in L]
def solve():
n, t = LI()
T = LI()
sentou = [0 for _ in range(T[-1] + t + 1)]
i = 0
while i < len(T):
sentou[T[i]] += 1
sentou[T[i] + t] -= 1
i += 1
j = 1
while j < len(sentou):
sentou[j] += sentou[j - 1]
j += 1
print((n * t - (sum(sentou) - (sentou.count(1) + len(sentou) - sentou.count(1) - sentou.count(0)))))
solve() | def LI(): return [int(x) for x in input().split(" ")]
def LS(): return [str(x) for x in input().split(" ")]
def ItoS(L): return [str(x) for x in L]
def StoI(L): return [int(c) for c in L]
def solve():
n, t = LI()
T = LI()
ans = 0
for i in range(len(T) - 1):
ans += min(t, T[i + 1] - T[i])
print((ans + t))
solve() | p03731 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.