input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *
from math import *
from fractions import *
sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()
def main():
N = int(eval(input()))
h = list(map(int, input().split()))
ans = 0
while sum(h) > 0:
for i in range(N):
for j in reversed(list(range(1, N - i + 1))):
if min(h[i:i + j]) > 0:
for k in range(i, i + j):
h[k] -= 1
ans += 1
break
else:
continue
break
print(ans)
main()
| import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *
from math import *
from fractions import *
sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()
def f(arr):
m = min(arr)
for i in range(len(arr)):
arr[i] -= m
buf = []
ret = m
for i in arr:
if i == 0:
if len(buf) > 0:
ret += f(buf)
buf = []
else:
buf.append(i)
if len(buf) > 0:
ret += f(buf)
return ret
def main():
N = int(eval(input()))
h = list(map(int, input().split()))
print((f(h)))
main()
| p03147 |
N = int(eval(input()))
H = list(map(int, input().split()))
count = 0
H.append(0)
for lv in range(1, 101):
flag = False
for h in H:
if flag and h < lv:
count += 1
flag = False
elif not flag and h >= lv:
flag = True
print(count)
| N=int(eval(input()))
*H,=list(map(int, input().split()))
H = [0] + H
ans = 0
for i in range(1,N+1):
w = H[i] - H[i-1]
if w > 0: ans += w
print(ans) | p03147 |
N = int(eval(input()))
H = list(map(int,input().split()))
ans = 0
for i in range(N-1):
if(H[i] > H[i+1]):
ans += H[i] - H[i+1]
print((ans + H[-1])) | def ans():
N = int(eval(input()))
H = list(map(int,input().split()))
res = 0
for i in range(N-1):
if(H[i] > H[i+1]):
res += H[i] - H[i+1]
print((res + H[-1]))
ans() | p03147 |
N = int(eval(input()))
h = list(map(int, input().split()))
board = [[0] * (N + 1) for _ in range(max(h))]
for i in range(N):
for j in range(h[i]):
board[j][i + 1] = 1
print((sum(row[i] == 0 and row[i + 1] == 1 for row in board for i in range(N))))
| eval(input())
ans, tmp = 0, 0
for h in map(int, input().split()):
ans += max(0, h - tmp)
tmp = h
print(ans)
| p03147 |
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
n = ri()
ls = ril()
prev = 0
up = True
res = 0
for x, y in zip(ls, ls[1:] + [0]):
if up and x > y:
res += x - prev
up = False
elif not up and x < y:
prev = x
up = True
print(res) | import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
n = ri()
ls = ril()
res = 0
for x, y in zip([0] + ls, ls):
if x < y:
res += y - x
print(res) | p03147 |
N=int(eval(input()))
A=list(map(int,input().split()))
maxh=max(A)
ans=0
for i in range(1,maxh+1):
# i 以上の高さのブロック数をカウントする
block=0
cur=False
if A[0]>=i:
block+=1
cur=True
for j in range(1,len(A)):
if A[j]>=i:
if not cur:
block+=1
cur=True
else:
cur=False
ans+=block
print(ans)
| N=int(eval(input()))
A=list(map(int,input().split()))
cur=0
ans=0
for i in range(N):
if A[i]>cur:
ans+=A[i]-cur
cur=A[i]
print(ans) | p03147 |
'''
数列hを棒グラフと見て
0と0で挟まれた山の個数を数える→すべて-1して山を削っていく
出力例２なら
[3 1 2 3 1]をmax(h)回，-1ずつ減らしていく
[2, 0, 1, 2, 0]
[1, 0, 0, 1, 0]
[0, 0, 0, 0, 0]
0になると花に水をやってはいけないから
count0でその花が何番目にあるか，を取得
数列count0で前項との差が1より大きければ山がある＝水をかけれる
'''
n=int(eval(input()))
h=list(map(int, input().split()))
sum=0
for i in range(max(h)):
if 0 not in h:
h=[X-1 if X>0 else 0 for X in h]
sum+=1
# print(h,1)
else:
count0=[Y for Y, Z in enumerate(h) if Z==0]
a=count0.copy()
b=count0.copy()
del a[0]
del b[-1]
c=[x-y for(x,y) in zip(a,b)]
sum = sum + len(c)-c.count(1)
if count0[0]>0 and count0[-1]<n-1:
sum +=2
elif count0[0]>0 or count0[-1]<n-1:
sum +=1
else:
sum +=0
h=[i-1 if i>0 else 0 for i in h]
print(sum)
| n,*h=list(map(int,open(0).read().split()))
a=h[0]
for i in range(1,n):
if h[i-1]<h[i]:
a+=h[i]-h[i-1]
print(a) | p03147 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
# 方針
# 前から順に-1していく
# その際、常に前の数を見ておき、0になった場合一区切り
# カウンターを+1する
# また、最後の項に達したときも+1
# インデックスは先頭に戻して
# 全ての項が0になるまで繰り返す
# （全部0になったことを確認するため、初めにsumを取って
# 引き算するたびにsumも-1していき、0になったらループ脱出）
def main():
n=I()
l=LI()
sm=sum(l)
i=0
c=0
while True:
# print(l)
# print(c)
if l[i]!=0:
l[i]-=1
sm-=1
if i==n-1 or l[i+1]==0:
c+=1
i+=1
if i>=n:
i=0
if sm==0:
break
return c
print((main()))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
sm=sum(l)
c=0
i=0
while True:
if l[i]>0:
l[i]-=1
sm-=1
if i+1==n or l[i+1]==0:
c+=1
i+=1
if i>=n:
i=0
if sm==0:
return c
print((main()))
| p03147 |
N = int(eval(input()))
h = list(map(int, input().split()))
ans = 0
for i in range(max(h)):
h.append(0)
count = 0
for k in range(N):
if h[k] != 0 and h[k + 1] == 0:
count += 1
ans += count
h = list([(x - 1, 0)[x == 0] for x in h])
print(ans) | N = int(eval(input()))
h = list(map(int, input().split()))
ans = 0
count = 0
h.append(0)
f = set(h)
for i in range(max(h)):
if i in f:
count = 0
for k in range(N):
if h[k] != 0 and h[k + 1] == 0:
count += 1
ans += count
h = list([(x - 1, 0)[x == 0] for x in h])
print(ans) | p03147 |
n=0
Answer=0
N=int(eval(input()))
h=list(map(int,input().split()))
h.insert(0,0)
for i in range(N):
if h[n]<=h[n+1]:
m=h[n+1]-h[n]
Answer=Answer+m
else :
pass
n=n+1
print(Answer) | N=int(eval(input()))
h=list(map(int,input().split()))
Answer=h[0]
for i in range(N-1):
if h[i]<=h[i+1]:
m=h[i+1]-h[i]
Answer=Answer+m
print(Answer) | p03147 |
n = int(eval(input()))
H = [int(i) for i in input().split()]
count = 0
for _ in range(100):
flag = 1
for i in range(n):
if H[i] > 0:
H[i] -= 1
if flag:
count += 1
flag = 0
else:
flag = 1
print(count) | n = int(eval(input()))
A = [0] + [int(i) for i in input().split()]
cnt = 0
for i in range(n):
if A[i + 1] > A[i]:
cnt += A[i + 1] - A[i]
print(cnt) | p03147 |
N = int(eval(input()))
h = list(map(int,input().split()))
if h == [0]*N:
print((0))
exit()
for i in range(1,10001):
f = False
for j in range(N):
if h[j] > 0:
h[j] -= 1
f = True
elif h[j] <= 0 and f:
break
if h == [0]*N:
ans = i
break
print(ans) | N = int(eval(input()))
H = list(map(int,input().split()))
cnt = 0
for _ in range(10**4):
if any(H) is False:
break
cnt += 1
f = False
for i in range(len(H)):
if H[i] > 0:
H[i] -= 1
f = True
elif f and H[i] == 0:
break
print(cnt) | p03147 |
from sys import stdin
from itertools import groupby
n = int(stdin.readline().rstrip())
li = list(map(int,stdin.readline().rstrip().split()))
li = [0] + li
zantei = 0
point = 0
for i in range(len(li)):
if li[i-1] <= li[i]:
point += li[i]-li[i-1]
print(point) | n = int(eval(input()))
h = list(map(int,input().split()))
point = 0
now = 0
for i in h:
if now <= i:
now,point = i,point+(i-now)
else:
now = i
print(point) | p03147 |
def calc(a,n):
array = [[a[j]>i for j in range(n)] for i in range(max(a))]
mat = [[a for a,b in zip(row,row[1:]+[False]) if a and a!=b]for row in array]
return sum([len(row)for row in mat])
n = int(eval(input()))
a = [int(e) for e in input().split()]
print((calc(a,n))) | n = int(eval(input()))
a = [int(e) for e in input().split()]
tmp_mat = [[a[j]>i for j in range(n)] for i in range(max(a))]
mat = [[a for a,b in zip(row,row[1:]+[False]) if a and a!=b]for row in tmp_mat]
print((sum([len(row)for row in mat]))) | p03147 |
N = int(eval(input()))
H = list(map(int,input().split()))
flowers = [0] * N
start = 0
end = 0
con = 0
while flowers != H:
for i in range(0,N):
if H[i] > flowers[i]:
start = i
for j in range(i,N):
if H[j] == flowers[j]:
end = j
break
else:
end = N
break
for k in range(start,end):
flowers[k] += 1
con += 1
start = 0
end = 0
print(con) | N = int(eval(input()))
L = list(map(int,input().split()))
s = L[0]
ans = s
for i in range(0,N):
if s <= L[i]:
ans += L[i] - s
s = L[i]
print(ans) | p03147 |
n=int(eval(input()))
h=[int(x) for x in input().split()]
height=[]
result=0
tmp=0
for i in range(max(h)):
buf=[]
for j in range(n):
if h[j] > i:
buf.append(1)
else:
buf.append(0)
height.append(buf)
for val in height:
while(tmp < len(val)):
if val[tmp]==0:
tmp+=1
else:
result+=1
while(tmp<len(val)):
if(val[tmp]==0):
break
tmp+=1;
tmp=0
#print(height)
print(result) | n=int(eval(input()))
h=[int(x) for x in input().split()]
buf=[0 for i in range(n)]
ans=0
flag=False
for i in range(max(h)):
for j in range(n):
if h[j] >= i+1:
flag=True
if flag and h[j] <= i:
ans+=1
flag=False
if flag:
ans+=1
flag=False
print(ans) | p03147 |
def main():
import sys
input = sys.stdin.readline
a = int(input().rstrip('\n'))
s = str(input().rstrip('\n'))
if a >= 3200:
print(s)
else:
print("red")
if __name__ == '__main__':
main()
| def slove():
import sys
input = sys.stdin.readline
a = int(input().rstrip('\n'))
s = str(input().rstrip('\n'))
print((s if a >= 3200 else "red"))
if __name__ == '__main__':
slove()
| p02933 |
import decimal
X = int(eval(input()))
i = 0
K = 100
while K < X:
i = i + 1
K_ = decimal.Decimal(str(K*1.01))
K = int(K_.quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR))
print(i) | X = int(eval(input()))
i = 0
K = 100
while K < X:
i = i + 1
K = int(K*1.01)
print(i) | p02694 |
import sys
input = sys.stdin.readline
from collections import *
X = int(eval(input()))
now = 100
ans = 0
while now<X:
now = int(1.01*now)
ans += 1
print(ans) | X = int(eval(input()))
now = 100
ans = 0
while now<X:
now += now//100
ans += 1
print(ans) | p02694 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from math import floor
from decimal import Decimal
def main():
x = int(eval(input()))
n = Decimal(100)
r = 0
while n < x:
n = Decimal(floor((n * Decimal(101) / Decimal(100))))
r += 1
print(r)
if __name__ == '__main__':
main() | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from math import floor
from decimal import Decimal
def main():
x = int(eval(input()))
n = Decimal(100)
r = 0
while n < x:
n = Decimal(floor((n * 101 / 100)))
r += 1
print(r)
if __name__ == '__main__':
main()
| p02694 |
from math import floor
def main():
X=int(eval(input()))
tmp=100
for year in range(1,4000):
tmp += tmp//100
if tmp >= X:
print(year)
exit()
main()
| def main():
X=int(eval(input()))
tmp=100
for year in range(1,4000):
tmp += tmp//100
if tmp >= X:
print(year)
exit()
main()
| p02694 |
from sys import exit
def main():
X = int(eval(input()))
deposit = 100
i = 0
while True:
deposit = int(deposit * 1.01)
i += 1
if deposit >= X:
print(i)
exit()
if __name__ == '__main__':
main() | # from sys import exit
def main():
x = int(eval(input()))
d = 100
ans = 0
while d < x:
d = int(d*1.01)
ans += 1
print(ans)
if __name__ == '__main__':
main() | p02694 |
import math
x = int(eval(input()))
a = 100
for i in range(1,4000):
a = math.floor(a * 1.01)
if a >= x:
print(i)
break
| x = int(eval(input()))
a = 100
ans = 0
while (a < x):
a += a//100
ans+=1
print(ans) | p02694 |
x=int(eval(input()))
n=100
cnt=0
while n<x:
cnt+=1
n*=101
n//=100
print(cnt) | x=int(eval(input()))
n=100
cnt=0
while n<x:
cnt+=1
n+=n//100
print(cnt)
| p02694 |
from math import floor,ceil
X = int(eval(input()))
p = 100
c = 0
while p < X:
p=floor(p*1.01)
c += 1
print(c) | from math import floor,ceil
X = int(eval(input()))
cash = 100
count = 0
while cash < X:
cash=floor(cash*1.01)
count += 1
print(count) | p02694 |
X = int(eval(input()))
a = 100
i = 0
while a < X:
a += a // 100
i += 1
print(i) | X = int(eval(input()))
# 割り算をして切り下げるときは a // b が良い！
a = 100
i = 0
while a < X:
a += a // 100
i += 1
print(i) | p02694 |
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
x = int(eval(input()))
yokin = 100
for i in range(1, 100000000000):
yokin *= 101
yokin = yokin //100
if (yokin >= x):
print(i)
break
| #k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
x = int(eval(input()))
yokin = 100
for i in range(1, 100000000000):
yokin += yokin // 100
if (yokin >= x):
print(i)
break
| p02694 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
# sys.setrecursionlimit(100000)
input = sys.stdin.buffer.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(X):
T = 100
for i in range(INF):
T *= 1.01
T = int(T)
if X <= T:
return i + 1
def main():
X = read_int()
print(slv(X))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
INF = 2**62-1
def read_int():
return int(eval(input()))
def slv(X):
T = 100
for i in range(INF):
T += T // 100
T = int(T)
if X <= T:
return i + 1
def main():
X = read_int()
print((slv(X)))
if __name__ == '__main__':
main()
| p02694 |
import math
from decimal import Decimal
X = int(eval(input()))
now = 100
year = 0
while True:
if now >= X:
break
#now = int(now * Decimal("1.01"))
now = int(now * round(Decimal(1.01), 2))
year += 1
print(year)
| import math
from decimal import Decimal
X = int(eval(input()))
now = 100
year = 0
while True:
if now >= X:
break
#now = int(now * Decimal("1.01"))
#now = int(now * round(Decimal(1.01), 2))
now += now // 100
year += 1
print(year)
| p02694 |
n = 0
m = 100
X = int(eval(input()))
while m < X:
m += (m // 100)
n += 1
print(n)
| X = int(eval(input()))
n = 0
x = 100
while x < X:
x += x // 100
n += 1
print(n) | p02694 |
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def rangeI(it, l, r):
for i, e in enumerate(it):
if l <= i < r:
yield e
elif l >= r:
break
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
MOD = 10**9+7
x = int(input())
a = 100
count = 0
while a < x:
a = int(a*1.01)
count += 1
print(count)
| x = int(eval(input()))
a = 100
count = 0
while a < x:
a = int(a*101//100)
count += 1
print(count) | p02694 |
x = int(eval(input()))
depo = 100
#rate = depo*0.01
count = 0
while depo < x:
rate = depo*0.01
depo += rate
depo = int(depo)
count += 1
print(count)
|
x = int(eval(input()))
depo = 100
count = 0
while depo < x:
depo += int(depo*0.01)
count += 1
print(count)
| p02694 |
x = int(eval(input()))
dum = 100
count = 0
while(1):
if dum >= x:
break
dum = dum*1.01
dum = dum//1
count += 1
#print(dum)
print(count) | import math
x = int(eval(input()))
a = 100
cnt = 0
while(1):
cnt += 1
a += a//100
if a >= x:
break
print(cnt)
| p02694 |
from math import floor
x = int(eval(input()))
ans = 0
y = 100
while y < x:
y = floor(y*1.01)
ans += 1
print(ans) | def resolve():
X = int(eval(input()))
tmp = 100
ans = 0
while tmp<X:
tmp += tmp//100
ans += 1
print(ans)
resolve() | p02694 |
X = int(eval(input()))
save = 100
count = 0
while save < X:
save += int(save * 0.01)
count += 1
print(count) | X = int(eval(input()))
m = 100
count = 0
while m < X:
m *= 1.01
m = int(m)
count += 1
print(count) | p02694 |
X = int(eval(input()))
count = 0
money = int(100)
while True:
money = int(money * 1.01)
count += 1
if money >= X:
print(count)
break
| X = int(eval(input()))
count = 0
money = 100
while True:
money = int(money * 1.01)
count += 1
if money >= X:
print(count)
break
| p02694 |
X = int(eval(input()))
p = 100
i = 0
while p < X:
i += 1
p += int(p*0.01)
print(i) | x = int(eval(input()))
i = 0
z = 100
while z < x:
i += 1
z = int(z * 1.01)
print(i) | p02694 |
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))
X = int(eval(input()))
v = 100
cnt = 0
while v<X:
v = int(v*1.01)
cnt += 1
print(cnt)
| #import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))
X = int(eval(input()))
v = 100
cnt = 0
while v<X:
v = v*101//100
cnt += 1
print(cnt)
| p02694 |
import math
x = int(eval(input()))
y=math.floor(100)
d=int(y)
year=0
while y<x:
y*=1.01
d=int(y)
y=d
year+=1
#print(y,year)
print(year) | x = int(eval(input()))
y=100
year=0
while y<x:
y=int(y*1.01)
year+=1
print(year) | p02694 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from math import floor
x = int(readline())
v = 100
for i in range(x):
v = floor(v * 1.01)
if v >= x:
print((i + 1))
exit()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from math import floor
x = int(read())
v = 100
for i in range(x):
v = floor(v * 1.01)
if v >= x:
print((i + 1))
exit()
| p02694 |
import math
x = int(eval(input()))
m = 100
cnt = 0
while 1:
cnt += 1
m = m + math.floor(m * 0.01)
if m >= x:
break
print(cnt) | import math
x = int(eval(input()))
m = 100
cnt = 0
while 1:
cnt += 1
m = math.floor(m * 1.01)
if m >= x:
break
print(cnt) | p02694 |
x = int(eval(input()))
import sys
sys.setrecursionlimit(4000)
def f(n):
if n == 1:
return 101
else:
return int(f(n-1)*1.01)
n = 1
while f(n) < x:
n += 1
else:
print(n) | x = int(eval(input()))
import sys
sys.setrecursionlimit(4000)
import math
p = math.log(1.01, 10)
q = int(math.log(x/100, 10)/p)
def f(n):
if n == 1:
return 101
else:
return int(f(n-1)*1.01)
n = q
while f(n) < x:
n += 1
else:
print(n) | p02694 |
def main():
x = int(eval(input()))
m = 100
for i in range(10**5):
if m >= x:
print(i)
return
m += m//100
if __name__ == "__main__":
main() | def main():
x = int(eval(input()))
money = 100
for i in range(10**5):
if money >= x:
print(i)
return
money += money//100
if __name__ == "__main__":
main()
| p02694 |
import math
x = int(eval(input()))
a = 100
ans = 1
while True:
a = int(math.floor(a*1.01))
if a >= x:
print(ans)
exit()
else:
ans += 1 | import math
x = int(eval(input()))
money = 100
ans = 0
while True:
if money >= x:
print(ans)
exit()
else:
money = int(math.floor(money * 1.01))
ans += 1 | p02694 |
x = int(eval(input()))
money = 100
ans = 0
while money < x:
ans += 1
money *= 101
money //= 100
print(ans) | x = int(eval(input()))
money, cnt = 100, 0
while money < x:
money += money // 100
cnt += 1
print(cnt) | p02694 |
k = int(eval(input()))
now = 100
cnt = 0
while (now < k):
now *= 1.01
now = int(now)
cnt += 1
print(cnt) | x = int(eval(input()))
money = 100
ans = 0
while(money < x):
ans += 1
money *= 1.01
money = int(money)
print(ans)
| p02694 |
x = int(eval(input()))
total = 100
year = 0
while x > total:
year += 1
total += total//100
print(year)
| import math
x = int(eval(input()))
initial = 100
count = 0
while initial < x:
initial += initial//100
count += 1
print(count) | p02694 |
a = [100]
for i in range(4000):
a.append(a[-1] + a[-1] // 100)
x = int(eval(input()))
for i in range(4000):
if a[i] >= x:
print(i)
exit() | X = int(eval(input()))
x1 = 100
r = 0.01
t = 0
if 101 <= X <=10**18:
while x1 < X:
R = int(x1 * r)
x1 = R + x1
t = t + 1
print(t)
| p02694 |
x = int(eval(input()))
money = 100
year = 0
while money < x:
money += int(money / 100)
year += 1
print(year)
| x = int(eval(input()))
money = 100
year = 0
while money < x:
money += money // 100
year += 1
print(year)
| p02694 |
from math import floor
from fractions import Fraction
from decimal import Decimal
def com_interest(n: int) -> int:
saving = Decimal(100)
interest_per = 0.01
years = 0
while True:
years += 1
b = Decimal('1.01')
saving = int(saving) * b
if saving >= n:
break
return years
print((com_interest(int(eval(input()))))) | from decimal import Decimal
def com_interest(n: int) -> int:
saving = Decimal('100')
interest_per = 0.01
years = 0
while True:
years += 1
saving = int(saving * Decimal('1.01'))
if saving >= n:
break
return years
print((com_interest(int(eval(input())))))
| p02694 |
from decimal import Decimal
x=int(eval(input()))
n=Decimal("100")
ans=0
while True:
ans+=1
n*=Decimal("1.01")
n//=1
if n>=x:
print(ans)
break | x=int(eval(input()))
n=100
ans=0
while True:
ans+=1
n+=n//100
if n>=x:
print(ans)
break | p02694 |
X = int(eval(input()))
y = 100
flag = 1
con = 0
while flag:
y *= 1.01
y = int(y)
con += 1
if y >= X:
flag = 0
print(con)
| X = int(eval(input()))
money = 100
ans = 0
while money < X:
ans += 1
money = int(money*1.01)
print(ans) | p02694 |
x = int(eval(input()))
year = 0
m = 100
for i in range(100000):
m = int(m*1.01)
year += 1
if m >= x:
print(year)
exit() | x = int(eval(input()))
year = 0
m = 100
for i in range(100000):
m = m*101//100
year += 1
if m >= x:
print(year)
exit() | p02694 |
while 1:
N,T,L,B = list(map(int,input().split()))
if N == 0: break
lose = [int(input()) for i in range(L)]
back = [int(input()) for i in range(B)]
dp = [[0.0]*(N+1) for i in range(T+2)]
dp[0][0] = 1.0
ans = 0.0
p = 1.0/6.0
for t in range(T):
for i in range(N):
tt = t-1 if i in lose else t
for j in range(i+1,i+7):
if j > N: j = N-j%N
if j in back:
dp[t+1][0] += p*dp[tt][i]
else:
dp[t+1][j] += p*dp[tt][i]
dp[t+1][N] += dp[t][N]
print("%.6f"%dp[T][N]) | while 1:
N,T,L,B = list(map(int,input().split()))
if N == 0: break
lose = set([int(input()) for i in range(L)])
back = set([int(input()) for i in range(B)])
dp = [[0.]*(N+1) for i in range(T+1)]
dp[0][0] = 1.
p = 1./6.
for t in range(T):
for i in range(N):
tt = t-1 if i in lose else t
for j in range(i+1,i+7):
if j > N: j = N-j%N
if j in back: j = 0
dp[t+1][j] += p*dp[tt][i]
dp[t+1][N] += dp[t][N]
print("%.6f"%dp[T][N]) | p00856 |
while 1:
N, T, L, B = list(map(int,input().split(" ")))
if N == T == L == B == 0: break
check = 0
dp = [[0 for _ in range(N+1)] for _ in range(T+1)]
Lose = set([int(input()) for _ in range(L)])
Back = set([int(input()) for _ in range(B)])
dp[0][0] = 1
for i in range(T):
for j in range(N):
rank = i-1 if j in Lose else i
for d in range(1,7):
next = j + d
if next > N :
next = N - (next - N)
if next in Back:
dp[i+1][0] += dp[rank][j] / 6.
else :
dp[i+1][next] += dp[rank][j] / 6.
print("%6f" % sum([dp[i][N] for i in range(1,T+1)])) | while 1:
N, T, L, B = list(map(int,input().split(" ")))
if N == T == L == B == 0: break
dp = [[0 for _ in range(N+1)] for _ in range(T+1)]
Lose = set([int(input()) for _ in range(L)])
Back = set([int(input()) for _ in range(B)])
dp[0][0] = 1
for i in range(T):
for j in range(N):
rank = i-1 if j in Lose else i
for d in range(1,7):
next = j + d
if next > N :
next = N - (next - N)
if next in Back:
dp[i+1][0] += dp[rank][j] / 6.
else :
dp[i+1][next] += dp[rank][j] / 6.
print("%6f" % sum([dp[i][N] for i in range(1,T+1)])) | p00856 |
import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
#import heapq
#import time
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(eval(input()))
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def same(self, x, y):
return self.find(x) == self.find(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find(x)]
def kruskal(v, edge):
edge.sort(key=lambda x: x[2])
res=0
uf = UnionFind(v)
for e in edge:
if uf.same(e[0], e[1]):
continue
uf.unite(e[0], e[1])
res+=e[2]
return res
n = ri()
d1=[rl()+[i] for i in range(n)]
d2=copy.deepcopy(d1)
d1.sort(key=lambda x: x[0])
d2.sort(key=lambda x: x[1])
edge=[]
for i in range(n-1):
edge.append(( d1[i+1][2], d1[i][2],d1[i+1][0]-d1[i][0]))
edge.append(( d2[i+1][2], d2[i][2],d2[i+1][1]-d2[i][1]))
edge.sort(key=lambda x: x[2])
res=0
uf = UnionFind(n)
for e in edge:
if uf.same(e[0], e[1]):
continue
uf.unite(e[0], e[1])
res+=e[2]
print(res) | import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
#import heapq
#import time
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(eval(input()))
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def same(self, x, y):
return self.find(x) == self.find(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find(x)]
n = ri()
d=[tuple(rl())+tuple((i,)) for i in range(n)]
d.sort(key=lambda x: x[0])
edge=[]
for i in range(n-1):
edge.append((d[i+1][2], d[i][2],d[i+1][0]-d[i][0]))
d.sort(key=lambda x:x[1])
for i in range(n-1):
edge.append((d[i+1][2], d[i][2],d[i+1][1]-d[i][1]))
edge.sort(key=lambda x: x[2])
res=0
uf = UnionFind(n)
for e in edge:
if uf.same(e[0], e[1]):
continue
uf.unite(e[0], e[1])
res+=e[2]
print(res) | p03684 |
import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
#import heapq
#import time
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(eval(input()))
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def same(self, x, y):
return self.find(x) == self.find(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find(x)]
n = ri()
d1=[tuple(rl())+tuple((i,)) for i in range(n)]
d2=copy.deepcopy(d1)
d1.sort(key=lambda x:x[0])
d2.sort(key=lambda x:x[1])
edge=[]
for i in range(n-1):
edge.append((d1[i+1][2], d1[i][2],d1[i+1][0]-d1[i][0]))
edge.append((d2[i+1][2], d2[i][2],d2[i+1][1]-d2[i][1]))
edge.sort(key=lambda x: x[2])
res=0
uf = UnionFind(n)
for e in edge:
if uf.same(e[0], e[1]):
continue
uf.unite(e[0], e[1])
res+=e[2]
print(res) | import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
#import heapq
#import time
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(eval(input()))
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def same(self, x, y):
return self.find(x) == self.find(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find(x)]
n = ri()
d1=[tuple(rl())+tuple((i,)) for i in range(n)]
d2=d1[:]
d1.sort(key=lambda x:x[0])
d2.sort(key=lambda x:x[1])
edge=[]
for i in range(n-1):
edge.append((d1[i+1][2], d1[i][2],d1[i+1][0]-d1[i][0]))
edge.append((d2[i+1][2], d2[i][2],d2[i+1][1]-d2[i][1]))
edge.sort(key=lambda x: x[2])
res=0
uf = UnionFind(n)
for e in edge:
if uf.same(e[0], e[1]):
continue
uf.unite(e[0], e[1])
res+=e[2]
print(res) | p03684 |
from collections import deque
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
N = int(eval(input()))
same = set()
xseq = []
yseq = []
uf = UnionFind(N)
ans = 0
for i in range(N):
x,y = (int(x) for x in input().split())
xseq.append((x,i))
yseq.append((y,i))
xseq.sort()
yseq.sort()
xdiff = [(xseq[i][0]-xseq[i-1][0],(xseq[i][1],xseq[i-1][1])) for i in range(1,N)]
ydiff = [(yseq[i][0]-yseq[i-1][0],(yseq[i][1],yseq[i-1][1])) for i in range(1,N)]
diff = xdiff + ydiff
diff.sort()
d = deque(diff)
for i in range(len(d)):
temp = d.popleft()
if uf.find(temp[1][0]) != uf.find(temp[1][1]):
uf.union(temp[1][0],temp[1][1])
ans += temp[0]
if uf.parents.count(-1*N) == 1:
break
print(ans) | from collections import deque
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
N = int(eval(input()))
xseq = []
yseq = []
uf = UnionFind(N)
ans = 0
for i in range(N):
x,y = (int(x) for x in input().split())
xseq.append((x,i))
yseq.append((y,i))
xseq.sort()
yseq.sort()
xdiff = [(xseq[i][0]-xseq[i-1][0],(xseq[i][1],xseq[i-1][1])) for i in range(1,N)]
ydiff = [(yseq[i][0]-yseq[i-1][0],(yseq[i][1],yseq[i-1][1])) for i in range(1,N)]
diff = xdiff + ydiff
diff.sort()
d = deque(diff)
for i in range(len(d)):
temp = d.popleft()
if uf.find(temp[1][0]) != uf.find(temp[1][1]):
uf.union(temp[1][0],temp[1][1])
ans += temp[0]
print(ans) | p03684 |
N=int(eval(input()))
city=[0]*N
for i in range(N):
x,y=list(map(int,input().split()))
city[i]=(i,x,y)
city.sort(key=lambda x:x[1])
data=[(city[i][0],city[i+1][0],city[i+1][1]-city[i][1]) for i in range(N-1)]
city.sort(key=lambda x:x[2])
data+=[(city[i][0],city[i+1][0],city[i+1][2]-city[i][2]) for i in range(N-1)]
data.sort(key=lambda x:x[2])
root=[-1]*N
def search(i):
global root
if root[i]>=0:
root[i]=search(root[i])
return root[i]
return i
cost=0
for i,j,k in data:
ri=search(i)
rj=search(j)
if ri==rj:
continue
elif root[ri]<=root[rj]:
cost+=k
root[ri]+=root[rj]
root[rj]=ri
elif root[ri]>root[rj]:
cost+=k
root[rj]+=root[ri]
root[ri]=rj
print(cost) | import sys
input=sys.stdin.readline
N=int(eval(input()))
P=[tuple(map(int,input().split())) for i in range(N)]
X=[(i,P[i][0]) for i in range(N)]
Y=[(i,P[i][1]) for i in range(N)]
X.sort(key=lambda x:x[1])
Y.sort(key=lambda x:x[1])
Z=[(X[i][0],X[i+1][0],X[i+1][1]-X[i][1]) for i in range(N-1)]+[(Y[i][0],Y[i+1][0],Y[i+1][1]-Y[i][1]) for i in range(N-1)]
Z.sort(key=lambda x:x[2])
root=[-1]*N
def search(i):
global root
if root[i]>=0:
root[i]=search(root[i])
return root[i]
return i
ans=0
for i,j,k in Z:
ri=search(i)
rj=search(j)
if ri==rj:
continue
elif root[ri]<=root[rj]:
root[ri]+=root[rj]
root[rj]=ri
ans+=k
else:
root[rj]+=root[ri]
root[ri]=rj
ans+=k
print(ans) | p03684 |
import heapq
class UnionFind():
def __init__(self, size):
self.table = [-1 for _ in range(size)]
self.count = 0
def find(self, x):
while self.table[x] >= 0:
x = self.table[x]
return x
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] > self.table[s2]:
self.table[s2] = s1
elif self.table[s1] < self.table[s2]:
self.table[s1] = s2
else:
self.table[s1] = s2
self.table[s2] -= 1
self.count += 1
return True
return False
n = int(eval(input()))
x = []
y = []
for i in range(n):
a, b = list(map(int, input().split()))
x.append([i, a])
y.append([i, b])
vx = sorted(x, key=lambda x: x[1])
vy = sorted(y, key=lambda x: x[1])
edges = []
uf = UnionFind(n)
for i in range(n - 1):
if vx[i][1] == vx[i + 1][1]:
uf.union(vx[i][0], vx[i + 1][0])
else:
heapq.heappush(edges, (vx[i + 1][1] - vx[i][1], vx[i][0], vx[i + 1][0]))
if vy[i][1] == vy[i + 1][1]:
uf.union(vy[i][0], vy[i + 1][0])
else:
heapq.heappush(edges, (vy[i + 1][1] - vy[i][1], vy[i][0], vy[i + 1][0]))
#edges = sorted(edges, key=lambda x: x[2], reverse=True)
#print(edges)
ans = 0
while edges != []:
e = heapq.heappop(edges)
if uf.union(e[1], e[2]):
ans += e[0]
if uf.count == n - 1:
break
print(ans) | import heapq
import sys
sys.setrecursionlimit(10 ** 7)
class UnionFind():
def __init__(self, size):
self.table = [-1 for _ in range(size)]
self.count = 0
# def find(self, x):
# while self.table[x] >= 0:
# x = self.table[x]
# return x
def find(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] > self.table[s2]:
self.table[s2] = s1
elif self.table[s1] < self.table[s2]:
self.table[s1] = s2
else:
self.table[s1] = s2
self.table[s2] -= 1
self.count += 1
return True
return False
n = int(eval(input()))
x = []
y = []
for i in range(n):
a, b = list(map(int, input().split()))
x.append([i, a])
y.append([i, b])
vx = sorted(x, key=lambda x: x[1])
vy = sorted(y, key=lambda x: x[1])
edges = []
uf = UnionFind(n)
for i in range(n - 1):
if vx[i][1] == vx[i + 1][1]:
uf.union(vx[i][0], vx[i + 1][0])
else:
heapq.heappush(edges, (vx[i + 1][1] - vx[i][1], vx[i][0], vx[i + 1][0]))
if vy[i][1] == vy[i + 1][1]:
uf.union(vy[i][0], vy[i + 1][0])
else:
heapq.heappush(edges, (vy[i + 1][1] - vy[i][1], vy[i][0], vy[i + 1][0]))
#edges = sorted(edges, key=lambda x: x[2], reverse=True)
#print(edges)
ans = 0
while edges != []:
e = heapq.heappop(edges)
if uf.union(e[1], e[2]):
ans += e[0]
if uf.count == n - 1:
break
print(ans) | p03684 |
# coding: utf-8
import array, bisect, collections, copy, heapq, itertools, math, random, re, string, sys, time
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
def II(): return int(eval(input()))
def ILI(): return list(map(int, input().split()))
def IAI(LINE): return [ILI() for __ in range(LINE)]
def IDI(): return {key: value for key, value in ILI()}
def read():
N = II()
x, y = [], []
for __ in range(N):
_x, _y = ILI()
x.append(_x)
y.append(_y)
return N, x, y
def solve(N, x, y):
cost = [[INF] * N for __ in range(N)]
for i in range(N):
for j in range(N):
x_i, y_i = x[i], y[i]
x_j, y_j = x[j], y[j]
cost[i][j] = min(abs(x_i - x_j), abs(y_i - y_j))
min_cost = [INF] * N
bool_used = [False] * N
ans = 0
min_cost[0] = 0
while True:
v = -1
for i in range(N):
if bool_used[i] is False and (v == -1 or min_cost[i] < min_cost[v]):
v = i
if v == -1:
break
bool_used[v] = True
ans += min_cost[v]
for i in range(N):
min_cost[i] = min(min_cost[i], cost[v][i])
return ans
def main():
params = read()
print((solve(*params)))
if __name__ == "__main__":
main()
| # coding: utf-8
import array, bisect, collections, copy, heapq, itertools, math, random, re, string, sys, time
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
def II(): return int(eval(input()))
def ILI(): return list(map(int, input().split()))
def IAI(LINE): return [ILI() for __ in range(LINE)]
def IDI(): return {key: value for key, value in ILI()}
def read():
N = II()
x, y = [], []
for __ in range(N):
_x, _y = ILI()
x.append(_x)
y.append(_y)
return N, x, y
class UnionFind(object):
def __init__(self, number_of_nodes): # 初期化
self.par = array.array("L", list(range(number_of_nodes)))
self.rank = array.array("L", (0 for i in range(number_of_nodes)))
def root(self, node): # 根を求める
if self.par[node] == node:
return node
else:
r = self.root(self.par[node])
self.par[node] = r # 経路圧縮
return r
def in_the_same_set(self, node1, node2): # 同じ集合に属するか
return self.root(node1) == self.root(node2)
def unite(self, node1, node2): # 属する集合を併合
x = self.root(node1)
y = self.root(node2)
if x == y:
pass
elif self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def solve(N, x, y):
edges = []
for i in range(N):
for j in range(i + 1, N):
edges.append((min(abs(x[i] - x[j]), abs(y[i] - y[j])) , i, j))
edges.sort(key=lambda x: x[0])
union_find = UnionFind(N)
ans = 0
for edge in edges:
if not union_find.in_the_same_set(edge[1], edge[2]):
union_find.unite(edge[1], edge[2])
ans += edge[0]
return ans
def main():
params = read()
print((solve(*params)))
if __name__ == "__main__":
main()
| p03684 |
# coding: utf-8
import array, bisect, collections, copy, heapq, itertools, math, random, re, string, sys, time
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
def II(): return int(eval(input()))
def ILI(): return list(map(int, input().split()))
def IAI(LINE): return [ILI() for __ in range(LINE)]
def IDI(): return {key: value for key, value in ILI()}
def read():
N = II()
x, y = [], []
for __ in range(N):
_x, _y = ILI()
x.append(_x)
y.append(_y)
return N, x, y
class UnionFind(object):
def __init__(self, number_of_nodes): # 初期化
self.par = array.array("L", list(range(number_of_nodes)))
self.rank = array.array("L", (0 for i in range(number_of_nodes)))
def root(self, node): # 根を求める
if self.par[node] == node:
return node
else:
r = self.root(self.par[node])
self.par[node] = r # 経路圧縮
return r
def in_the_same_set(self, node1, node2): # 同じ集合に属するか
return self.root(node1) == self.root(node2)
def unite(self, node1, node2): # 属する集合を併合
x = self.root(node1)
y = self.root(node2)
if x == y:
pass
elif self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def solve(N, x, y):
edges = []
for i in range(N):
for j in range(i + 1, N):
edges.append((min(abs(x[i] - x[j]), abs(y[i] - y[j])) , i, j))
edges.sort(key=lambda x: x[0])
union_find = UnionFind(N)
ans = 0
count = 0
for edge in edges:
if count == N - 1:
break
if not union_find.in_the_same_set(edge[1], edge[2]):
union_find.unite(edge[1], edge[2])
ans += edge[0]
count += 1
return ans
def main():
params = read()
print((solve(*params)))
if __name__ == "__main__":
main() | # coding: utf-8
import array, bisect, collections, copy, heapq, itertools, math, random, re, string, sys, time
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
def II(): return int(eval(input()))
def ILI(): return list(map(int, input().split()))
def IAI(LINE): return [ILI() for __ in range(LINE)]
def IDI(): return {key: value for key, value in ILI()}
def read():
N = II()
x, y = [], []
for i in range(N):
_x, _y = ILI()
x.append((i, _x))
y.append((i, _y))
return N, x, y
class UnionFind(object):
def __init__(self, number_of_nodes): # 初期化
self.par = array.array("L", list(range(number_of_nodes)))
self.rank = array.array("L", (0 for i in range(number_of_nodes)))
def root(self, node): # 根を求める
if self.par[node] == node:
return node
else:
r = self.root(self.par[node])
self.par[node] = r # 経路圧縮
return r
def in_the_same_set(self, node1, node2): # 同じ集合に属するか
return self.root(node1) == self.root(node2)
def unite(self, node1, node2): # 属する集合を併合
x = self.root(node1)
y = self.root(node2)
if x == y:
pass
elif self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def solve(N, x, y):
edges = []
x.sort(key=lambda x: x[1])
y.sort(key=lambda x: x[1])
for i in range(N - 1):
x_s, x_e = x[i], x[i + 1]
y_s, y_e = y[i], y[i + 1]
edges.append((x_s[0], x_e[0], x_e[1] - x_s[1]))
edges.append((y_s[0], y_e[0], y_e[1] - y_s[1]))
edges.sort(key=lambda x: x[2])
union_find = UnionFind(N)
ans = 0
for edge in edges:
if not union_find.in_the_same_set(edge[0], edge[1]):
union_find.unite(edge[0], edge[1])
ans += edge[2]
return ans
def main():
params = read()
print((solve(*params)))
if __name__ == "__main__":
main()
| p03684 |
import heapq
def prim_heap():
used = [True] * n #True:不使用
edgelist = []
for e in edge[0]:
heapq.heappush(edgelist,e)
used[0] = False
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0]
return res
#########################
n = int(eval(input()))
#隣接リストの作成 edge[i]:[コスト,行先]
edge = [[] for i in range(n)]
x_sort = [] #[Xi,Yi,点番号]
y_sort = [] #[Yi,Xi,点番号]
for i in range(n):
X,Y = list(map(int,input().split()))
x_sort.append([X,Y,i])
y_sort.append([Y,X,i])
x_sort.sort()
y_sort.sort()
for i in range(1,n):
edge[x_sort[i][2]].append([min(abs(x_sort[i][0]-x_sort[i-1][0]),abs(x_sort[i][1]-x_sort[i-1][1])),x_sort[i-1][2]])
edge[x_sort[i-1][2]].append([min(abs(x_sort[i][0]-x_sort[i-1][0]),abs(x_sort[i][1]-x_sort[i-1][1])),x_sort[i][2]])
edge[y_sort[i][2]].append([min(abs(y_sort[i][0]-y_sort[i-1][0]),abs(y_sort[i][1]-y_sort[i-1][1])),y_sort[i-1][2]])
edge[y_sort[i][2]].append([min(abs(y_sort[i][0]-y_sort[i-1][0]),abs(y_sort[i][1]-y_sort[i-1][1])),y_sort[i-1][2]])
print((prim_heap())) | import heapq
def prim_heap():
used = [True] * n #True:不使用
edgelist = []
for e in edge[0]:
heapq.heappush(edgelist,e)
used[0] = False
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0]
return res
#########################
n = int(eval(input()))
#隣接リストの作成 edge[i]:[コスト,行先]
edge = [[] for i in range(n)]
p=[]
edge=[[] for i in range(n)]
for i in range(n):
p.append(tuple(map(int,input().split()))+tuple([i]))
x_sorted=sorted(p,key=lambda x:x[0])
y_sorted=sorted(p,key=lambda x:x[1])
for i in range(n-1):
edge[x_sorted[i][2]].append((x_sorted[i+1][0]-x_sorted[i][0],x_sorted[i+1][2]))
edge[x_sorted[i+1][2]].append((x_sorted[i+1][0]-x_sorted[i][0],x_sorted[i][2]))
edge[y_sorted[i][2]].append((y_sorted[i+1][1]-y_sorted[i][1],y_sorted[i+1][2]))
edge[y_sorted[i+1][2]].append((y_sorted[i+1][1]-y_sorted[i][1],y_sorted[i][2]))
print((prim_heap())) | p03684 |
#!/usr/bin/env python3
import heapq
def main():
n = int(eval(input()))
nodes = []
for i in range(n):
xi, yi = list(map(int, input().split()))
nodes.append((i, xi, yi))
adj = [[] for i in range(n)]
nodes.sort(key=(lambda x: x[1]))
for j in range(n):
i = nodes[j][0]
if j - 1 >= 0:
i1 = nodes[j - 1][0]
adj[i].append(i1)
if j + 1 < n:
i1 = nodes[j + 1][0]
adj[i].append(i1)
nodes.sort(key=(lambda x: x[2]))
for j in range(n):
i = nodes[j][0]
if j - 1 >= 0:
i1 = nodes[j - 1][0]
adj[i].append(i1)
if j + 1 < n:
i1 = nodes[j + 1][0]
adj[i].append(i1)
nodes.sort(key=(lambda x: x[0]))
res = 0
q = [(0, 0)]
visited = [False for i in range(n)]
while q:
d, i = heapq.heappop(q)
if visited[i]:
continue
visited[i] = True
res += d
for j in adj[i]:
if visited[j]:
continue
heapq.heappush(q, (dist(i, j, nodes), j))
print(res)
def dist(i, j, nodes):
_, xi, yi = nodes[i]
_, xj, yj = nodes[j]
res = min(abs(xi - xj), abs(yi - yj))
return res
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import heapq
def main():
n = int(eval(input()))
nodes = []
for i in range(n):
xi, yi = list(map(int, input().split()))
nodes.append((i, xi, yi))
adj = [[] for i in range(n)]
nodesx = sorted(nodes, key=(lambda x: x[1]))
for j in range(n - 1):
i1 = nodesx[j][0]
i2 = nodesx[j + 1][0]
adj[i1].append(i2)
adj[i2].append(i1)
nodesy = sorted(nodes, key=(lambda x: x[2]))
for j in range(n - 1):
i1 = nodesy[j][0]
i2 = nodesy[j + 1][0]
adj[i1].append(i2)
adj[i2].append(i1)
res = 0
q = [(0, 0)]
visited = [False for i in range(n)]
while q:
d, i = heapq.heappop(q)
if visited[i]:
continue
visited[i] = True
res += d
for j in adj[i]:
if visited[j]:
continue
heapq.heappush(q, (dist(i, j, nodes), j))
print(res)
def dist(i, j, nodes):
_, xi, yi = nodes[i]
_, xj, yj = nodes[j]
res = min(abs(xi - xj), abs(yi - yj))
return res
if __name__ == "__main__":
main()
| p03684 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
# input=lambda :sys.stdin.readline().rstrip()
def resolve():
class UnionFind(object):
"""
query: O(Ack^-1(n,n)) (amortize)
"""
def __init__(self,n):
"""
param n: number of nodes
"""
self.__par=list(range(n))
self.__rank=[0]*n
self.__size=[1]*n
def __root(self,k):
if self.__par[k]==k: return k
else:
self.__par[k]=self.__root(self.__par[k])
return self.__par[k]
def is_same(self,i,j):
return self.__root(i)==self.__root(j)
def unite(self,i,j):
i=self.__root(i)
j=self.__root(j)
if i==j: return
if self.__rank[i]>self.__rank[j]:
self.__par[j]=i
else:
self.__par[i]=j
if self.__rank[i]==self.__rank[j]: self.__rank[j]+=1
# 候補となるedgesは2N-2個しかないため、全列挙
# Kruskal's algorithmでuniteしていく
from operator import itemgetter
n=int(eval(input()))
P=[0]*n
edges=[0]*(2*n-2)
for i in range(n):
x,y=list(map(int,input().split()))
P[i]=(x,y,i)
# xでsort
P.sort(key=itemgetter(0))
for k in range(n-1):
x0,y0,i=P[k]
x1,y1,j=P[k+1]
edges[k]=(i,j,min(abs(x0-x1),abs(y0-y1)))
# yでsort
P.sort(key=itemgetter(1))
for k in range(n-1):
x0,y0,i=P[k]
x1,y1,j=P[k+1]
edges[k+n-1]=(i,j,min(abs(x0-x1),abs(y0-y1)))
# edgesをcostでsort
edges.sort(key=itemgetter(2))
# union findに突っ込んでいく
tree=UnionFind(n)
ans=0
for i,j,cost in edges:
if tree.is_same(i,j): continue
tree.unite(i,j)
ans+=cost
print(ans)
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
class UnionFind(object):
"""
query: O(Ack^-1(n,n)) (amortize)
"""
def __init__(self,n):
"""
param n: number of nodes
"""
self.__par=list(range(n))
self.__rank=[0]*n
self.__size=[1]*n
def __root(self,k):
if self.__par[k]==k: return k
else:
self.__par[k]=self.__root(self.__par[k])
return self.__par[k]
def is_same(self,i,j):
return self.__root(i)==self.__root(j)
def unite(self,i,j):
i=self.__root(i)
j=self.__root(j)
if i==j: return
if self.__rank[i]>self.__rank[j]:
self.__par[j]=i
else:
self.__par[i]=j
if self.__rank[i]==self.__rank[j]: self.__rank[j]+=1
# Kruskal's algorithm
from operator import itemgetter
n=int(eval(input()))
P=[0]*n
edges=[0]*(2*n-2)
for i in range(n):
x,y=list(map(int,input().split()))
P[i]=(x,y,i)
# xでsort
P.sort(key=itemgetter(0))
for k in range(n-1):
x0,y0,i=P[k]
x1,y1,j=P[k+1]
edges[k]=(i,j,min(abs(x0-x1),abs(y0-y1)))
# yでsort
P.sort(key=itemgetter(1))
for k in range(n-1):
x0,y0,i=P[k]
x1,y1,j=P[k+1]
edges[k+n-1]=(i,j,min(abs(x0-x1),abs(y0-y1)))
# edgesをcostでsort
edges.sort(key=itemgetter(2))
# union findに突っ込んでいく
tree=UnionFind(n)
ans=0
for i,j,cost in edges:
if tree.is_same(i,j): continue
tree.unite(i,j)
ans+=cost
print(ans)
resolve() | p03684 |
import sys
import heapq
input = sys.stdin.readline
class Node:
def __init__(self, id):
self.id = id
self.check = False
self.link = []
self.cost = []
def __lt__(self, other):
return self.id < other.id
def main():
N = int(eval(input()))
nodes = [Node(i) for i in range(N)]
xy = []
for i in range(N):
x, y = list(map(int, input().split()))
xy.append((i, x, y))
for t in range(2):
if t == 0:
xy = sorted(xy, key=lambda x: x[1])# x昇順
else:
xy = sorted(xy, key=lambda x: x[2])# y昇順
p_n, p_x, p_y = xy[0]
for i in range(1, N):
n, x, y = xy[i]
if t == 0:
cost = abs(x - p_x)# x
else:
cost = abs(y - p_y)# y
nodes[p_n].link.append(nodes[n])
nodes[p_n].cost.append(cost)
nodes[n].link.append(nodes[p_n])
nodes[n].cost.append(cost)
p_n, p_x, p_y = n, x, y
q = []
ans = 0
heapq.heappush(q, (0, nodes[0]))# edge_cost, node
while len(q) > 0:
edge_cost, node = heapq.heappop(q)
if node.check:
continue
node.check = True
ans += edge_cost
for i, next_node in enumerate(node.link):
if not next_node.check:
heapq.heappush(q, (node.cost[i], next_node))
print(ans)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def same_tree(node_a, node_b):
if node_a.root() == node_b.root():
return True
def unite(node_a, node_b):
root_a = node_a.root()
root_b = node_b.root()
if root_a == root_b:
return
if root_b.depth > root_a.depth:
root_a, root_b = root_b, root_a
root_b.is_root = False
root_b.parent = root_a
root_a.depth = max(root_a.depth, root_b.depth+1)
class Node:
def __init__(self):
self.is_root = True
self.parent = None
self.depth = 1
def root(self):
node = self
while not node.is_root:
node = node.parent
return node
def main():
N = int(eval(input()))
nodes = [Node() for i in range(N)]
# 各町の座標をタプル(i, x, y)に入れて配列に格納
xy = []
for i in range(N):
x, y = list(map(int, input().split()))
xy.append((i, x, y))
# 使う可能性のある辺のみを取り出す
edges = []
xy = sorted(xy, key=lambda x: x[1])# x座標昇順
# print("x:", xy)
for i in range(1, N):
edges.append((xy[i][1] - xy[i-1][1], xy[i-1][0], xy[i][0]))
xy = sorted(xy, key=lambda x: x[2])# y座標昇順
# print("y:", xy)
for i in range(1, N):
edges.append((xy[i][2] - xy[i-1][2], xy[i-1][0], xy[i][0]))
ans = 0
edges = sorted(edges)
# print(edges)
for (cost, a, b) in edges:
if not same_tree(nodes[a], nodes[b]):
unite(nodes[a], nodes[b])
ans += cost
print(ans)
if __name__ == "__main__":
main() | p03684 |
#!/usr/bin/env pypy3
import array
import collections
import heapq
import itertools
AdjacentVertex = collections.namedtuple("AdjacentVertex", "vertex cost")
Town = collections.namedtuple("Town", "idx x y")
INF = 2 ** 31 - 1
NO_VERTEX = -1
# Prim法で頂点0からの最小全域木を求める
def compute_mst_prim(max_v, adj_list):
# pred[u]は頂点uの「ひとつ前」の頂点を表す
pred = collections.defaultdict(lambda: NO_VERTEX)
# uとpred[u]を結ぶ辺の重みがkey[u]に入る
key = collections.defaultdict(lambda: INF)
key[0] = 0
# 二分ヒープを優先度付きキューとして用いる
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# 優先度付きキューに頂点が入っているかを示す配列
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq[v] = True
return (pred, key)
def solve(n, towns):
txs = sorted(towns, key=lambda t: t.x)
tys = sorted(towns, key=lambda t: t.y)
adj_list = collections.defaultdict(set)
g = itertools.chain(list(zip(txs[:-1], txs[1:])), list(zip(tys[:-1], tys[1:])))
for t1, t2 in g:
cost = min(abs(t1.x - t2.x), abs(t1.y - t2.y))
adj_list[t1.idx].add(AdjacentVertex(t2.idx, cost))
adj_list[t2.idx].add(AdjacentVertex(t1.idx, cost))
(_, key) = compute_mst_prim(n, adj_list)
return sum(key.values())
def main():
n = int(eval(input()))
towns = []
for idx in range(n):
x, y = (int(z) for z in input().split())
towns.append(Town(idx, x, y))
res = solve(n, towns)
print(res)
if __name__ == '__main__':
main()
| #!/usr/bin/env pypy3
import array
import collections
import heapq
import itertools
AdjacentVertex = collections.namedtuple("AdjacentVertex", "vertex cost")
Town = collections.namedtuple("Town", "idx x y")
INF = 2 ** 31 - 1
NO_VERTEX = -1
# Prim法で頂点0からの最小全域木を求める
def compute_mst_prim(max_v, adj_list):
# pred[u]は頂点uの「ひとつ前」の頂点を表す
pred = [NO_VERTEX for _ in range(max_v)]
# uとpred[u]を結ぶ辺の重みがkey[u]に入る
key = [INF for _ in range(max_v)]
key[0] = 0
# 二分ヒープを優先度付きキューとして用いる
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# 優先度付きキューに頂点が入っているかを示す配列
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq[v] = True
return (pred, key)
def solve(n, towns):
txs = sorted(towns, key=lambda t: t.x)
tys = sorted(towns, key=lambda t: t.y)
adj_list = [set() for _ in range(n)]
g = itertools.chain(list(zip(txs[:-1], txs[1:])), list(zip(tys[:-1], tys[1:])))
for t1, t2 in g:
cost = min(abs(t1.x - t2.x), abs(t1.y - t2.y))
adj_list[t1.idx].add(AdjacentVertex(t2.idx, cost))
adj_list[t2.idx].add(AdjacentVertex(t1.idx, cost))
(_, key) = compute_mst_prim(n, adj_list)
return sum(key)
def main():
n = int(eval(input()))
towns = [Town(idx, *(int(z) for z in input().split())) for idx in range(n)]
res = solve(n, towns)
print(res)
if __name__ == '__main__':
main()
| p03684 |
N=int(eval(input()))
import sys
input=sys.stdin.readline
X=[[-10**10,0]]
Y=[[-10**10,0]]
for i in range(N):
x,y=list(map(int,input().split()))
X.append([x,i+1])
Y.append([y,i+1])
X.append([10**10,N+1])
Y.append([10**10,N+1])
X.sort()
Y.sort()
#print(X,Y)
L=[[]for i in range(N+1)]
for i in range(1,N+1):
L[X[i][1]].append([X[i][0]-X[i-1][0],X[i-1][1]])
L[X[i][1]].append([X[i+1][0]-X[i][0],X[i+1][1]])
for i in range(1,N+1):
L[Y[i][1]].append([Y[i][0]-Y[i-1][0],Y[i-1][1]])
L[Y[i][1]].append([Y[i+1][0]-Y[i][0],Y[i+1][1]])
#print(L)
C=[1 for i in range(N+2)]
C[0]=0
C[-1]=0
C[1]=0
import heapq
ans=0
Q=L[1]
heapq.heapify(Q)
for i in range(10**6):
#print(ans,Q)
#print(C)
if len(Q)==0:
break
q=heapq.heappop(Q)
if C[q[1]]==0:
continue
else:
C[q[1]]=0
ans+=q[0]
for j in range(4):
if C[L[q[1]][j][1]]==1:
heapq.heappush(Q,L[q[1]][j])
print(ans) | N=int(eval(input()))
import sys
input=sys.stdin.readline
X=[(-10**10,0)]
Y=[(-10**10,0)]
for i in range(N):
x,y=list(map(int,input().split()))
X.append((x,i+1))
Y.append((y,i+1))
X.append((10**10,N+1))
Y.append((10**10,N+1))
X.sort()
Y.sort()
#print(X,Y)
L=[[]for i in range(N+1)]
for i in range(1,N+1):
L[X[i][1]].append((X[i][0]-X[i-1][0],X[i-1][1]))
L[X[i][1]].append((X[i+1][0]-X[i][0],X[i+1][1]))
for i in range(1,N+1):
L[Y[i][1]].append((Y[i][0]-Y[i-1][0],Y[i-1][1]))
L[Y[i][1]].append((Y[i+1][0]-Y[i][0],Y[i+1][1]))
#print(L)
C=[1 for i in range(N+2)]
C[0]=0
C[-1]=0
C[1]=0
import heapq
ans=0
Q=L[1]
heapq.heapify(Q)
for i in range(10**6):
#print(ans,Q)
#print(C)
if len(Q)==0:
break
q=heapq.heappop(Q)
if C[q[1]]==0:
continue
else:
C[q[1]]=0
ans+=q[0]
for j in range(4):
if C[L[q[1]][j][1]]==1:
heapq.heappush(Q,L[q[1]][j])
print(ans) | p03684 |
import heapq
def prime_method():
start = graph[0]
not_went = [True] * n # n個の点に行ったかという話
edges = []
for e in start:
heapq.heappush(edges,e)
not_went[0] = False
cost = 0
while len(edges) != 0:
minedge = heapq.heappop(edges)
if not not_went[minedge[1]]:
continue
v = minedge[1]
gv = graph[v]
not_went[v] = False
for temp in gv:
if not_went[temp[1]]: # その頂点に行ってなければ
heapq.heappush(edges, temp)
cost += minedge[0]
return cost
# a[1] = [[2,3],[5,11]] → 点1からコスト2で頂点3に行ける辺、点1からコスト5で頂点11に行ける辺がある
n = int(eval(input()))
# cities = [(a, b, i) for i, (a, b) in enumerate([tuple(map(int, input().split())) for _ in range(N)])]
cities = []
for i in range(n):
cities.append(tuple(map(int,input().split()))+tuple([i]))
graph = [[] for i in range(n)]
citiesX=sorted(cities,key=lambda x:x[0])
citiesY=sorted(cities,key=lambda x:x[1])
for i in range(n-1):
graph[citiesX[i][2]].append([(citiesX[i+1][0] - citiesX[i][0]),citiesX[i+1][2]])
graph[citiesX[i+1][2]].append([(citiesX[i+1][0] - citiesX[i][0]),citiesX[i][2]])
graph[citiesY[i][2]].append([(citiesY[i+1][1] - citiesY[i][1]),citiesY[i+1][2]])
graph[citiesY[i+1][2]].append([(citiesY[i+1][1] - citiesY[i][1]),citiesY[i][2]])
print((prime_method())) |
import heapq
def prime_method():
not_went = [True] * n # n個の点に行ったかという話
edges = []
start = graph[0]
for e in start:
heapq.heappush(edges,e)
not_went[0] = False
cost = 0
while len(edges) != 0:
minedge = heapq.heappop(edges)
if not not_went[minedge[1]]:
continue
v = minedge[1]
gv = graph[v]
not_went[v] = False
for temp in gv:
if not_went[temp[1]]: # その頂点に行ってなければ
heapq.heappush(edges, temp)
cost += minedge[0]
return cost
# a[1] = [[2,3],[5,11]] → 点1からコスト2で頂点3に行ける辺、点1からコスト5で頂点11に行ける辺がある
n = int(eval(input()))
graph = [[] for i in range(n)]
cities = []
for i in range(n):
cities.append(tuple(map(int,input().split()))+tuple([i]))
citiesX=sorted(cities,key=lambda x:x[0])
citiesY=sorted(cities,key=lambda x:x[1])
for i in range(n-1):
graph[citiesX[i][2]].append(((citiesX[i+1][0] - citiesX[i][0]),citiesX[i+1][2]))
graph[citiesX[i+1][2]].append(((citiesX[i+1][0] - citiesX[i][0]),citiesX[i][2]))
graph[citiesY[i][2]].append(((citiesY[i+1][1] - citiesY[i][1]),citiesY[i+1][2]))
graph[citiesY[i+1][2]].append(((citiesY[i+1][1] - citiesY[i][1]),citiesY[i][2]))
print((prime_method())) | p03684 |
class UnionFindNode:
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.rank_ = 1
self.member_num_ = 1
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
root = self.root()
return root.group_id_
def rank(self):
root = self.root()
return root.rank_
def unite(self, unite_node):
root = self.root()
unite_root = unite_node.root()
if root.group_id_ != unite_root.group_id_:
if root.rank() > unite_root.rank():
unite_root.parent_ = root
root.rank_ = max(root.rank_, unite_root.rank_ + 1)
root.member_num_ = root.member_num_ + unite_root.member_num_
else:
root.parent_ = unite_root
unite_root.rank_ = max(root.rank_ + 1, unite_root.rank_)
unite_root.member_num_ = root.member_num_ + unite_root.member_num_
N, = list(map(int, input().split()))
X,Y = [],[]
for i in range(1, N+1):
x, y = list(map(int, input().split()))
X.append((x,i))
Y.append((y,i))
X = sorted(X, key=lambda x:x[0])
Y = sorted(Y, key=lambda x:x[0])
G = [set() for _ in range(N+1)]
Es = set()
for i in range(N-1):
Es.add((tuple(sorted([X[i][1], X[i+1][1]])), abs(X[i][0]-X[i+1][0])))
Es.add((tuple(sorted([Y[i][1], Y[i+1][1]])), abs(Y[i][0]-Y[i+1][0])))
G[X[i][1]].add(X[i+1][1])
G[Y[i][1]].add(Y[i+1][1])
G[X[i+1][1]].add(X[i][1])
G[Y[i+1][1]].add(Y[i][1])
node_list = [UnionFindNode(i) for i in range(N+1)]
Es = sorted(Es, key=lambda x:x[1])
r = 0
for (x, y), c in Es:
if node_list[x].find() == node_list[y].find():
continue
r += c
node_list[x].unite(node_list[y])
print(r)
| class UnionFindNode:
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.rank_ = 1
self.member_num_ = 1
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
root = self.root()
return root.group_id_
def rank(self):
root = self.root()
return root.rank_
def unite(self, unite_node):
root = self.root()
unite_root = unite_node.root()
if root.group_id_ != unite_root.group_id_:
if root.rank() > unite_root.rank():
n_root, child = root, unite_root
else:
n_root, child = unite_root, root
child.parent_ = n_root
n_root.rank_ = max(n_root.rank_, child.rank_ + 1)
n_root.member_num_ = n_root.member_num_ + child.member_num_
N, = list(map(int, input().split()))
X,Y = [],[]
for i in range(1, N+1):
x, y = list(map(int, input().split()))
X.append((x,i))
Y.append((y,i))
X = sorted(X, key=lambda x:x[0])
Y = sorted(Y, key=lambda x:x[0])
Es = set()
for i in range(N-1):
Es.add((tuple(sorted([X[i][1], X[i+1][1]])), abs(X[i][0]-X[i+1][0])))
Es.add((tuple(sorted([Y[i][1], Y[i+1][1]])), abs(Y[i][0]-Y[i+1][0])))
node_list = [UnionFindNode(i) for i in range(N+1)]
Es = sorted(Es, key=lambda x:x[1])
r = 0
for (x, y), c in Es:
if node_list[x].find() == node_list[y].find():
continue
r += c
node_list[x].unite(node_list[y])
print(r)
| p03684 |
from itertools import accumulate
MOD = 10 ** 9 + 7
table_len = 2 * 10 ** 5 + 10
fac = [1, 1]
for i in range(2, table_len):
fac.append(fac[-1] * i % MOD)
finv = [0] * table_len
finv[-1] = pow(fac[-1], MOD - 2, MOD)
for i in range(table_len-1, -1, -1):
finv[i-1] = finv[i] * i % 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)
dfs_order = []
parent = [0] * (N+1)
root = 1
stack = [root]
while stack:
node = stack.pop()
dfs_order.append(node)
for child in adj[node]:
if child != parent[node]:
parent[child] = node
stack.append(child)
dp1_size = [1] * (N+1)
for node in reversed(dfs_order):
for child in adj[node]:
if child != parent[node]:
dp1_size[node] += dp1_size[child]
dp2_size = [0] * (N+1)
for node in dfs_order:
around = [dp1_size[next_node] if next_node != parent[node] else dp2_size[node] for next_node in adj[node]]
from_left = [0] + list(accumulate(around))[:-1]
from_right = list(accumulate(reversed(around)))[-2::-1] + [0]
without = [l + r for l, r in zip(from_left, from_right)]
for next_node, value in zip(adj[node], without):
if next_node != parent[node]:
dp2_size[next_node] += value + 1
dp1 = [1] * (N+1)
for node in reversed(dfs_order):
s = 0
for child in adj[node]:
if child != parent[node]:
s += dp1_size[child]
dp1[node] *= dp1[child]
dp1[node] %= MOD
dp1[node] *= finv[dp1_size[child]]
dp1[node] %= MOD
dp1[node] *= fac[s]
dp1[node] %= MOD
def func(t1, t2):
size1, value1 = t1
size2, value2 = t2
size = size1 + size2
comb = fac[size] * finv[size1] * finv[size2] % MOD
value = comb * value1 * value2 % MOD
return (size, value)
dp2 = [1] * (N+1)
for node in dfs_order:
around_size = [dp1_size[next_node] if next_node != parent[node] else dp2_size[node] for next_node in adj[node]]
around = [dp1[next_node] if next_node != parent[node] else dp2[node] for next_node in adj[node]]
from_left = [(0, 1)] + list(accumulate(list(zip(around_size, around)), func))[:-1]
from_right = list(accumulate(reversed(list(zip(around_size, around))), func))[-2::-1] + [(0, 1)]
without = [func(l, r) for l, r in zip(from_left, from_right)]
for next_node, (_, value) in zip(adj[node], without):
if next_node != parent[node]:
dp2[next_node] = value
for size1, val1, size2, val2 in zip(dp1_size[1:], dp1[1:], dp2_size[1:], dp2[1:]):
print((func((size1 - 1, val1), (size2, val2))[1])) | from itertools import accumulate
MOD = 10 ** 9 + 7
table_len = 2 * 10 ** 5 + 10
fac = [1, 1]
for i in range(2, table_len):
fac.append(fac[-1] * i % MOD)
finv = [0] * table_len
finv[-1] = pow(fac[-1], MOD - 2, MOD)
for i in range(table_len-1, -1, -1):
finv[i-1] = finv[i] * i % 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)
dfs_order = []
parent = [0] * (N+1)
root = 1
stack = [root]
while stack:
node = stack.pop()
dfs_order.append(node)
for child in adj[node]:
if child != parent[node]:
parent[child] = node
stack.append(child)
def func(t1, t2):
size1, value1 = t1
size2, value2 = t2
size = size1 + size2
comb = fac[size] * finv[size1] * finv[size2] % MOD
value = comb * value1 * value2 % MOD
return (size, value)
dp1 = [(0, 1)] * (N+1)
for node in reversed(dfs_order):
for child in adj[node]:
if child != parent[node]:
dp1[node] = func(dp1[node], dp1[child])
dp1[node] = (dp1[node][0] + 1, dp1[node][1])
dp2 = [(0, 1)] * (N+1)
for node in dfs_order:
around = [dp1[next_node] if next_node != parent[node] else dp2[node] for next_node in adj[node]]
from_left = [(0, 1)] + list(accumulate(around, func))[:-1]
from_right = list(accumulate(reversed(around), func))[-2::-1] + [(0, 1)]
without = [func(l, r) for l, r in zip(from_left, from_right)]
for next_node, t in zip(adj[node], without):
if next_node != parent[node]:
dp2[next_node] = (t[0] + 1, t[1])
for t1, t2 in zip(dp1[1:], dp2[1:]):
print((func((t1[0] - 1, t1[1]), t2)[1])) | p02728 |
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 28 22:56:10 2020
"""
import sys
#import numpy as np
sys.setrecursionlimit(10 ** 9)
#def input():
# return sys.stdin.readline()[:-1]
mod = 10**9+7
N = int(eval(input()))
#X, Y = map(int,input().split())
ab = [list(map(int,input().split())) for i in range(N-1)]
fact = [1, 1] # 元テーブル
fact_inv = [1, 1] # 逆元テーブル
tmp_inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N+1):
fact.append((fact[-1] * i) % mod)
tmp_inv.append((-tmp_inv[mod % i] * (mod//i)) % mod)
fact_inv.append((fact_inv[-1] * tmp_inv[-1]) % mod)
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return fact[n] * fact_inv[r] * fact_inv[n-r] % mod
#逆元作成
def inv(a,mod):
return pow(a,mod-2,mod)
graph = [[] for _ in range(N+1)]
for a, b in ab:
graph[a].append(b)
graph[b].append(a)
dp = [1] * (N + 1)
size = [0] * (N + 1)
def dfs(par, v):
for u in graph[v]:
if par == u:
continue
dfs(v, u)
size[v] += size[u]
dp[v] = dp[v] * dp[u] * fact_inv[size[u]] % mod
dp[v] = dp[v] * fact[size[v]] % mod
size[v] += 1
ans = [0] * (N + 1)
def reroot(par, val_par, size_par, v):
ans[v] = val_par * dp[v] * cmb(N-1, size_par, mod) % mod
for u in graph[v]:
if par == u:
continue
val = ans[v] * inv(dp[u] * cmb(N-1, size[u],mod),mod) % mod
reroot(v, val, N - size[u], u)
dfs(-1,1)
reroot(-1,1,0,1)
for i in range(1,N+1):
print((ans[i])) | # -*- coding: utf-8 -*-
"""
Created on Tue Apr 28 22:56:10 2020
"""
import sys
#import numpy as np
sys.setrecursionlimit(10 ** 9)
#def input():
# return sys.stdin.readline()[:-1]
mod = 10**9+7
N = int(eval(input()))
#X, Y = map(int,input().split())
#ab = [list(map(int,input().split())) for i in range(N-1)]
fact = [1, 1] # 元テーブル
fact_inv = [1, 1] # 逆元テーブル
tmp_inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N+1):
fact.append((fact[-1] * i) % mod)
tmp_inv.append((-tmp_inv[mod % i] * (mod//i)) % mod)
fact_inv.append((fact_inv[-1] * tmp_inv[-1]) % mod)
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return fact[n] * fact_inv[r] * fact_inv[n-r] % mod
#逆元作成
def inv(a,mod):
return pow(a,mod-2,mod)
graph = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b = [int(x)-1 for x in input().split()]
graph[a].append(b)
graph[b].append(a)
dp = [1] * (N + 0)
size = [0] * (N + 0)
def dfs(par, v):
for u in graph[v]:
if par == u:
continue
dfs(v, u)
size[v] += size[u]
dp[v] = dp[v] * dp[u] * fact_inv[size[u]] % mod
dp[v] = dp[v] * fact[size[v]] % mod
size[v] += 1
ans = [0] * (N + 0)
def reroot(par, val_par, size_par, v):
ans[v] = val_par * dp[v] * cmb(N-1, size_par, mod) % mod
for u in graph[v]:
if par == u:
continue
val = ans[v] * inv(dp[u] * cmb(N-1, size[u],mod),mod) % mod
reroot(v, val, N - size[u], u)
dfs(-1,1)
reroot(-1,1,0,1)
for i in range(N):
print((ans[i])) | p02728 |
class Factorial():
def __init__(self, n, mod):
self.mod = mod
self.factorial = [0 for _ in range(n + 1)]
self.inv = [0 for _ in range(n + 1)]
self.factorial[0] = 1
self.inv[0] = 1
for i in range(n):
self.factorial[i + 1] = self.factorial[i] * (i + 1) % mod
self.inv[n] = pow(self.factorial[n], mod - 2, mod)
for i in range(n)[::-1]:
self.inv[i] = self.inv[i + 1] * (i + 1) % mod
def fact(self, m):
return self.factorial[m]
def invfact(self, m):
return self.inv[m]
import sys
input = sys.stdin.readline
MOD = 1000000007
N = int(eval(input()))
E = [tuple(map(int, input().split())) for _ in range(N - 1)]
tree = [[] for _ in range(N)]
for e in E:
tree[e[0] - 1].append(e[1] - 1)
tree[e[1] - 1].append(e[0] - 1)
visited = [0 for _ in range(N)]
visited[0] = 1
parent = [None for _ in range(N)]
parent[0] = -1
order = []
order.append(0)
stack = [0]
while stack:
node = stack.pop()
for adj in tree[node]:
if not visited[adj]:
visited[adj] = 1
parent[adj] = node
order.append(adj)
stack.append(adj)
dp = [[1, 1] for _ in range(N)]
cum_l = [[1, 0] for _ in range(N)]
cum_r = [[1, 0] for _ in range(N)]
F = Factorial(N + 1, MOD)
for node in order[::-1]:
dp_node = [1, 1]
for adj in tree[node]:
if parent[adj] == node:
cum_l[adj][0] = dp_node[0]
cum_l[adj][1] = dp_node[1]
dp_node[1] += dp[adj][1]
dp_node[0] *= dp[adj][0]
dp_node[0] *= F.invfact(dp[adj][1])
dp_node[0] *= F.fact(dp_node[1] - 1)
dp_node[0] *= F.invfact(dp_node[1] - dp[adj][1] - 1)
dp_node[0] %= MOD
dp_node = [1, 1]
for adj in tree[node][::-1]:
if parent[adj] == node:
cum_r[adj][0] = dp_node[0]
cum_r[adj][1] = dp_node[1]
dp_node[1] += dp[adj][1]
dp_node[0] *= dp[adj][0]
dp_node[0] *= F.invfact(dp[adj][1])
dp_node[0] *= F.fact(dp_node[1] - 1)
dp_node[0] *= F.invfact(dp_node[1] - dp[adj][1] - 1)
dp_node[0] %= MOD
dp[node][0] = dp_node[0]
dp[node][1] = dp_node[1]
dp_inv = [[1, 0] for _ in range(N)]
for node in order:
if node == 0:
continue
merged = [1, 0]
merged[1] = cum_l[node][1] + cum_r[node][1] - 1
merged[0] *= cum_l[node][0] * F.invfact(cum_l[node][1] - 1)
merged[0] *= cum_r[node][0] * F.invfact(cum_r[node][1] - 1)
merged[0] *= F.fact(merged[1] - 1)
merged[0] %= MOD
par = parent[node]
dp_inv[node][0] = merged[0]
dp_inv[node][1] = merged[1]
dp_inv[node][1] += dp_inv[par][1]
dp_inv[node][0] *= dp_inv[par][0]
dp_inv[node][0] *= F.invfact(dp_inv[par][1])
dp_inv[node][0] *= F.fact(dp_inv[node][1] - 1)
dp_inv[node][0] *= F.invfact(dp_inv[node][1] - dp_inv[par][1] - 1)
dp_inv[node][0] %= MOD
dp_node = [1, 1]
dp_node[0] = dp[node][0]
dp_node[1] = dp[node][1]
dp_node[1] += dp_inv[node][1]
dp_node[0] *= dp_inv[node][0]
dp_node[0] *= F.invfact(dp_inv[node][1])
dp_node[0] *= F.fact(dp_node[1] - 1)
dp_node[0] *= F.invfact(dp_node[1] - dp_inv[node][1] - 1)
dp_node[0] %= MOD
dp[node][0] = dp_node[0]
dp[node][1] = dp_node[1]
res = []
for i in range(N):
res.append(dp[i][0])
print(('\n'.join(map(str, res)))) | class Tree():
def __init__(self, n, edge):
self.n = n
self.tree = [[] for _ in range(n)]
for e in edge:
self.tree[e[0] - 1].append(e[1] - 1)
self.tree[e[1] - 1].append(e[0] - 1)
def setroot(self, root):
self.root = root
self.parent = [None for _ in range(self.n)]
self.parent[root] = -1
self.depth = [None for _ in range(self.n)]
self.depth[root] = 0
self.order = []
self.order.append(root)
stack = [root]
while stack:
node = stack.pop()
for adj in self.tree[node]:
if self.parent[adj] is None:
self.parent[adj] = node
self.depth[adj] = self.depth[node] + 1
self.order.append(adj)
stack.append(adj)
def rerooting(self, func, merge, ti, ei):
dp = [ti for _ in range(self.n)]
lt = [ei for _ in range(self.n)]
rt = [ei for _ in range(self.n)]
inv = [ei for _ in range(self.n)]
self.setroot(0)
for node in self.order[::-1]:
tmp = ti
for adj in self.tree[node]:
if self.parent[adj] == node:
lt[adj] = tmp
tmp = func(tmp, dp[adj])
tmp = ti
for adj in self.tree[node][::-1]:
if self.parent[adj] == node:
rt[adj] = tmp
tmp = func(tmp, dp[adj])
dp[node] = tmp
for node in self.order:
if node == 0:
continue
merged = merge(lt[node], rt[node])
par = self.parent[node]
inv[node] = func(merged, inv[par])
dp[node] = func(dp[node], inv[node])
return dp
class Factorial():
def __init__(self, n, mod):
self.mod = mod
self.factorial = [0 for _ in range(n + 1)]
self.inv = [0 for _ in range(n + 1)]
self.factorial[0] = 1
self.inv[0] = 1
for i in range(n):
self.factorial[i + 1] = self.factorial[i] * (i + 1) % mod
self.inv[n] = pow(self.factorial[n], mod - 2, mod)
for i in range(n)[::-1]:
self.inv[i] = self.inv[i + 1] * (i + 1) % mod
def fact(self, m):
return self.factorial[m]
def invfact(self, m):
return self.inv[m]
import sys
input = sys.stdin.readline
MOD = 1000000007
N = int(eval(input()))
E = [tuple(map(int, input().split())) for _ in range(N - 1)]
T = Tree(N, E)
F = Factorial(N + 1, MOD)
def func(node, adj):
size = node[1] + adj[1]
count = node[0] * adj[0] * F.invfact(adj[1]) * F.fact(size - 1) * F.invfact(node[1] - 1)
count %= MOD
return count, size
def merge(lt, rt):
size = lt[1] + rt[1] - 1
count = lt[0] * rt[0] * F.invfact(lt[1] - 1) * F.invfact(rt[1] - 1) * F.fact(size - 1)
count %= MOD
return count, size
ti = (1, 1)
ei = (1, 0)
D = T.rerooting(func, merge, ti, ei)
res = []
for i in range(N):
res.append(D[i][0])
print(('\n'.join(map(str, res)))) | p02728 |
n = int(eval(input())); arr = [list(map(int,input().split())) for _ in range(n-1)]
graph = [[] for _ in range(n)]
for a,b in arr:
graph[a-1].append(b-1); graph[b-1].append(a-1)
mod = 10**9+7
fac = [1]*(n+1)
inv = [1]*(n+1)
ifac = [1]*(n+1)
for i in range(2,n+1):
fac[i] = fac[i-1] * i % mod
inv[i] = (- (mod//i)*inv[(mod%i)]) % mod
ifac[i] = ifac[i-1] * inv[i] % mod
parents = [-1]*n
children = [[] for _ in range(n)]
orders = []
stack = [0]
flags = [True] * n; flags[0] = False
while stack:
tmp = stack.pop()
orders.append(tmp)
for node in graph[tmp]:
if flags[node]:
flags[node] = False
children[tmp].append(node)
stack.append(node)
parents[node] = tmp
size = [1] * (n+1)
dp = [1] * (n+1)
for child in orders[::-1]:
parent = parents[child]
size[parent] += size[child]
dp[child] = dp[child] * fac[size[child]-1] % mod
dp[parent] = dp[parent] * dp[child] * ifac[size[child]] % mod
_ = size.pop();_ = dp.pop()
size2 = [n-i+1 for i in size]
dp2 = [1] * n; dp2[0] = dp[0]
for parent in orders[1:]:
child = parents[parent]
dp2[parent] = dp2[parent] * size[parent] * dp2[child] * inv[size2[parent]-1] % mod
for i in range(n):
print((dp2[i])) | n = int(eval(input())); arr = [list(map(int,input().split())) for _ in range(n-1)]
graph = [[] for _ in range(n)]
for a,b in arr:
graph[a-1].append(b-1); graph[b-1].append(a-1)
mod = 10**9+7
fac = [1]*(n+1)
inv = [1]*(n+1)
ifac = [1]*(n+1)
for i in range(2,n+1):
fac[i] = fac[i-1] * i % mod
inv[i] = (- (mod//i)*inv[(mod%i)]) % mod
ifac[i] = ifac[i-1] * inv[i] % mod
parents = [-1]*n
children = [[] for _ in range(n)]
orders = []
stack = [0]
flags = [True] * n; flags[0] = False
while stack:
tmp = stack.pop()
orders.append(tmp)
for node in graph[tmp]:
if flags[node]:
flags[node] = False
children[tmp].append(node)
stack.append(node)
parents[node] = tmp
size = [1] * n
dp = [1] * n
for parent in orders[::-1]:
for child in children[parent]:
size[parent] += size[child]
dp[parent] = dp[parent] * dp[child] * ifac[size[child]] % mod
dp[parent] = dp[parent] * fac[size[parent]-1] % mod
size2 = [n-i+1 for i in size]
dp2 = [1] * n; dp2[0] = dp[0]
for parent in orders[1:]:
child = parents[parent]
dp2[parent] = dp2[parent] * size[parent] * dp2[child] * inv[size2[parent]-1] % mod
for i in range(n):
print((dp2[i])) | p02728 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(input())
G = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b = map(int, input().split())
G[a].append(b)
G[b].append(a)
mod = 10**9+7
fact = [1] * (N+1)
fact_inv = [1] * (N+1)
inv = lambda x : pow(x, mod-2, mod)
for i in range(1, N+1):
fact[i] = i * fact[i-1] % mod
fact_inv[i] = inv(fact[i])
comb = lambda n, k : fact[n] * fact_inv[k] * fact_inv[n-k] % mod
value = [0] * (N+1)
count = [0] * (N+1)
def dfs1(par, v):
value[v] = 1
count[v] = 0
for u in G[v]:
if par == u:
continue
dfs1(v, u)
count[v] += count[u]
value[v] = value[v] * value[u] * comb(count[v], count[u]) % mod
count[v] += 1
ans = [0] * (N+1)
def dfs2(par, val_par, cnt_par, v):
val = val_par * value[v] * comb(N-1, cnt_par) % mod
ans[v] = val
for u in G[v]:
if par == u:
continue
val2 = val * inv(value[u]) * inv(comb(N-1, count[u])) % mod
dfs2(v, val2, N-count[u], u)
dfs1(0, 1)
dfs2(0, 1, 0, 1)
print(*ans[1:], sep='\n')
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(lambda x : int(x)-1, input().split())
G[a].append(b)
G[b].append(a)
mod = 10**9+7
fact = [1] * N
fact_inv = [1] * N
inv = lambda x : pow(x, mod-2, mod)
for i in range(1, N):
fact[i] = i * fact[i-1] % mod
fact_inv[i] = inv(fact[i])
comb = lambda n, k : fact[n] * fact_inv[k] * fact_inv[n-k] % mod
value = [1] * N
count = [0] * N
def dfs(par, v):
for u in G[v]:
if par == u:
continue
dfs(v, u)
count[v] += count[u]
value[v] = value[v] * value[u] * comb(count[v], count[u]) % mod
count[v] += 1
ans = [0] * N
def reroot(par, val_par, cnt_par, v):
ans[v] = val_par * value[v] * comb(N-1, cnt_par) % mod
for u in G[v]:
if par == u:
continue
val = ans[v] * inv(value[u] * comb(N-1, count[u])) % mod
reroot(v, val, N-count[u], u)
dfs(-1, 0)
reroot(-1, 1, 0, 0)
print(*ans, sep='\n')
| p02728 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(lambda x : int(x)-1, input().split())
G[a].append(b)
G[b].append(a)
mod = 10**9+7
fact = [1] * N
fact_inv = [1] * N
inv = lambda x : pow(x, mod-2, mod)
for i in range(1, N):
fact[i] = i * fact[i-1] % mod
fact_inv[i] = inv(fact[i])
comb = lambda n, k : fact[n] * fact_inv[k] * fact_inv[n-k] % mod
value = [1] * N
count = [0] * N
def dfs(par, v):
for u in G[v]:
if par == u:
continue
dfs(v, u)
count[v] += count[u]
value[v] = value[v] * value[u] * comb(count[v], count[u]) % mod
count[v] += 1
ans = [0] * N
def reroot(par, val_par, cnt_par, v):
ans[v] = val_par * value[v] * comb(N-1, cnt_par) % mod
for u in G[v]:
if par == u:
continue
val = ans[v] * inv(value[u] * comb(N-1, count[u])) % mod
reroot(v, val, N-count[u], u)
dfs(-1, 0)
reroot(-1, 1, 0, 0)
print(*ans, sep='\n')
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(lambda x : int(x)-1, input().split())
G[a].append(b)
G[b].append(a)
mod = 10**9+7
fact = [1] * N
fact_inv = [1] * N
for i in range(1, N):
fact[i] = i * fact[i-1] % mod
inv = lambda x : pow(x, mod-2, mod)
fact_inv[N-1] = inv(fact[N-1])
for i in range(1, N)[::-1]:
fact_inv[i-1] = i * fact_inv[i] % mod
comb = lambda n, k : fact[n] * fact_inv[k] * fact_inv[n-k] % mod
dp = [1] * N
size = [0] * N
def dfs(par, v):
for u in G[v]:
if par == u:
continue
dfs(v, u)
size[v] += size[u]
dp[v] = dp[v] * dp[u] * fact_inv[size[u]] % mod
dp[v] = dp[v] * fact[size[v]] % mod
size[v] += 1
ans = [0] * N
def reroot(par, val_par, size_par, v):
ans[v] = val_par * dp[v] * comb(N-1, size_par) % mod
for u in G[v]:
if par == u:
continue
val = ans[v] * inv(dp[u] * comb(N-1, size[u])) % mod
reroot(v, val, N-size[u], u)
dfs(-1, 0)
reroot(-1, 1, 0, 0)
print(*ans, sep='\n')
| p02728 |
#ABC160F
import sys
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.buffer.readline()[:-1]
MOD = 10**9+7
n = int(eval(input()))
con = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
con[a-1].append(b-1)
con[b-1].append(a-1)
stair = [1] #階乗MOD
stairr = [1] #階乗逆数MOD
for i in range(n):
stair.append((stair[i] * (i+1)) % MOD)
stairr.append(pow((stair[i] * (i+1)) % MOD, MOD-2, MOD))
cnt = [1 for _ in range(n)]
des_size = [1 for _ in range(n)]
des_case = [1 for _ in range(n)]
def dfs1(v, u):
totalsize = 1 #v自身も含んだsizeであることに注意
totalcase = 1
for w in con[v]:
if w == u:
continue
dfs1(w, v)
totalsize += des_size[w]
totalcase = (totalcase * des_case[w] * stairr[des_size[w]]) % MOD
totalcase = (totalcase * stair[totalsize-1]) % MOD
des_size[v] = totalsize
des_case[v] = totalcase
#print(v, u, totalsize, totalcase)
#print(des_size)
#print(des_case)
return
dfs1(0, -1)
#print(des_size)
#print(des_case)
asc_size = [1 for _ in range(n)]
asc_case = [1 for _ in range(n)]
def dfs2(v, u):
if u == -1:
for w in con[v]:
if w == u:
continue
dfs2(w, v)
return
asc_size[v] = n - des_size[v] + 1
x0 = des_size[u]
y0 = des_case[u]
x1 = des_size[v]
y1 = des_case[v]
x2 = asc_size[u]
y2 = asc_case[u]
p = (y0 * y2 * stair[x1] * stair[x0+x2-x1-2]) % MOD
q = (stairr[x0-1] * stairr[x2-1] * pow(y1, MOD-2, MOD)) % MOD
asc_case[v] = (p*q) % MOD
#print(v, u, asc_size, asc_case, p, q)
for w in con[v]:
if w == u:
continue
dfs2(w, v)
return
dfs2(0, -1)
#print(asc_size)
#print(asc_case)
for i in range(n):
r = stair[des_size[i] + asc_size[i] -2]
s = (stairr[des_size[i]-1] * stairr[asc_size[i]-1]) % MOD
t = (des_case[i] * asc_case[i]) % MOD
ans = (r * s * t) % MOD
print(ans) | #ABC160F
import sys
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.buffer.readline()[:-1]
MOD = 10**9+7
n = int(eval(input()))
con = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
con[a-1].append(b-1)
con[b-1].append(a-1)
stair = [1] #階乗MOD
stairr = [1] #階乗逆数MOD
for i in range(n):
stair.append((stair[i] * (i+1)) % MOD)
stairr.append(pow((stair[i] * (i+1)) % MOD, MOD-2, MOD))
cnt = [1 for _ in range(n)]
des_size = [1 for _ in range(n)]
des_case = [1 for _ in range(n)]
def dfs1(v, u):
totalsize = 1 #v自身も含んだsizeであることに注意
totalcase = 1
for w in con[v]:
if w == u:
continue
dfs1(w, v)
totalsize += des_size[w]
totalcase = (totalcase * des_case[w] * stairr[des_size[w]]) % MOD
totalcase = (totalcase * stair[totalsize-1]) % MOD
des_size[v] = totalsize
des_case[v] = totalcase
#print(v, u, totalsize, totalcase)
#print(des_size)
#print(des_case)
return
dfs1(0, -1)
#print(des_size)
#print(des_case)
asc_size = [1 for _ in range(n)]
asc_case = [1 for _ in range(n)]
def dfs2(v, u):
if u == -1:
for w in con[v]:
if w == u:
continue
dfs2(w, v)
return
asc_size[v] = n - des_size[v] + 1
x0 = des_size[u]
y0 = des_case[u]
x1 = des_size[v]
y1 = des_case[v]
x2 = asc_size[u]
y2 = asc_case[u]
p = (y0 * y2 * stair[x1] * stair[x0+x2-x1-2]) % MOD
q = (stairr[x0-1] * stairr[x2-1] * pow(y1, MOD-2, MOD)) % MOD
asc_case[v] = (p*q) % MOD
#print(v, u, asc_size, asc_case, p, q)
for w in con[v]:
if w == u:
continue
dfs2(w, v)
return
dfs2(0, -1)
#print(asc_size)
#print(asc_case)
for i in range(n):
r = stair[des_size[i] + asc_size[i] -2]
s = (stairr[des_size[i]-1] * stairr[asc_size[i]-1]) % MOD
t = (des_case[i] * asc_case[i]) % MOD
print(((r * s * t) % MOD)) | p02728 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].append(b)
g[b].append(a)
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
# topological sort
s = []
s.append(0)
parent = [-1]*n
order = []
while s:
v = s.pop()
order.append(v)
for u in g[v]:
if u == parent[v]:
continue
parent[u] = v
s.append(u)
dp = [1]*n
c = [0]*n
order.reverse()
for v in order:
dp[v] *= g1[c[v]]
dp[v] %= mod
c[v] += 1
if parent[v] == -1:
continue
c[parent[v]] += c[v]
dp[parent[v]] *= (dp[v]*g2[c[v]])
dp[parent[v]] %= mod
order.reverse()
ans = [0]*n
for v in order:
ans[v] = dp[v]
for u in g[v]:
if u == parent[v]:
continue
dp[u] *= ans[v]*g2[c[v]-1]*g1[c[v]-1-c[u]]*g1[c[u]]*pow(dp[u],(mod-2),mod)
dp[u] *= g2[c[u]-1]
dp[u] *= g1[c[v]-1]
dp[u] *= g2[c[v]-c[u]]
dp[u] %= mod
c[u] = c[v]
for i in range(n):
print((ans[i]%mod))
| import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].append(b)
g[b].append(a)
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
# topological sort
s = []
s.append(0)
parent = [-1]*n
order = []
while s:
v = s.pop()
order.append(v)
for u in g[v]:
if u == parent[v]:
continue
parent[u] = v
s.append(u)
dp = [1]*n
c = [0]*n
order.reverse()
for v in order:
dp[v] *= g1[c[v]]
dp[v] %= mod
c[v] += 1
if parent[v] == -1:
continue
c[parent[v]] += c[v]
dp[parent[v]] *= (dp[v]*g2[c[v]])
dp[parent[v]] %= mod
order.reverse()
ans = [0]*n
for v in order:
ans[v] = dp[v]
for u in g[v]:
if u == parent[v]:
continue
dp[u] *= ans[v]*g2[c[v]-1]*g1[c[v]-1-c[u]]*g1[c[u]]*pow(dp[u],(mod-2),mod)
dp[u] *= g2[c[u]-1]
dp[u] *= g1[c[v]-1]
dp[u] *= g2[c[v]-c[u]]
dp[u] %= mod
c[u] = c[v]
for i in range(n):
print((ans[i]%mod))
if __name__ == '__main__':
main() | p02728 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9+7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def dfs_1(s,p): #部分木のサイズを数えるdfs
par[s] = p
for v in edges[s]:
if v == p:
continue
size[s] += dfs_1(v,s)
return size[s]
def dfs_2(s,p): #1を根としたときに進む向きのdp計算用dfs
dp1[s] = fact[size[s]-1]
for v in edges[s]:
if v == p:
continue
dp1[s] *= dfs_2(v,s)
dp1[s] %= mod
dp1[s] *= pow(fact[size[v]], mod-2, mod)
dp1[s] %= mod
return dp1[s]
def comb(n,r):
return fact[n]*pow(fact[r],mod-2,mod)*pow(fact[n-r],mod-2,mod) % mod
def bfs(s): #dp1と逆向きに進むdp計算用bfs
que = deque()
que.append((s,-1))
while que:
v,p = que.popleft()
if v == 0:
dp2[v] = dp1[v]
else:
inv = dp2[p]*pow(dp1[v],mod-2,mod)*pow(comb(n-1,size[v]),mod-2,mod)
inv %= mod
dp2[v] = dp1[v]*inv*comb(n-1,size[v]-1)
dp2[v] %= mod
for u in edges[v]:
if u == p:
continue
que.append((u,v))
n = I()
fact = [1]*(n+1)
par = [None]*n
for i in range(1,n+1):
fact[i] = i*fact[i-1]
fact[i] %= mod
edges = [[] for _ in range(n)]
size = [1]*n
dp1 = [0]*n #1を根としたときに進む向きのdp
for _ in range(n-1):
a,b = LI()
edges[a-1].append(b-1)
edges[b-1].append(a-1)
dfs_1(0,-1)
dfs_2(0,-1)
dp2 = [0]*n
bfs(0)
for i in dp2:
print(i)
| #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9+7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def dfs_1(s,p): #部分木のサイズを数えるdfs
par[s] = p
for v in edges[s]:
if v == p:
continue
size[s] += dfs_1(v,s)
return size[s]
def dfs_2(s,p): #1を根としたときに進む向きのdp計算用dfs
dp1[s] = fact[size[s]-1]
for v in edges[s]:
if v == p:
continue
dp1[s] *= dfs_2(v,s)
dp1[s] %= mod
dp1[s] *= pow(fact[size[v]], mod-2, mod)
dp1[s] %= mod
return dp1[s]
def comb(n,r):
return fact[n]*pow(fact[r],mod-2,mod)*pow(fact[n-r],mod-2,mod) % mod
def bfs(s): #dp1と逆向きに進むdp計算用bfs
que = deque()
que.append((s,-1))
while que:
v,p = que.popleft()
if v == 0:
dp2[v] = dp1[v]
else:
inv = (dp2[p]*pow((dp1[v]*comb(n-1,size[v]))%mod,mod-2,mod)) % mod
dp2[v] = (dp1[v]*inv*comb(n-1,size[v]-1)) % mod
for u in edges[v]:
if u == p:
continue
que.append((u,v))
n = I()
fact = [1]*(n+1)
par = [None]*n
for i in range(1,n+1):
fact[i] = i*fact[i-1]
fact[i] %= mod
edges = [[] for _ in range(n)]
size = [1]*n
dp1 = [0]*n #1を根としたときに進む向きのdp
for _ in range(n-1):
a,b = LI()
edges[a-1].append(b-1)
edges[b-1].append(a-1)
dfs_1(0,-1)
dfs_2(0,-1)
dp2 = [0]*n
bfs(0)
for i in dp2:
print(i)
| p02728 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9+7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def dfs_1(s,p): #部分木のサイズを数えるdfs
par[s] = p
for v in edges[s]:
if v == p:
continue
size[s] += dfs_1(v,s)
return size[s]
def dfs_2(s,p): #1を根としたときに進む向きのdp計算用dfs
dp1[s] = fact[size[s]-1]
for v in edges[s]:
if v == p:
continue
dp1[s] *= dfs_2(v,s)
dp1[s] %= mod
dp1[s] *= pow(fact[size[v]], mod-2, mod)
dp1[s] %= mod
return dp1[s]
def comb(n,r):
return fact[n]*pow(fact[r],mod-2,mod)*pow(fact[n-r],mod-2,mod) % mod
def bfs(s):
que = deque()
que.append((s,-1))
while que:
v,p = que.popleft()
if v == 0:
dp2[v] = dp1[v]
else:
inv = (dp2[p]*pow((dp1[v]*comb(n-1,size[v]))%mod,mod-2,mod)) % mod
dp2[v] = (dp1[v]*inv*comb(n-1,size[v]-1)) % mod
for u in edges[v]:
if u == p:
continue
que.append((u,v))
n = I()
fact = [1]*(n+1)
par = [None]*n
for i in range(1,n+1):
fact[i] = i*fact[i-1]
fact[i] %= mod
edges = [[] for _ in range(n)]
size = [1]*n
dp1 = [0]*n #1を根としたときに進む向きのdp
for _ in range(n-1):
a,b = LI()
edges[a-1].append(b-1)
edges[b-1].append(a-1)
dfs_1(0,-1)
dfs_2(0,-1)
dp2 = [0]*n
bfs(0)
for i in dp2:
print(i)
| #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9+7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def dfs_1(s,p): #部分木のサイズを数えるdfs
par[s] = p
for v in edges[s]:
if v == p:
continue
size[s] += dfs_1(v,s)
return size[s]
def dfs_2(s,p): #1を根としたときに進む向きのdp計算用dfs
dp1[s] = fact[size[s]-1]
for v in edges[s]:
if v == p:
continue
dp1[s] = (dp1[s]*dfs_2(v,s))%mod
dp1[s] = (dp1[s]*pow(fact[size[v]], mod-2, mod))%mod
return dp1[s]
def comb(n,r):
return fact[n]*pow(fact[r],mod-2,mod)*pow(fact[n-r],mod-2,mod) % mod
def bfs(s):
que = deque()
que.append((s,-1))
while que:
v,p = que.popleft()
if v == 0:
dp2[v] = dp1[v]
else:
inv = (dp2[p]*pow((dp1[v]*comb(n-1,size[v]))%mod,mod-2,mod)) % mod
dp2[v] = (dp1[v]*inv*comb(n-1,size[v]-1)) % mod
for u in edges[v]:
if u == p:
continue
que.append((u,v))
n = I()
fact = [1]*(n+1)
par = [None]*n
for i in range(1,n+1):
fact[i] = i*fact[i-1]
fact[i] %= mod
edges = [[] for _ in range(n)]
size = [1]*n
dp1 = [0]*n #1を根としたときに進む向きのdp
for _ in range(n-1):
a,b = LI()
edges[a-1].append(b-1)
edges[b-1].append(a-1)
dfs_1(0,-1)
dfs_2(0,-1)
dp2 = [0]*n
bfs(0)
for i in dp2:
print(i)
| p02728 |
import sys
sys.setrecursionlimit(10**7)
MOD = 10**9+7
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n-1):
a, b = map(int, input().split())
a -= 1; b -= 1
g[a].append(b)
g[b].append(a)
lim = 10**6
fact = [1, 1] + [0] * (lim-1)
fact_inv = [1, 1] + [0] * (lim-1)
inv = [0, 1] + [0] * (lim-1)
for i in range(2, lim+1):
fact[i] = fact[i-1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD
fact_inv[i] = fact_inv[i-1] * inv[i] % MOD
def comb(n, m):
if n < m or n < 0 or m < 0: return 0
return fact[n] * (fact_inv[m] * fact_inv[n-m] % MOD) % MOD
def icomb(n, m):
if n < m or n < 0 or m < 0: return 0
return fact_inv[n] * (fact[m] * fact[n-m] % MOD) % MOD
dp = [1] * n
size = [0] * n
def dfs(v, pv):
for nv in g[v]:
if nv == pv: continue
dfs(nv, v)
ns = size[nv]+1
size[v] += ns
dp[v] *= dp[nv] * comb(size[v], ns) % MOD
dp[v] %= MOD
def dfs2(v, pv):
for nv in g[v]:
if nv == pv: continue
d, sz = dp[v], size[v]
d *= pow(dp[nv], MOD-2, MOD) * icomb(sz, size[nv]+1) % MOD
d %= MOD
sz -= size[nv]+1
size[nv] += sz+1
dp[nv] *= d * comb(size[nv], sz+1) % MOD
dp[nv] %= MOD
dfs2(nv, v)
dfs(0, -1)
dfs2(0, -1)
print(*dp, sep="\n")
| import sys
sys.setrecursionlimit(10**7)
input = lambda: sys.stdin.readline().rstrip()
MOD = 10**9+7
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n-1):
a, b = map(int, input().split())
a -= 1; b -= 1
g[a].append(b)
g[b].append(a)
lim = 10**5*2
fact = [1, 1] + [0] * (lim-1)
fact_inv = [1, 1] + [0] * (lim-1)
inv = [0, 1] + [0] * (lim-1)
for i in range(2, lim+1):
fact[i] = fact[i-1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD
fact_inv[i] = fact_inv[i-1] * inv[i] % MOD
def comb(n, m):
if n < m or n < 0 or m < 0: return 0
return fact[n] * (fact_inv[m] * fact_inv[n-m] % MOD) % MOD
def icomb(n, m):
if n < m or n < 0 or m < 0: return 0
return fact_inv[n] * (fact[m] * fact[n-m] % MOD) % MOD
dp = [1] * n
size = [0] * n
def dfs(v, pv):
for nv in g[v]:
if nv == pv: continue
dfs(nv, v)
ns = size[nv]+1
size[v] += ns
dp[v] *= dp[nv] * comb(size[v], ns) % MOD
dp[v] %= MOD
def dfs2(v, pv):
for nv in g[v]:
if nv == pv: continue
d, sz = dp[v], size[v]
d *= pow(dp[nv], MOD-2, MOD) * icomb(sz, size[nv]+1) % MOD
d %= MOD
sz -= size[nv]+1
size[nv] += sz+1
dp[nv] *= d * comb(size[nv], sz+1) % MOD
dp[nv] %= MOD
dfs2(nv, v)
dfs(0, -1)
dfs2(0, -1)
print(*dp, sep="\n")
| p02728 |
import sys
sys.setrecursionlimit(10**7)
def modinv(a,m=10**9+7):
if a==0: return 1
b=m
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return lastx % m
def cur(p):
for x in neighbor[p]:
if x==par[p]: continue
par[x]=p
descend[p]+=cur(x)
return descend[p]
def cur2(p):
for x in neighbor[p]:
if x==par[p]: continue
ans[x]=ans[p]*descend[x]*modinv(n-descend[x])%mod
cur2(x)
mod=10**9+7
n=int(eval(input()))
neighbor=[[] for _ in range(n+1)]
descend=[1]*(n+1)
par=[0]*(n+1)
for _ in range(n-1):
a,b=list(map(int,input().split()))
neighbor[a].append(b)
neighbor[b].append(a)
cur(1)
ans=[1]*(n+1)
ans1=1
for i in range(1,n+1):
ans1=ans1*i*modinv(descend[i])%mod
ans[1]=ans1
cur2(1)
for i in range(1,n+1):
print((ans[i]))
| import sys
sys.setrecursionlimit(10**7)
def modinv(a,m=10**9+7):
if a==0: return 1
b=m
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return lastx % m
def cur(p):
for x in neighbor[p]:
if x==par[p]: continue
else:
par[x]=p
descend[p]+=cur(x)
neighbor[p].remove(par[p])
return descend[p]
def cur2(p):
for x in neighbor[p]:
ans[x]=ans[p]*descend[x]*modinv(n-descend[x])%mod
cur2(x)
mod=10**9+7
n=int(eval(input()))
neighbor=[[] for _ in range(n+1)]
descend=[1]*(n+1)
par=[0]*(n+1)
for _ in range(n-1):
a,b=list(map(int,input().split()))
neighbor[a].append(b)
neighbor[b].append(a)
neighbor[1].append(0)
cur(1)
ans=[1]*(n+1)
ans1=1
for i in range(1,n+1):
ans1=ans1*i*modinv(descend[i])%mod
ans[1]=ans1
cur2(1)
for i in range(1,n+1):
print((ans[i]))
| p02728 |
import sys
from copy import deepcopy
from functools import lru_cache
sys.setrecursionlimit(10**6)
def main():
# input and preparation
F = 2*10**5
mod = 10**9+7
fact = [1]*F
inv = [1]*F
for i in range(2,F):
fact[i]=(fact[i-1]*i)%mod
inv[F-1]=pow(fact[F-1],mod-2,mod)
for i in range(F-2,1,-1):
inv[i] = (inv[i+1]*(i+1))%mod
n=int(eval(input()))
node=[[] for i in range(n)]
for i in range(n-1):
a,b=list(map(int,input().split()))
node[a-1].append(b-1)
node[b-1].append(a-1)
memo=[[0]*n for i in range(n)]
# node i is list of [child,size,comb] connected i
# return [size,comb]
def deep(i,parent):
if len(node[i])==1 and parent!=-1:
return [1,1]
mysize=0
mycomb=1
for j in node[i]:
if j!=parent:
size,comb=memo[j][i] if memo[j][i] != 0 else deep(j,i)
mysize+=size
mycomb=(mycomb*comb)%mod
mycomb=(mycomb*inv[size])%mod
mycomb=(mycomb*fact[mysize])%mod
if parent!=-1:
memo[i][parent]=(mysize+1,mycomb)
return (mysize+1,mycomb)
for i in range(n):
print((deep(i,-1)[1]))
main()
| import sys
from copy import deepcopy
from functools import lru_cache
sys.setrecursionlimit(10**6)
def main():
#node i is list of [child,size,comb] connected i
#return [size,comb]
@lru_cache(maxsize=1000000)
def deep(i,parent):
if len(node[i])==1 and parent!=-1:
return (1,1)
mysize=0
mycomb=1
for j in node[i]:
if j!=parent:
size,comb=deep(j,i)
mysize+=size
mycomb=(mycomb*comb)%mod
mycomb=(mycomb*inv[size])%mod
mycomb=(mycomb*fact[mysize])%mod
return (mysize+1,mycomb)
F = 2*10**5
mod = 10**9+7
fact = [1]*F
inv = [1]*F
for i in range(2,F):
fact[i]=(fact[i-1]*i)%mod
inv[F-1]=pow(fact[F-1],mod-2,mod)
for i in range(F-2,1,-1):
inv[i] = (inv[i+1]*(i+1))%mod
n=int(eval(input()))
node=[[] for i in range(n)]
for i in range(n-1):
a,b=list(map(int,input().split()))
node[a-1].append(b-1)
node[b-1].append(a-1)
for i in range(n):
print((deep(i,-1)[1]))
main()
| p02728 |
import sys
F = 2*10**5
mod = 10**9+7
fact = [1]*F
inv = [1]*F
for i in range(2,F):
fact[i]=(fact[i-1]*i)%mod
inv[F-1]=pow(fact[F-1],mod-2,mod)
for i in range(F-2,1,-1):
inv[i] = (inv[i+1]*(i+1))%mod
n=int(eval(input()))
neighbers=[[] for i in range(n)]
for i in range(n-1):
a,b=list(map(int,input().split()))
neighbers[a-1].append(b-1)
neighbers[b-1].append(a-1)
stack=[0]
order=[0]
parent=[0]*n
while stack:
node = stack.pop()
for child in neighbers[node]:
if child==parent[node]:
continue
stack.append(child)
order.append(child)
parent[child]=node
# (size,combination)
upinfo=[(0,1)]*n
downinfo=[(0,1)]*n
for node in order[::-1]:
if len(neighbers[node])==1:
downinfo[node]=(1,1)
else:
totalsize=0
totalcomb=1
for child in neighbers[node]:
if child == parent[node]:
continue
size,comb=downinfo[child]
totalsize+=size
totalcomb=(totalcomb*comb)%mod
totalcomb=(totalcomb*inv[size])%mod
totalcomb=(totalcomb*fact[totalsize])%mod
downinfo[node]=(totalsize+1,totalcomb)
for node in order[1:]:
totalsize=0
totalcomb=1
for brother in neighbers[parent[node]]:
if brother == node:
continue
size,comb=upinfo[parent[node]] if brother == parent[parent[node]] else downinfo[brother]
totalsize+=size
totalcomb=(totalcomb*comb)%mod
totalcomb=(totalcomb*inv[size])%mod
totalcomb=(totalcomb*fact[totalsize])%mod
upinfo[node]=(totalsize+1,totalcomb)
for node in range(n):
totalsize=0
totalcomb=1
for child in neighbers[node]:
size,comb=upinfo[node] if child==parent[node] else downinfo[child]
totalsize+=size
totalcomb=(totalcomb*comb)%mod
totalcomb=(totalcomb*inv[size])%mod
totalcomb=(totalcomb*fact[totalsize])%mod
print(totalcomb)
| n=int(input())
F = n+5
mod = 10**9+7
fact = [1]*F
inv = [1]*F
for i in range(2,F):
fact[i]=(fact[i-1]*i)%mod
inv[F-1]=pow(fact[F-1],mod-2,mod)
for i in range(F-2,1,-1):
inv[i] = (inv[i+1]*(i+1))%mod
#invnum[0] cant be used
invnum=[fact[i-1]*inv[i] for i in range(n)]
graph=[[] for i in range(n)]
for i in range(n-1):
a,b=map(int,input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
stack=[0]
order=[0]
parent=[-1]*n
comb=[0]*n
size=[1]*n
# BFS order
while stack:
node = stack.pop()
for neib in graph[node]:
if neib!=parent[node]:
stack.append(neib)
order.append(neib)
parent[neib]=node
#calc size including self
for node in order[n-1:0:-1]:
size[parent[node]]+=size[node]
#calc root comb
comb[0]=fact[n-1]
for node in range(1,n):
comb[0]*=invnum[size[node]]
comb[0]%=mod
#calc all comb
for node in order[1:]:
comb[node]=comb[parent[node]]*size[node]*invnum[n-size[node]]%mod
print(*comb,sep="\n")
| p02728 |
import sys
input = sys.stdin.readline
from collections import deque
class Factorial:
def __init__(self, n, mod):
self.f = [1]
self.mod = mod
for j in range(1, n + 1):
self.f.append(self.f[-1] * j % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for j in range(n, 0, -1):
self.i.append(self.i[-1] * j % mod)
self.i.reverse()
def factorial(self, j):
return self.f[j]
def ifactorial(self, j):
return self.i[j]
def comb(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0
MOD = 10 ** 9 + 7
N = int(eval(input()))
c = Factorial(N + 2, MOD)
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
edge_num = [len(G[i]) for i in range(N + 1)]
que = deque()
check = [0] * (N + 1)
order = []
o_append =order.append
q_pop = que.pop
q_append = que.append
q_append((1, 0))
check[1] = 1
while que:
now = q_pop()
o_append(now)
for next_ in G[now[0]]:
if check[next_] == 0:
q_append((next_, now[0]))
check[next_] = 1
# print (order)
size1 = [0] * (N + 1) #自身を頂点とする部分木のサイズ、木の根は頂点0
dp1 = [1] * (N + 1)
for child, parent in order[::-1]:
dp1[child] *= c.factorial(size1[child])
dp1[child] %= MOD
s = size1[child] + 1
size1[parent] += s
dp1[parent] *= c.ifactorial(s) * dp1[child]
dp1[parent] %= MOD
# print (size1)
# print (dp1)
size2 = [N - 2 - x for x in size1]
dp2 = [1] * (N + 1)
# print (size1)
# print (size2)
for child, parent in order[1:]:
x = dp1[parent]
x *= dp2[parent]
x *= c.ifactorial(size1[parent])
x *= c.factorial(size1[child] + 1)
x *= pow(dp1[child], MOD - 2, MOD) #割り算
x *= c.factorial(size2[child])
x *= c.ifactorial(size2[parent] + 1)
dp2[child] = x % MOD
# print (dp2)
for x1, x2, s1, s2 in zip(dp1[1:], dp2[1:], size1[1:], size2[1:]):
s2 += 1
x = x1 * x2 * c.factorial(s1 + s2) * c.ifactorial(s1) * c.ifactorial(s2) % MOD
print (x) | import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
class Factorial:
def __init__(self, n, mod):
self.f = [1]
self.mod = mod
for j in range(1, n + 1):
self.f.append(self.f[-1] * j % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for j in range(n, 0, -1):
self.i.append(self.i[-1] * j % mod)
self.i.reverse()
def factorial(self, j):
return self.f[j]
def ifactorial(self, j):
return self.i[j]
def comb(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0
N = int(input())
C = Factorial(N + 1, MOD)
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
order = []
order_append = order.append
stack = [(0, -1)]
stack_pop = stack.pop
stack_append = stack.append
while stack:
tmp = stack_pop()
order_append(tmp)
for next_ in G[tmp[0]]:
if next_ == tmp[1]:
continue
stack_append((next_, tmp[0]))
size = [1] * N
dp = [1] * N
# print (order)
for c, p in order[::-1]:
if c == 0:
break
size[p] += size[c]
for c, p in order[::-1]:
dp[c] = (dp[c] * C.factorial(size[c] - 1)) % MOD
if c == 0:
break
# dp[c] = (dp[c] * C.factorial(size[c] - 1)) % MOD
dp[p] = (dp[p] * dp[c] % MOD) * C.ifactorial(size[c]) % MOD
# print (dp)
dp2 = [0] * N
dp2[0] = dp[0]
for c, p in order[1::]:
tmp = (dp2[p] * C.factorial(N - 1 - size[c]) % MOD) * C.factorial(size[c]) % MOD
red = (tmp * C.ifactorial(N - 1) % MOD) * pow(dp[c], MOD - 2, MOD) % MOD
size_red = N - size[c]
tmp = (dp[c] * red % MOD) * C.factorial(N - 1) % MOD
dp2[c] = (tmp * C.ifactorial(size[c] - 1) % MOD) * C.ifactorial(size_red) % MOD
print (*dp2, sep = '\n')
| p02728 |
import sys
input = sys.stdin.readline
class Factorial:
def __init__(self, n, mod):
self.f = [1]
self.mod = mod
for j in range(1, n + 1):
self.f.append(self.f[-1] * j % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for j in range(n, 0, -1):
self.i.append(self.i[-1] * j % mod)
self.i.reverse()
def factorial(self, j):
return self.f[j]
def ifactorial(self, j):
return self.i[j]
def comb(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0
MOD = 10 ** 9 + 7
F = Factorial(2 * 10 ** 5 + 10, MOD)
N = int(eval(input()))
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
root = 1
DAG = []
parent = [-1] * (N + 1)
parent[root] = 0
stack = [root]
while stack:
now_ = stack.pop()
DAG.append(now_)
for next_ in G[now_]:
if parent[next_] == -1:
stack.append(next_)
parent[next_] = now_
# print ('parent', parent)
size1 = [1] * (N + 1)
dp1 = [1] * (N + 1)
for i in DAG[::-1]:
size1[parent[i]] += size1[i]
for i in DAG[::-1]:
dp1[i] *= F.factorial(size1[i] - 1)
dp1[i] %= MOD
dp1[parent[i]] *= (dp1[i] * F.ifactorial(size1[i])) % MOD
dp1[parent[i]] %= MOD
# print (dp1)
# print (size1)
size2 = [1] * (N + 1)
dp2 = [1] * (N + 1)
for i in DAG[::]:
for j in G[i]:
if parent[i] == j:
continue
size2[j] = size2[i] + size1[i] - size1[j]
for i in DAG[1::]:
x = 1
x *= dp1[parent[i]]
x *= F.ifactorial(size1[parent[i]] - 1)
x *= F.factorial(size1[i])
x *= pow(dp1[i], MOD - 2, MOD)
x *= dp2[parent[i]]
x *= F.ifactorial(size2[parent[i]] - 1)
x *= F.factorial(size2[i] - 2)
dp2[i] = x % MOD
# print ('size1', size1)
# print ('size2', size2)
# print ('dp1', dp1)
# print ('dp2', dp2)
# print (G)
fact = F.factorial(N - 1)
for x in range(1, N + 1):
ans = fact * dp1[x] * F.ifactorial(size1[x] - 1) * dp2[x] * F.ifactorial(size2[x] - 1)
print((ans % MOD))
| import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
class Factorial:
def __init__(self, n, mod):
self.f = [1]
self.mod = mod
for j in range(1, n + 1):
self.f.append(self.f[-1] * j % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for j in range(n, 0, -1):
self.i.append(self.i[-1] * j % mod)
self.i.reverse()
def factorial(self, j):
return self.f[j]
def ifactorial(self, j):
return self.i[j]
def comb(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0
N = int(eval(input()))
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
F = Factorial(N + 2, MOD)
root = 1
stack = [root]
check = [False] * (N + 1)
check[root] = True
p = [0] * (N + 1)
DAG = []
while stack:
now_ = stack.pop()
DAG.append(now_)
for next_ in G[now_]:
if check[next_]:
continue
stack.append(next_)
check[next_] = True
p[next_] = now_
size1 = [0] * (N + 1)
dp1 = [1] * (N + 1)
for now_ in DAG[::-1]:
size1[now_] += 1
size1[p[now_]] += size1[now_]
dp1[now_] *= F.factorial(size1[now_] - 1)
dp1[now_] %= MOD
dp1[p[now_]] *= dp1[now_] * F.ifactorial(size1[now_])
dp1[p[now_]] %= MOD
# print (size1)
# print (dp1)
size2 = [N - size1[i] + 1 for i in range(N + 1)]
dp2 = [1] * (N + 1)
for now_ in DAG[1::]:
parent = p[now_]
x = dp1[parent]
x *= F.ifactorial(size1[parent] - 1)
x *= F.factorial(size1[now_])
x *= pow(dp1[now_], MOD - 2, MOD)
x *= dp2[parent]
x *= F.ifactorial(size2[parent] - 1)
x *= F.factorial(size2[now_] - 2)
dp2[now_] = x % MOD
# print (size2)
# print (dp2)
for i in range(1, N + 1):
ans = dp1[i] * F.ifactorial(size1[i] - 1) * dp2[i] * F.ifactorial(size2[i] - 1) * F.factorial(N - 1)
print((ans % MOD))
| p02728 |
def main():
from collections import deque
N = int(eval(input()))
ab = [list(map(int,input().split())) for _ in range(N-1)]
mod = 10**9+7
fact = [1]*(N+1)
fact_inv = [1]*(N+1)
for i in range(1,N+1):
fact[i] = (fact[i-1]*i)%mod
fact_inv[i] = pow(fact[i], mod-2, mod)
g = [deque([]) for _ in range(N+1)]
for a,b in ab:
g[a].append(b)
g[b].append(a)
parents = [0]*(N+1)
q = deque([])
s = deque([1])
while s:
x = s.pop()
q.append(x)
for y in g[x]:
if y==parents[x]:
continue
else:
parents[y] = x
s.append(y)
q = list(q)
size_forward = [0]*(N+1)
dp_forward = [1]*(N+1)
for i in q[::-1]:
p = parents[i]
s = size_forward[i] + 1
size_forward[p] += s
dp_forward[i] *= fact[size_forward[i]]
dp_forward[p] *= dp_forward[i] * fact_inv[s]
dp_forward[p] %= mod
size_back = [N-1-i for i in size_forward]
dp_back = [1]*(N+1)
for i in q[1:]:
p = parents[i]
x = dp_back[p]
x *= fact_inv[size_back[p]]
x *= dp_forward[p]
x *= fact_inv[size_forward[p]]
x *= fact[size_forward[i]+1]
x *= pow(dp_forward[i],mod-2,mod)
x *= fact[size_back[i]-1]
dp_back[i] = x % mod
for a,b,c,d in zip(size_forward[1:], dp_forward[1:], size_back[1:], dp_back[1:]):
ans = b * d * fact[a+c] * fact_inv[a] * fact_inv[c]
ans %= mod
print(ans)
main() | from collections import deque
N = int(eval(input()))
ab = [list(map(int,input().split())) for _ in range(N-1)]
mod = 10**9+7
fact = [1]*(N+1)
fact_inv = [1]*(N+1)
for i in range(1,N+1):
fact[i] = (fact[i-1]*i)%mod
fact_inv[-1] = pow(fact[-1], mod-2, mod)
for i in range(N,0,-1):
fact_inv[i-1] = fact_inv[i] * i % mod
g = [deque([]) for _ in range(N+1)]
for a,b in ab:
g[a].append(b)
g[b].append(a)
parents = [0]*(N+1)
q = deque([])
s = deque([1])
while s:
x = s.pop()
q.append(x)
for y in g[x]:
if y==parents[x]:
continue
else:
parents[y] = x
s.append(y)
q = list(q)
size_forward = [0]*(N+1)
dp_forward = [1]*(N+1)
for i in q[::-1]:
p = parents[i]
s = size_forward[i] + 1
size_forward[p] += s
dp_forward[i] *= fact[size_forward[i]]
dp_forward[p] *= dp_forward[i] * fact_inv[s]
dp_forward[p] %= mod
size_back = [N-1-i for i in size_forward]
dp_back = [1]*(N+1)
for i in q[1:]:
p = parents[i]
x = dp_back[p]
x *= fact_inv[size_back[p]]
x *= dp_forward[p]
x *= fact_inv[size_forward[p]]
x *= fact[size_forward[i]+1]
x *= pow(dp_forward[i],mod-2,mod)
x *= fact[size_back[i]-1]
dp_back[i] = x % mod
for a,b,c,d in zip(size_forward[1:], dp_forward[1:], size_back[1:], dp_back[1:]):
ans = b * d * fact[a+c] * fact_inv[a] * fact_inv[c]
ans %= mod
print(ans) | p02728 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
MOD = 10**9 + 7
N = int(eval(input()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
adjL[a].append(b)
adjL[b].append(a)
def getInvs(n, MOD):
invs = [1] * (n+1)
for x in range(2, n+1):
invs[x] = (-(MOD//x) * invs[MOD%x]) % MOD
return invs
invs = getInvs(N, MOD)
dp = [[] for _ in range(N)]
outdegs = [0] * N
sizes = [0] * N
iPars = [-1] * N
def dfsDP(v, vPar):
outdeg = outdegs[v] = len(adjL[v])
dp[v] = [0] * outdeg
res = 1
sizes[v] = 1
for i, v2 in enumerate(adjL[v]):
if v2 == vPar:
iPars[v] = i
continue
dp[v][i] = dfsDP(v2, v)
res = res * dp[v][i] % MOD
sizes[v] += sizes[v2]
return res * invs[sizes[v]] % MOD
anss = [0] * N
def dfsAns(v, vPar, resPar):
if vPar != -1:
dp[v][iPars[v]] = resPar
outdeg = outdegs[v]
dpL = [1] * (outdeg+1)
for i in range(outdeg):
v2 = adjL[v][i]
dpL[i+1] = dpL[i] * dp[v][i] % MOD
dpR = [1] * (outdeg+1)
for i in reversed(list(range(outdeg))):
v2 = adjL[v][i]
dpR[i] = dpR[i+1] * dp[v][i] % MOD
anss[v] = dpL[-1] * invs[N]
for i, v2 in enumerate(adjL[v]):
if v2 == vPar: continue
dfsAns(v2, v, dpL[i] * dpR[i+1] * invs[N-sizes[v2]] % MOD)
dfsDP(0, -1)
dfsAns(0, -1, 0)
def getFact(n, MOD):
fact = 1
for i in range(1, n+1):
fact = (fact * i) % MOD
return fact
factN = getFact(N, MOD)
for v in range(N):
anss[v] = anss[v] * factN % MOD
print(('\n'.join(map(str, anss))))
solve()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
MOD = 10**9 + 7
N = int(eval(input()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
adjL[a].append(b)
adjL[b].append(a)
def getFacts(n, MOD):
facts = [1] * (n+1)
for x in range(2, n+1):
facts[x] = (facts[x-1] * x) % MOD
return facts
facts = getFacts(N, MOD)
def getInvFacts(n, MOD):
invFacts = [0] * (n+1)
invFacts[n] = pow(facts[n], MOD-2, MOD)
for x in reversed(list(range(n))):
invFacts[x] = (invFacts[x+1] * (x+1)) % MOD
return invFacts
invFacts = getInvFacts(N, MOD)
def getComb(n, k, MOD):
if n < k:
return 0
return facts[n] * invFacts[k] * invFacts[n-k] % MOD
dp = [1] * N
sizes = [0] * N
def dfsDP(v, vPar):
sizes[v] = 0
for v2 in adjL[v]:
if v2 == vPar: continue
dp[v] = dp[v] * dfsDP(v2, v) % MOD
sizes[v] += sizes[v2]
dp[v] = dp[v] * getComb(sizes[v], sizes[v2], MOD) % MOD
sizes[v] += 1
return dp[v]
anss = [0] * N
def dfsAns(v, vPar, resPar):
anss[v] = dp[v] * resPar * getComb(N-1, sizes[v]-1, MOD) % MOD
for v2 in adjL[v]:
if v2 == vPar: continue
coef = dp[v2] * getComb(N-1, sizes[v2], MOD) % MOD
dfsAns(v2, v, anss[v] * pow(coef, MOD-2, MOD) % MOD)
dfsDP(0, -1)
dfsAns(0, -1, 1)
print(('\n'.join(map(str, anss))))
solve()
| p02728 |
import sys
sys.setrecursionlimit(10**7)
MOD = 1000000007
def modpow(a, b):
if b == 0:
return 1
if b % 2 == 0:
d = modpow(a, b / 2)
return (d ** 2) % MOD
d = modpow(a, b - 1)
return (a * d) % MOD
M = 2*10**5 + 10
fact = [1] * M
ifact = [1] * M
for i in range(2, M):
fact[i] = (fact[i - 1] * i) % MOD
ifact[M - 1] = modpow(fact[M - 1], MOD - 2)
for i in range(2, M - 1)[::-1]:
ifact[i] = (ifact[i + 1] * (i + 1)) % MOD
def comb(n, k):
if n < 0 or k > n:
return 0
return (((fact[n] * ifact[k]) % MOD) * ifact[n - k]) % MOD
class DP:
def __init__(self, dp = 1, size = 0):
self.dp = dp
self.size = size
def __add__(self, other):
dp = self.dp
dp *= other.dp
dp %= MOD
size = self.size + other.size
dp *= comb(size, self.size)
dp %= MOD
return DP(dp, size)
def __sub__(self, other):
size = self.size - other.size
dp = self.dp
dp *= modpow(comb(self.size, size), MOD - 2)
dp %= MOD
dp *= modpow(other.dp, MOD - 2)
dp %= MOD
return DP(dp, size)
def addRoot(self):
return DP(self.dp, self.size + 1)
N = int(eval(input()))
e = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = [v - 1 for v in map(int, input().split())]
e[a].append(b)
e[b].append(a)
dp = [DP() for _ in range(N)]
def dfs(v, p = -1):
for c in e[v]:
if c == p:
continue
dfs(c, v)
dp[v] += dp[c].addRoot()
def dfs2(v, p = -1):
for c in e[v]:
if c == p:
continue
d = dp[v] - dp[c].addRoot()
dp[c] += d.addRoot()
dfs2(c, v)
dfs(0)
dfs2(0)
for d in dp:
print((d.dp)) | MOD = 1000000007
M = 2*10**5 + 10
fact = [1] * M
ifact = [1] * M
for i in range(2, M):
fact[i] = fact[i - 1] * i % MOD
ifact[M - 1] = pow(fact[M - 1], MOD - 2, MOD)
for i in range(2, M - 1)[::-1]:
ifact[i] = ifact[i + 1] * (i + 1) % MOD
def comb(n, k):
if n < 0 or k > n:
return 0
return (fact[n] * ifact[k] % MOD) * ifact[n - k] % MOD
class DP:
def __init__(self, dp = 1, size = 0):
self.dp = dp
self.size = size
def __add__(self, other):
dp = self.dp
dp *= other.dp
dp %= MOD
size = self.size + other.size
dp *= comb(size, self.size)
dp %= MOD
return DP(dp, size)
def __sub__(self, other):
size = self.size - other.size
dp = self.dp
dp *= pow(comb(self.size, size), MOD - 2, MOD)
dp %= MOD
dp *= pow(other.dp, MOD - 2, MOD)
dp %= MOD
return DP(dp, size)
def addRoot(self):
return DP(self.dp, self.size + 1)
N = int(eval(input()))
e = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = [v - 1 for v in map(int, input().split())]
e[a].append(b)
e[b].append(a)
order = []
parent = [-1] * N
stack = [0]
while stack:
v = stack.pop()
order.append(v)
for c in e[v]:
if c == parent[v]:
continue
stack.append(c)
parent[c] = v
dp = [DP() for _ in range(N)]
for v in order[::-1]:
if parent[v] == -1:
continue
dp[parent[v]] += dp[v].addRoot()
for v in order[1:]:
d = dp[parent[v]] - dp[v].addRoot()
dp[v] += d.addRoot()
for d in dp:
print((d.dp)) | p02728 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
import resource
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return (a * b) % self.m
def div(self, a, b):
return self.mul(a, self.pow(b, self.m-2))
@lru_cache(maxsize=None)
def pow(self, a, b):
return pow(a, b, self.m)
M = Mod(10**9 + 7)
m = 10**9 + 7
fact = [1] * (2 * (10**5) + 1)
fact_inv = [0] * (2 * (10**5) + 1)
for i in range(1, 2 * (10**5)+1):
fact[i] = M.mul(fact[i-1], i)
fact_inv[i] = pow(fact[i], m-2, m)
@mt
def slv(N, AB):
g = defaultdict(list)
for a, b in AB:
g[a].append(b)
g[b].append(a)
memo = defaultdict(dict)
def f(u, p, flag=False):
if u in memo and p in memo[u]:
return memo[u][p]
r = 1
n = 1
if p == 0 or flag:
for v in g[u]:
if v == p:
continue
n_, r_ = f(v, u, flag)
n += n_
r = M.mul(r, r_)
r = M.mul(r, fact_inv[n_])
r = M.mul(r, fact[n-1])
else:
np, rp = f(p, u, False)
na, ra = f(u, 0, False)
r = M.div(ra, rp)
r = M.mul(r, fact[np])
n = na - np
r = M.mul(r, fact_inv[na-1])
r = M.mul(r, fact[n-1])
# memo[(u, p)] = n, r
memo[u][p] = n, r
return n, r
f(1, 0, True)
for i in range(1, N+1):
print(f(i, 0, False)[1])
def main():
N = read_int()
AB = [read_int_n() for _ in range(N-1)]
slv(N, AB)
# N = (10**5) * 2
# AB = [(_, _+1) for _ in range(N-1)]
# (slv(N, AB))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
import resource
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return (a * b) % self.m
def div(self, a, b):
return self.mul(a, self.pow(b, self.m-2))
@lru_cache(maxsize=None)
def pow(self, a, b):
return pow(a, b, self.m)
M = Mod(10**9 + 7)
m = 10**9 + 7
fact = [1] * (2 * (10**5) + 1)
fact_inv = [0] * (2 * (10**5) + 1)
for i in range(1, 2 * (10**5)+1):
fact[i] = M.mul(fact[i-1], i)
fact_inv[i] = pow(fact[i], m-2, m)
@mt
def slv(N, AB):
g = defaultdict(list)
for a, b in AB:
g[a].append(b)
g[b].append(a)
memo = defaultdict(dict)
def f(u, p, flag=False):
if u in memo and p in memo[u]:
return memo[u][p]
r = 1
n = 1
if p == 0 or flag:
for v in g[u]:
if v == p:
continue
n_, r_ = f(v, u, flag)
n += n_
r = M.mul(r, r_)
r = M.mul(r, fact_inv[n_])
r = M.mul(r, fact[n-1])
else:
np, rp = f(p, u, False)
na, ra = f(u, 0, False)
r = M.div(ra, rp)
r = M.mul(r, fact[np])
n = na - np
r = M.mul(r, fact_inv[na-1])
r = M.mul(r, fact[n-1])
memo[u][p] = n, r
return n, r
f(1, 0, True)
for i in range(1, N+1):
print(f(i, 0, False)[1])
def main():
N = read_int()
AB = [read_int_n() for _ in range(N-1)]
slv(N, AB)
# N = (10**5) * 2
# AB = [(_, _+1) for _ in range(N-1)]
# (slv(N, AB))
if __name__ == '__main__':
main()
| p02728 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
import resource
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
M = Mod(10**9 + 7)
m = 10**9 + 7
fact = [1] * (2 * (10**5) + 1)
fact_inv = [0] * (2 * (10**5) + 1)
for i in range(1, 2 * (10**5)+1):
fact[i] = M.mul(fact[i-1], i)
fact_inv[i] = pow(fact[i], m-2, m)
@mt
def slv(N, AB):
g = defaultdict(list)
for a, b in AB:
g[a].append(b)
g[b].append(a)
memo = defaultdict(dict)
def f(u, p, flag=False):
if u in memo and p in memo[u]:
return memo[u][p]
r = 1
n = 1
if p == 0 or flag:
for v in g[u]:
if v == p:
continue
n_, r_ = f(v, u, flag)
n += n_
r = M.mul(r, r_)
r = M.mul(r, fact_inv[n_])
r = M.mul(r, fact[n-1])
else:
np, rp = f(p, u, False)
na, ra = f(u, 0, False)
r = M.div(ra, rp)
r = M.mul(r, fact[np])
n = na - np
r = M.mul(r, fact_inv[na-1])
r = M.mul(r, fact[n-1])
memo[u][p] = n, r
return n, r
f(1, 0, True)
for i in range(1, N+1):
print(f(i, 0, False)[1])
def main():
N = read_int()
AB = [read_int_n() for _ in range(N-1)]
slv(N, AB)
# N = (10**5) * 2
# AB = [(_, _+1) for _ in range(N-1)]
# (slv(N, AB))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
from collections import defaultdict
class ReRooting:
def __init__(self, f, g, merge, ie):
self.tree = defaultdict(list)
self.f = f
self.g = g
self.merge = merge
self.ie = ie
self.dp = defaultdict(dict)
def add_edge(self, u, v):
self.tree[u].append(v)
self.tree[v].append(u)
def __dfs1(self, u, p):
o = []
s = [(u, -1)]
while s:
u, p = s.pop()
o.append((u, p))
for v in self.tree[u]:
if v == p:
continue
s.append((v, u))
for u, p in reversed(o):
r = self.ie
for v in self.tree[u]:
if v == p:
continue
# ep(u_, v, self.dp)
r = self.merge(r, self.f(self.dp[u][v], v))
self.dp[p][u] = self.g(r, u)
def __dfs2(self, u, p, a):
s = [(u, p, a)]
while s:
u, p, a = s.pop()
self.dp[u][p] = a
pl = [0] * (len(self.tree[u]) + 1)
pl[0] = self.ie
for i, v in enumerate(self.tree[u]):
pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
pr = [0] * (len(self.tree[u]) + 1)
pr[-1] = self.ie
for i, v in reversed(list(enumerate(self.tree[u]))):
pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
for i, v in enumerate(self.tree[u]):
if v == p:
continue
r = self.merge(pl[i], pr[i+1])
s.append((v, u, self.g(r, v)))
# def __dfs1(self, u, p):
# r = self.ie
# for v in self.tree[u]:
# if v == p:
# continue
# self.dp[u][v] = self.__dfs1(v, u)
# r = self.merge(r, self.f(self.dp[u][v], v))
# return self.g(r, u)
# def __dfs2(self, u, p, a):
# for v in self.tree[u]:
# if v == p:
# self.dp[u][v] = a
# break
# pl = [0] * (len(self.tree[u]) + 1)
# pl[0] = self.ie
# for i, v in enumerate(self.tree[u]):
# pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
# pr = [0] * (len(self.tree[u]) + 1)
# pr[-1] = self.ie
# for i, v in reversed(list(enumerate(self.tree[u]))):
# pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
# for i, v in enumerate(self.tree[u]):
# if v == p:
# continue
# r = self.merge(pl[i], pr[i+1])
# self.__dfs2(v, u, self.g(r, v))
def build(self, root=1):
self.__dfs1(root, -1)
self.__dfs2(root, -1, self.ie)
def slv(self, u):
r = self.ie
for v in self.tree[u]:
r = self.merge(r, self.f(self.dp[u][v], v))
return self.g(r, u)
def atcoder_dp_dp_v():
# https://atcoder.jp/contests/dp/tasks/dp_v
# https://atcoder.jp/contests/dp/submissions/16664670
N, M = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(N-1)]
f = lambda x, y: x
g = lambda x, y: x + 1
merge = lambda x, y: (x * y) % M
rr = ReRooting(f, g, merge, 1)
for x, y in XY:
rr.add_edge(x, y)
rr.build()
for u in range(1, N+1):
print((rr.slv(u)))
def atcoder_abc60_f():
N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(N-1)]
M = 10**9+7
from functools import reduce
fact = [1]
for i in range(1, 10**6):
fact.append(fact[-1]*i % M)
def f(x, _):
c = x[0]
s = x[1]
c *= pow(fact[s], M-2, M)
c %= M
return (c, s)
def g(x, _):
c = x[0]
s = x[1]
c *= fact[s]
c %= M
return (c, s+1)
def merge(x, y):
return (x[0]*y[0]%M, x[1]+y[1])
rr = ReRooting(f, g, merge, (1, 0))
for a, b in AB:
rr.add_edge(a, b)
rr.build()
for u in range(1, N+1):
print((rr.slv(u)[0]))
if __name__ == '__main__':
# atcoder_dp_dp_v()
atcoder_abc60_f()
| p02728 |
# -*- coding: utf-8 -*-
from collections import defaultdict
class ReRooting:
def __init__(self, f, g, merge, ie):
self.tree = defaultdict(list)
self.f = f
self.g = g
self.merge = merge
self.ie = ie
self.dp = defaultdict(dict)
def add_edge(self, u, v):
self.tree[u].append(v)
self.tree[v].append(u)
def __dfs1(self, u, p):
o = []
s = [(u, -1)]
while s:
u, p = s.pop()
o.append((u, p))
for v in self.tree[u]:
if v == p:
continue
s.append((v, u))
for u, p in reversed(o):
r = self.ie
for v in self.tree[u]:
if v == p:
continue
# ep(u_, v, self.dp)
r = self.merge(r, self.f(self.dp[u][v], v))
self.dp[p][u] = self.g(r, u)
def __dfs2(self, u, p, a):
s = [(u, p, a)]
while s:
u, p, a = s.pop()
self.dp[u][p] = a
pl = [0] * (len(self.tree[u]) + 1)
pl[0] = self.ie
for i, v in enumerate(self.tree[u]):
pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
pr = [0] * (len(self.tree[u]) + 1)
pr[-1] = self.ie
for i, v in reversed(list(enumerate(self.tree[u]))):
pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
for i, v in enumerate(self.tree[u]):
if v == p:
continue
r = self.merge(pl[i], pr[i+1])
s.append((v, u, self.g(r, v)))
# def __dfs1(self, u, p):
# r = self.ie
# for v in self.tree[u]:
# if v == p:
# continue
# self.dp[u][v] = self.__dfs1(v, u)
# r = self.merge(r, self.f(self.dp[u][v], v))
# return self.g(r, u)
# def __dfs2(self, u, p, a):
# for v in self.tree[u]:
# if v == p:
# self.dp[u][v] = a
# break
# pl = [0] * (len(self.tree[u]) + 1)
# pl[0] = self.ie
# for i, v in enumerate(self.tree[u]):
# pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
# pr = [0] * (len(self.tree[u]) + 1)
# pr[-1] = self.ie
# for i, v in reversed(list(enumerate(self.tree[u]))):
# pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
# for i, v in enumerate(self.tree[u]):
# if v == p:
# continue
# r = self.merge(pl[i], pr[i+1])
# self.__dfs2(v, u, self.g(r, v))
def build(self, root=1):
self.__dfs1(root, -1)
self.__dfs2(root, -1, self.ie)
def slv(self, u):
r = self.ie
for v in self.tree[u]:
r = self.merge(r, self.f(self.dp[u][v], v))
return self.g(r, u)
def atcoder_dp_dp_v():
# https://atcoder.jp/contests/dp/tasks/dp_v
# https://atcoder.jp/contests/dp/submissions/16664670
N, M = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(N-1)]
f = lambda x, y: x
g = lambda x, y: x + 1
merge = lambda x, y: (x * y) % M
rr = ReRooting(f, g, merge, 1)
for x, y in XY:
rr.add_edge(x, y)
rr.build()
for u in range(1, N+1):
print((rr.slv(u)))
def atcoder_abc60_f():
N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(N-1)]
M = 10**9+7
from functools import reduce
fact = [1]
for i in range(1, 10**6):
fact.append(fact[-1]*i % M)
def f(x, _):
c = x[0]
s = x[1]
c *= pow(fact[s], M-2, M)
c %= M
return (c, s)
def g(x, _):
c = x[0]
s = x[1]
c *= fact[s]
c %= M
return (c, s+1)
def merge(x, y):
return (x[0]*y[0]%M, x[1]+y[1])
rr = ReRooting(f, g, merge, (1, 0))
for a, b in AB:
rr.add_edge(a, b)
rr.build()
for u in range(1, N+1):
print((rr.slv(u)[0]))
if __name__ == '__main__':
# atcoder_dp_dp_v()
atcoder_abc60_f()
| # -*- coding: utf-8 -*-
from collections import defaultdict
class ReRooting:
def __init__(self, f, g, merge, ie):
self.tree = defaultdict(list)
self.f = f
self.g = g
self.merge = merge
self.ie = ie
self.dp = defaultdict(dict)
def add_edge(self, u, v):
self.tree[u].append(v)
self.tree[v].append(u)
def __dfs1(self, u, p):
o = []
s = [(u, -1)]
while s:
u, p = s.pop()
o.append((u, p))
for v in self.tree[u]:
if v == p:
continue
s.append((v, u))
for u, p in reversed(o):
r = self.ie
for v in self.tree[u]:
if v == p:
continue
# ep(u_, v, self.dp)
r = self.merge(r, self.f(self.dp[u][v], v))
self.dp[p][u] = self.g(r, u)
def __dfs2(self, u, p, a):
s = [(u, p, a)]
while s:
u, p, a = s.pop()
self.dp[u][p] = a
pl = [0] * (len(self.tree[u]) + 1)
pl[0] = self.ie
for i, v in enumerate(self.tree[u]):
pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
pr = [0] * (len(self.tree[u]) + 1)
pr[-1] = self.ie
for i, v in reversed(list(enumerate(self.tree[u]))):
pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
for i, v in enumerate(self.tree[u]):
if v == p:
continue
r = self.merge(pl[i], pr[i+1])
s.append((v, u, self.g(r, v)))
# def __dfs1(self, u, p):
# r = self.ie
# for v in self.tree[u]:
# if v == p:
# continue
# self.dp[u][v] = self.__dfs1(v, u)
# r = self.merge(r, self.f(self.dp[u][v], v))
# return self.g(r, u)
# def __dfs2(self, u, p, a):
# for v in self.tree[u]:
# if v == p:
# self.dp[u][v] = a
# break
# pl = [0] * (len(self.tree[u]) + 1)
# pl[0] = self.ie
# for i, v in enumerate(self.tree[u]):
# pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
# pr = [0] * (len(self.tree[u]) + 1)
# pr[-1] = self.ie
# for i, v in reversed(list(enumerate(self.tree[u]))):
# pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
# for i, v in enumerate(self.tree[u]):
# if v == p:
# continue
# r = self.merge(pl[i], pr[i+1])
# self.__dfs2(v, u, self.g(r, v))
def build(self, root=1):
self.__dfs1(root, -1)
self.__dfs2(root, -1, self.ie)
def slv(self, u):
r = self.ie
for v in self.tree[u]:
r = self.merge(r, self.f(self.dp[u][v], v))
return self.g(r, u)
def atcoder_dp_dp_v():
# https://atcoder.jp/contests/dp/tasks/dp_v
# https://atcoder.jp/contests/dp/submissions/16666380
N, M = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(N-1)]
f = lambda x, y: x
g = lambda x, y: x + 1
merge = lambda x, y: (x * y) % M
rr = ReRooting(f, g, merge, 1)
for x, y in XY:
rr.add_edge(x, y)
rr.build()
for u in range(1, N+1):
print((rr.slv(u)-1))
def atcoder_abc60_f():
# https://atcoder.jp/contests/abc160/tasks/abc160_f
N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(N-1)]
M = 10**9+7
from functools import reduce
fact = [1]
for i in range(1, 10**6):
fact.append(fact[-1]*i % M)
def f(x, _):
c = x[0]
s = x[1]
c *= pow(fact[s], M-2, M)
c %= M
return (c, s)
def g(x, _):
c = x[0]
s = x[1]
c *= fact[s]
c %= M
return (c, s+1)
def merge(x, y):
return (x[0]*y[0]%M, x[1]+y[1])
rr = ReRooting(f, g, merge, (1, 0))
for a, b in AB:
rr.add_edge(a, b)
rr.build()
for u in range(1, N+1):
print((rr.slv(u)[0]))
if __name__ == '__main__':
# atcoder_dp_dp_v()
atcoder_abc60_f()
| p02728 |
import sys
input = sys.stdin.buffer.readline
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
def factInvN(self, n):
if n < 0:
return 0
return self.factInv[n]
N = int(input())
MOD = 10**9 + 7
comb = Combination(N + 100)
edges = [[] for _ in range(N + 1)]
for _ in range(N - 1):
fr, to = map(int, input().split())
edges[fr].append(to)
edges[to].append(fr)
order = []
parent = [0] * (N + 1)
st = [1]
while st:
now = st.pop()
order.append(now)
for to in edges[now]:
if to == parent[now]:
continue
st.append(to)
parent[to] = now
size = [1] * (N + 1)
for v in order[::-1]:
size[parent[v]] += size[v]
dpLeaf = [1] * (N + 1)
for v in order[:: -1]:
pr = parent[v]
dpLeaf[v] = dpLeaf[v] * comb.factN(size[v] - 1) % MOD
dpLeaf[pr] = dpLeaf[pr] * dpLeaf[v] * comb.factInvN(size[v]) % MOD
ans = [0] * (N + 1)
ans[1] = dpLeaf[1]
for v in order[1:]:
pr = parent[v]
x = ans[pr]
x *= comb.factN(N - 1 - size[v]) * comb.factInvN(N - size[v])
x *= size[v]
ans[v] = x % MOD
print(*(ans[1:]), sep='\n')
| import sys
input = sys.stdin.buffer.readline
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
def factInvN(self, n):
if n < 0:
return 0
return self.factInv[n]
N = int(input())
MOD = 10**9 + 7
comb = Combination(N + 100)
edges = [[] for _ in range(N + 1)]
for _ in range(N - 1):
fr, to = map(int, input().split())
edges[fr].append(to)
edges[to].append(fr)
order = []
parent = [0] * (N + 1)
st = [1]
while st:
now = st.pop()
order.append(now)
for to in edges[now]:
if to == parent[now]:
continue
st.append(to)
parent[to] = now
size = [1] * (N + 1)
for v in order[::-1]:
size[parent[v]] += size[v]
dpLeaf = [1] * (N + 1)
for v in order[:: -1]:
pr = parent[v]
dpLeaf[v] = dpLeaf[v] * comb.factN(size[v] - 1) % MOD
dpLeaf[pr] = dpLeaf[pr] * dpLeaf[v] * comb.factInvN(size[v]) % MOD
ans = [0] * (N + 1)
ans[1] = dpLeaf[1]
for v in order[1:]:
pr = parent[v]
ans[v] = ans[pr] * comb.factN(N - 1 - size[v]) * comb.factInvN(N - size[v]) * size[v] % MOD
print(*(ans[1:]), sep='\n')
| p02728 |
import sys
input = sys.stdin.buffer.readline
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
def factInvN(self, n):
if n < 0:
return 0
return self.factInv[n]
N = int(input())
MOD = 10**9 + 7
comb = Combination(N + 100)
edges = [[] for _ in range(N + 1)]
for _ in range(N - 1):
fr, to = map(int, input().split())
edges[fr].append(to)
edges[to].append(fr)
order = []
parent = [0] * (N + 1)
st = [1]
while st:
now = st.pop()
order.append(now)
for to in edges[now]:
if to == parent[now]:
continue
st.append(to)
parent[to] = now
size = [1] * (N + 1)
for v in order[::-1]:
size[parent[v]] += size[v]
dpLeaf = [1] * (N + 1)
for v in order[:: -1]:
pr = parent[v]
dpLeaf[v] = dpLeaf[v] * comb.factN(size[v] - 1) % MOD
dpLeaf[pr] = dpLeaf[pr] * dpLeaf[v] * comb.factInvN(size[v]) % MOD
ans = [0] * (N + 1)
ans[1] = dpLeaf[1]
for v in order[1:]:
pr = parent[v]
ans[v] = ans[pr] * comb.factN(N - 1 - size[v]) * comb.factInvN(N - size[v]) * size[v] % MOD
print(*(ans[1:]), sep='\n')
| import sys
input = sys.stdin.buffer.readline
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
def factInvN(self, n):
if n < 0:
return 0
return self.factInv[n]
N = int(input())
MOD = 10**9 + 7
comb = Combination(N + 100)
edges = [[] for _ in range(N + 1)]
for _ in range(N - 1):
fr, to = map(int, input().split())
edges[fr].append(to)
edges[to].append(fr)
order = []
parent = [0] * (N + 1)
st = [1]
while st:
now = st.pop()
order.append(now)
for to in edges[now]:
if to == parent[now]:
continue
st.append(to)
parent[to] = now
size = [1] * (N + 1)
for v in order[::-1]:
size[parent[v]] += size[v]
dpLeaf = [1] * (N + 1)
for v in order[:: -1]:
pr = parent[v]
dpLeaf[v] = dpLeaf[v] * comb.factN(size[v] - 1) % MOD
dpLeaf[pr] = dpLeaf[pr] * dpLeaf[v] * comb.factInvN(size[v]) % MOD
ans = [0] * (N + 1)
ans[1] = dpLeaf[1]
for v in order[1:]:
pr = parent[v]
ans[v] = ans[pr] * comb.inv[N - size[v]] * size[v] % MOD
print(*(ans[1:]), sep='\n')
| p02728 |
class ReRooting:
def __init__(self, size, root, identDp=0, identCum=0):
"""
identDp: 木DP用 lift(a, identDp) = a
identCum: 累積用 merge(a, identCum) = a
"""
self.size = size
self.edges = [[] for _ in range(self.size + 1)]
self.root = root
self.identDp = identDp
self.identCum = identCum
def addEdge(self, fr, to):
self.edges[fr].append(to)
self.edges[to].append(fr)
# 根を固定したときの木DP
def lift(self, top, bottom):
return (((top[0] * bottom[0]) % MOD * comb.ncr(top[1] + bottom[1] + 1, top[1])) % MOD, top[1] + bottom[1] + 1)
# 子の累積
def merge(self, cum, a):
return (((cum[0] * a[0]) % MOD * comb.ncr(cum[1] + a[1], cum[1])) % MOD, cum[1] + a[1])
def sol(self):
# 普通に木DPをする
# 並行して各頂点につき、子の値の累積liftを左右から求めておく
# その後根から順番に、親からの寄与を求めていく(fromParent)
N = self.size
edges = self.edges
st = [self.root]
parent = [-1] * (N + 1)
child = [[] for _ in range(N + 1)]
order = []
while st:
v = st.pop()
order.append(v)
for to in edges[v]:
if parent[v] == to:
continue
parent[to] = v
child[v].append(to)
st.append(to)
dp = [self.identDp] * (N + 1)
left = [self.identCum] * (N + 1)
right = [self.identCum] * (N + 1)
for v in order[::-1]:
tmp = self.identCum
for ch in child[v]:
left[ch] = tmp
tmp = self.lift(tmp, dp[ch])
tmp = self.identCum
for ch in reversed(child[v]):
right[ch] = tmp
tmp = self.lift(tmp, dp[ch])
dp[v] = tmp
fromParent = [self.identDp] * (N + 1)
for v in order:
if v == self.root:
continue
fromParent[v] = self.lift(self.merge(left[v], right[v]), fromParent[parent[v]])
dp[v] = self.lift(dp[v], fromParent[v])
return dp[:N]
class Combination:
def __init__(self, size, MOD=10**9 + 7):
self.size = size + 2
self.MOD = MOD
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.MOD
self.inv[i] = -self.inv[self.MOD % i] * (self.MOD // i) % self.MOD
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.MOD
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.MOD
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.MOD) % self.MOD
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
N = int(input())
MOD = 10**9 + 7
comb = Combination(2 * 10**5 + 100)
tree = ReRooting(N, 0, (1, -1), (1, 0))
for _ in range(N - 1):
fr, to = map(int, input().split())
tree.addEdge(fr - 1, to - 1)
ans = tree.sol()
print(*[a for a, b in ans], sep='\n')
| class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
class ReRooting:
"""
0-indexed
"""
def __init__(self, size, root=0, identDp=1, identCum=1):
"""
identDp: 木DP用 lift(a, identDp) = a
identCum: 累積用 merge(a, identCum) = a
"""
self.size = size
self.edges = [[] for _ in range(self.size + 1)]
self.root = root
self.identDp = identDp
self.identCum = identCum
def addEdge(self, fr, to):
self.edges[fr].append(to)
self.edges[to].append(fr)
# 根を固定したときの木DP(貰うDP)
def lift(self, top, bottom):
size = top[1] + bottom[1]
dp = top[0] * comb.factInv[top[1] - 1] * bottom[0] * comb.factInv[bottom[1]] * comb.fact[size - 1] % MOD
return (dp, size)
# 親の左右の累積から子を根としたときの値を求める
def merge(self, left, right):
size = left[1] + right[1] - 1
dp = left[0] * comb.factInv[left[1] - 1] * right[0] * comb.factInv[right[1] - 1] * comb.fact[size - 1] % MOD
return (dp, size)
def sol(self):
N = self.size
edges = self.edges
st = [self.root]
parent = [-1] * (N + 1)
child = [[] for _ in range(N + 1)]
order = []
while st:
v = st.pop()
order.append(v)
for to in edges[v]:
if parent[v] == to:
continue
parent[to] = v
child[v].append(to)
st.append(to)
dp = [self.identDp] * (N + 1)
left = [self.identCum] * (N + 1)
right = [self.identCum] * (N + 1)
for v in order[::-1]: # 貰うDPしつつ，累積をとる
tmp = self.identDp
for ch in child[v]:
left[ch] = tmp
tmp = self.lift(tmp, dp[ch])
tmp = self.identDp
for ch in reversed(child[v]):
right[ch] = tmp
tmp = self.lift(tmp, dp[ch])
dp[v] = tmp
fromParent = [self.identCum] * (N + 1)
for v in order:
if v == self.root:
continue
fromParent[v] = self.lift(self.merge(left[v], right[v]), fromParent[parent[v]])
dp[v] = self.lift(dp[v], fromParent[v]) # 最後に親からの貰うDP
return dp[:N]
N = int(input())
MOD = 10**9 + 7
comb = Combination(N + 100)
tree = ReRooting(N, 0, (1, 1), (1, 0))
for _ in range(N - 1):
fr, to = map(int, input().split())
tree.addEdge(fr - 1, to - 1)
ans = tree.sol()
ans = [d for d, _ in ans]
print(*ans, sep='\n')
| p02728 |
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
class ReRooting:
"""
0-indexed
"""
def __init__(self, size, root=0, identDp=1, identCum=1):
"""
identDp: 木DP用 lift(a, identDp) = a
identCum: 累積用 merge(a, identCum) = a
"""
self.size = size
self.edges = [[] for _ in range(self.size + 1)]
self.root = root
self.identDp = identDp
self.identCum = identCum
def addEdge(self, fr, to):
self.edges[fr].append(to)
self.edges[to].append(fr)
# 根を固定したときの木DP(貰うDP)
def lift(self, top, bottom):
newSize = top[1] + bottom[1] + 1
dp = top[0] * bottom[0] * comb.ncr(newSize, bottom[1] + 1)
return (dp, newSize)
# 親の左右の累積から子を根としたときの値を求める
def merge(self, left, right):
newSize = left[1] + right[1]
dp = left[0] * right[0] * comb.ncr(newSize, right[1])
return (dp, newSize)
def sol(self):
N = self.size
edges = self.edges
st = [self.root]
parent = [-1] * (N + 1)
child = [[] for _ in range(N + 1)]
order = []
while st:
v = st.pop()
order.append(v)
for to in edges[v]:
if parent[v] == to:
continue
parent[to] = v
child[v].append(to)
st.append(to)
dp = [self.identDp] * (N + 1)
left = [self.identCum] * (N + 1)
right = [self.identCum] * (N + 1)
for v in order[::-1]: # 貰うDPしつつ，累積をとる
tmp = self.identCum
for ch in child[v]:
left[ch] = tmp
tmp = self.lift(tmp, dp[ch])
tmp = self.identCum
for ch in reversed(child[v]):
right[ch] = tmp
tmp = self.lift(tmp, dp[ch])
dp[v] = tmp
fromParent = [self.identDp] * (N + 1)
for v in order:
if v == self.root:
continue
fromParent[v] = self.lift(self.merge(left[v], right[v]), fromParent[parent[v]])
dp[v] = self.lift(dp[v], fromParent[v]) # 最後に親からの貰うDP
return dp[:N]
N = int(input())
tree = ReRooting(N, 0, (1, -1), (1, 0))
comb = Combination(N + 100)
for _ in range(N - 1):
fr, to = map(int, input().split())
tree.addEdge(fr - 1, to - 1)
ans = tree.sol()
print(*[dp for dp, _ in ans[:N]], sep='\n')
| class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
class ReRooting:
"""
0-indexed
"""
def __init__(self, size, root=0, identDp=1, identCum=1):
"""
identDp: 木DP用 lift(a, identDp) = a
identCum: 累積用 merge(a, identCum) = a
"""
self.size = size
self.edges = [[] for _ in range(self.size + 1)]
self.root = root
self.identDp = identDp
self.identCum = identCum
def addEdge(self, fr, to):
self.edges[fr].append(to)
self.edges[to].append(fr)
# 根を固定したときの木DP(貰うDP)
def lift(self, top, bottom):
newSize = top[1] + bottom[1] + 1
dp = top[0] * bottom[0] * comb.ncr(newSize, bottom[1] + 1)
return (dp % MOD, newSize)
# 親の左右の累積から子を根としたときの値を求める
def merge(self, left, right):
newSize = left[1] + right[1]
dp = left[0] * right[0] * comb.ncr(newSize, right[1])
return (dp % MOD, newSize)
def sol(self):
N = self.size
edges = self.edges
st = [self.root]
parent = [-1] * (N + 1)
child = [[] for _ in range(N + 1)]
order = []
while st:
v = st.pop()
order.append(v)
for to in edges[v]:
if parent[v] == to:
continue
parent[to] = v
child[v].append(to)
st.append(to)
dp = [self.identDp] * (N + 1)
left = [self.identCum] * (N + 1)
right = [self.identCum] * (N + 1)
for v in order[::-1]: # 貰うDPしつつ，累積をとる
tmp = self.identCum
for ch in child[v]:
left[ch] = tmp
tmp = self.lift(tmp, dp[ch])
tmp = self.identCum
for ch in reversed(child[v]):
right[ch] = tmp
tmp = self.lift(tmp, dp[ch])
dp[v] = tmp
fromParent = [self.identDp] * (N + 1)
for v in order:
if v == self.root:
continue
fromParent[v] = self.lift(self.merge(left[v], right[v]), fromParent[parent[v]])
dp[v] = self.lift(dp[v], fromParent[v]) # 最後に親からの貰うDP
return dp[:N]
N = int(input())
MOD = 10**9 + 7
tree = ReRooting(N, 0, (1, -1), (1, 0))
comb = Combination(N + 100)
for _ in range(N - 1):
fr, to = map(int, input().split())
tree.addEdge(fr - 1, to - 1)
ans = tree.sol()
print(*[dp for dp, _ in ans[:N]], sep='\n')
| p02728 |
#%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(1,0)
self.mod=10**9+7
self.edge=edge
cb=comb(N)
self.fact=cb.fact
self.ifact=cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
def func(self,x,y):
ans=1
p1,s1=x
p2,s2=y
ans*=p1
ans*=p2
ans%=self.mod
ssum=s1+s2
#print(x,y,slist)
ans*=self.fact[ssum]*self.ifact[s1]*self.ifact[s2]%self.mod
ans%=self.mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
def _dfs(self,e,pa):
edge=self.edge
self.par[e]=pa
self.ikigake.append(e)
ans=self.unit
for ne in edge[e]:
if self.par[ne]!=-1:
continue
ans=self.func(ans,self.addnode(self._dfs(ne,e)))
#print(ans)
if pa!=e:
self.dics[pa][e]=ans
return ans
def forward(self,start):
self._dfs(start,start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| #%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(1,0)
self.mod=10**9+7
self.edge=edge
cb=comb(N)
self.fact=cb.fact
self.ifact=cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
#@lru_cache(maxsize = None)
def func(self,x,y):
ifact=self.ifact
mod=self.mod
p1,s1=x
p2,s2=y
ans=(p1*p2)%mod
ssum=s1+s2
#print(x,y,slist)
ans*=(self.fact[ssum]*ifact[s1])%mod*ifact[s2]%mod
ans%=mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
def _dfs(self,e,pa):
edge=self.edge
self.par[e]=pa
self.ikigake.append(e)
ans=self.unit
for ne in edge[e]:
if self.par[ne]!=-1:
continue
ans=self.func(ans,self.addnode(self._dfs(ne,e)))
#print(ans)
if pa!=e:
self.dics[pa][e]=ans
return ans
def forward(self,start):
self._dfs(start,start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| p02728 |
#%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
#@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(1,0)
self.mod=10**9+7
self.edge=edge
self.cb=comb(N)
self.fact=self.cb.fact
self.ifact=self.cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
#@lru_cache(maxsize = None)
def func(self,x,y):
#ifact=self.ifact
#mod=self.mod
p1,s1=x
p2,s2=y
ans=(p1*p2)%self.mod
ssum=s1+s2
ans*=self.cb.comb(ssum,s1)
#ans*=(self.fact[ssum]*self.ifact[s1])%self.mod*self.ifact[s2]%self.mod
ans%=self.mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
def _dfs(self,e,pa):
edge=self.edge
self.par[e]=pa
self.ikigake.append(e)
ans=self.unit
for ne in edge[e]:
if self.par[ne]!=-1:
continue
ans=self.func(ans,self.addnode(self._dfs(ne,e)))
#print(ans)
if pa!=e:
self.dics[pa][e]=ans
return ans
def forward(self,start):
self._dfs(start,start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| #%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
#@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
#@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(1,0)
self.mod=10**9+7
self.edge=edge
self.cb=comb(N)
self.fact=self.cb.fact
self.ifact=self.cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
#@lru_cache(maxsize = None)
def func(self,x,y):
#ifact=self.ifact
#mod=self.mod
p1,s1=x
p2,s2=y
ans=(p1*p2)%self.mod
ssum=s1+s2
ans*=self.cb.comb(ssum,s1)
#ans*=(self.fact[ssum]*self.ifact[s1])%self.mod*self.ifact[s2]%self.mod
ans%=self.mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
def _dfs(self,e,pa):
edge=self.edge
self.par[e]=pa
self.ikigake.append(e)
ans=self.unit
for ne in edge[e]:
if self.par[ne]!=-1:
continue
ans=self.func(ans,self.addnode(self._dfs(ne,e)))
#print(ans)
if pa!=e:
self.dics[pa][e]=ans
return ans
def forward(self,start):
self._dfs(start,start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| p02728 |
#%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class modint:#商をとるときはmodとdが互いに素であること
def __init__(self,x,mod=1000000007):
self.x, self.mod= x%mod, mod
def __str__(self):
return str(self.x)
def __add__(self, a):
if isinstance(a, modint):a=a.x
return (self.x+a)%self.mod
def __radd__(self, a):return self.__add__(a)
def __iadd__(self, a):
self.x=self.__add__(a)
return self
def __sub__(self, a):
if isinstance(a, modint):a=a.x
return self.__add__(-a)
def __rsub__(self, a):return (a-self.x)%self.mod
def __isub__(self, a):
return self.__iadd__(-a)
def __mul__(self, c):
if isinstance(c, modint):c=c.x
return (self.x*(c%self.mod))%self.mod
def __rmul__(self, c):return self.__mul__(c)
def __imul__(self, c):
self.x=self.__mul__(c)
return self
def __pow__(self,p):
if isinstance(p, modint):p=p.x
return pow(self.x,p,self.mod)
def __ipow__(self,p):
self.x=self.__pow__(p)
return self
def __truediv__(self, d):
if isinstance(d, modint):d=d.x
u,v,a,b=1,0,d,self.mod
while b:
t=a//b
a-=t*b
a,b,u,v=b,a,v,u-t*v
if a!=1: print("not 素")
return int((self.x*(u%self.mod))%self.mod)
def __itruediv__(self, d):
self.x=self.__truediv__(d)
return self
def __eq__(self, target):
if isinstance(target, modint):
return self.x==target.x
return self.x==target%self.mod
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
#@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(modint(1),0)
self.mod=10**9+7
self.edge=edge
self.cb=comb(N)
self.fact=self.cb.fact
self.ifact=self.cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
#@lru_cache(maxsize = None)
def func(self,x,y):
#ifact=self.ifact
#mod=self.mod
p1,s1=x
p2,s2=y
ans=modint(p1*p2)
ssum=s1+s2
ans*=self.cb.comb(ssum,s1)
#ans*=(self.fact[ssum]*self.ifact[s1])%self.mod*self.ifact[s2]%self.mod
#ans%=self.mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
def _dfs(self,e,pa):
edge=self.edge
self.par[e]=pa
self.ikigake.append(e)
ans=self.unit
for ne in edge[e]:
if self.par[ne]!=-1:
continue
ans=self.func(ans,self.addnode(self._dfs(ne,e)))
#print(ans)
if pa!=e:
self.dics[pa][e]=ans
return ans
def forward(self,start):
self._dfs(start,start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| #%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class modint:#add:和,mul:積,pow:累乗,div:商(modと互いに素であること)
def __init__(self,x,mod=1000000007):
if isinstance(x, modint):x=x.x
self.x, self.mod= x%mod, mod
def __str__(self):
return str(self.x)
def __add__(self, a):
if isinstance(a, modint):a=a.x
return modint(self.x+a,self.mod)
def __radd__(self, a):return self.__add__(a)
def __iadd__(self, a):
self.x=self.__add__(a)
return self
def __sub__(self, a):
if isinstance(a, modint):a=a.x
return self.__add__(-a)
def __rsub__(self, a):return (a-self.x)%mod
def __isub__(self, a):
return self.__iadd__(-a)
def __mul__(self, c):
if isinstance(c, modint):c=c.x
return modint(self.x*(c%self.mod),self.mod)
def __rmul__(self, c):return self.__mul__(c)
def __imul__(self, c):
return self.__mul__(c)
def __pow__(self,p):
if isinstance(p, modint):p=p.x
return modint(pow(self.x,p,self.mod),self.mod)
def __ipow__(self,p):
return self.__pow__(p)
def __truediv__(self, d):
if isinstance(d, modint):d=d.x
u,v,a,b=1,0,d,self.mod
while b:
t=a//b
a-=t*b
a,b,u,v=b,a,v,u-t*v
if a!=1: print("not 素")
return modint(self.x*(u%self.mod),self.mod)
def __itruediv__(self, d):
self.x=self.__truediv__(d)
return self
def __eq__(self, target):
if isinstance(target, modint):
return self.x==target.x
return self.x==target%self.mod
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
#@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
#@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
#@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(modint(1),0)
self.mod=10**9+7
self.edge=edge
self.cb=comb(N)
self.fact=self.cb.fact
self.ifact=self.cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
#@lru_cache(maxsize = None)
def func(self,x,y):
#ifact=self.ifact
#mod=self.mod
p1,s1=x
p2,s2=y
ans=modint(p1*p2)
ssum=s1+s2
ans*=self.cb.comb(ssum,s1)
#ans*=(self.fact[ssum]*self.ifact[s1])%self.mod*self.ifact[s2]%self.mod
#ans%=self.mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
def _dfs(self,e,pa):
edge=self.edge
self.par[e]=pa
self.ikigake.append(e)
ans=self.unit
for ne in edge[e]:
if self.par[ne]!=-1:
continue
ans=self.func(ans,self.addnode(self._dfs(ne,e)))
#print(ans)
if pa!=e:
self.dics[pa][e]=ans
return ans
def forward(self,start):
self._dfs(start,start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| p02728 |
#%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class modint:#add:和,mul:積,pow:累乗,div:商(modと互いに素であること)
def __init__(self,x,mod=1000000007):
if isinstance(x, modint):x=x.x
self.x, self.mod= x%mod, mod
def __str__(self):
return str(self.x)
def __add__(self, a):
if isinstance(a, modint):a=a.x
return modint(self.x+a,self.mod)
def __radd__(self, a):return self.__add__(a)
def __iadd__(self, a):
self.x=self.__add__(a)
return self
def __sub__(self, a):
if isinstance(a, modint):a=a.x
return self.__add__(-a)
def __rsub__(self, a):return (a-self.x)%mod
def __isub__(self, a):
return self.__iadd__(-a)
def __mul__(self, c):
if isinstance(c, modint):c=c.x
return modint(self.x*(c%self.mod),self.mod)
def __rmul__(self, c):return self.__mul__(c)
def __imul__(self, c):
return self.__mul__(c)
def __pow__(self,p):
if isinstance(p, modint):p=p.x
return modint(pow(self.x,p,self.mod),self.mod)
def __ipow__(self,p):
return self.__pow__(p)
def __truediv__(self, d):
if isinstance(d, modint):d=d.x
u,v,a,b=1,0,d,self.mod
while b:
t=a//b
a-=t*b
a,b,u,v=b,a,v,u-t*v
if a!=1: print("not 素")
return modint(self.x*(u%self.mod),self.mod)
def __itruediv__(self, d):
self.x=self.__truediv__(d)
return self
def __eq__(self, target):
if isinstance(target, modint):
return self.x==target.x
return self.x==target%self.mod
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
#@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
#@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(modint(1),0)
self.mod=10**9+7
self.edge=edge
self.cb=comb(N)
self.fact=self.cb.fact
self.ifact=self.cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
#@lru_cache(maxsize = None)
def func(self,x,y):
#ifact=self.ifact
#mod=self.mod
p1,s1=x
p2,s2=y
ans=modint(p1*p2)
ssum=s1+s2
ans*=self.cb.comb(ssum,s1)
#ans*=(self.fact[ssum]*self.ifact[s1])%self.mod*self.ifact[s2]%self.mod
#ans%=self.mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
def _dfs(self,e,pa):
edge=self.edge
self.par[e]=pa
self.ikigake.append(e)
ans=self.unit
for ne in edge[e]:
if self.par[ne]!=-1:
continue
ans=self.func(ans,self.addnode(self._dfs(ne,e)))
#print(ans)
if pa!=e:
self.dics[pa][e]=ans
return ans
def forward(self,start):
self._dfs(start,start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| #%%
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from collections import deque
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
def input(): return sys.stdin.readline()[:-1]
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
class modint:#add:和,mul:積,pow:累乗,div:商(modと互いに素であること)
def __init__(self,x,mod=1000000007):
if isinstance(x, modint):x=x.x
self.x, self.mod= x%mod, mod
def __str__(self):
return str(self.x)
def __add__(self, a):
if isinstance(a, modint):a=a.x
return modint(self.x+a,self.mod)
def __radd__(self, a):return self.__add__(a)
def __iadd__(self, a):
self.x=self.__add__(a)
return self
def __sub__(self, a):
if isinstance(a, modint):a=a.x
return self.__add__(-a)
def __rsub__(self, a):return (a-self.x)%self.mod
def __isub__(self, a):
return self.__iadd__(-a)
def __mul__(self, c):
if isinstance(c, modint):c=c.x
return modint(self.x*(c%self.mod),self.mod)
def __rmul__(self, c):return self.__mul__(c)
def __imul__(self, c):
return self.__mul__(c)
def __pow__(self,p):
if isinstance(p, modint):p=p.x
return modint(pow(self.x,p,self.mod),self.mod)
def __ipow__(self,p):
return self.__pow__(p)
def __truediv__(self, d):
if isinstance(d, modint):d=d.x
u,v,a,b=1,0,d,self.mod
while b:
t=a//b
a-=t*b
a,b,u,v=b,a,v,u-t*v
if a!=1: print("not 素")
return modint(self.x*(u%self.mod),self.mod)
def __itruediv__(self, d):
self.x=self.__truediv__(d)
return self
def __eq__(self, target):
if isinstance(target, modint):
return self.x==target.x
return self.x==target%self.mod
class comb:
def __init__(self,N,mod=10**9+7):#コンビネーションnCrをmodで求める、Nは最大のn
self.mod=mod
self.fact=[0]*(N+1)
self.ifact=[0]*(N+1)
fact,ifact=self.fact,self.ifact
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=self.extgcd1(x,mod)
#@lru_cache(maxsize = None)
def extgcd1(self,a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t,a=divmod(a,b)
a,b,u,v=b,a,v,u-t*v
if a!=1:
print("not 素")
return -1
return u%b0
#@lru_cache(maxsize = None)
def comb(self,n,r): return (self.fact[n]*self.ifact[r]%self.mod)*self.ifact[n-r]%self.mod
#@lru_cache(maxsize = None)
def mulcomb(self,n,*rs):#n!/(r1!*r2!*r3!*...)
ans=self.fact[n]
for r in rs: ans=(ans*self.ifact[r])%self.mod
return ans
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef funcを設定すること,
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=(modint(1),0)
self.mod=10**9+7
self.edge=edge
self.cb=comb(N)
self.fact=self.cb.fact
self.ifact=self.cb.ifact
self.par=[-1]*N
self.N=N
self.visited=[0]*N
self.dics=[dict() for _ in range(N)]
self.ikigake=[]
self.tot=[self.unit]*N
#@lru_cache(maxsize = None)
def func(self,x,y):
#ifact=self.ifact
#mod=self.mod
p1,s1=x
p2,s2=y
ans=modint(p1*p2)
ssum=s1+s2
ans*=self.cb.comb(ssum,s1)
#ans*=(self.fact[ssum]*self.ifact[s1])%self.mod*self.ifact[s2]%self.mod
#ans%=self.mod
return ans,ssum
def addnode(self,x):#部分木に親のノードを結合する処理,dfsとforwardに出現
return x[0],x[1]+1
# def _dfs(self,e,pa):
# edge=self.edge
# self.par[e]=pa
# self.ikigake.append(e)
# ans=self.unit
# for ne in edge[e]:
# if self.par[ne]!=-1:
# continue
# ans=self.func(ans,self.addnode(self._dfs(ne,e)))
# #print(ans)
# if pa!=e:
# self.dics[pa][e]=ans
# return ans
def _dfs(self,start):
edge=self.edge
N=self.N
par=self.par
q=deque([(start,start)])
while len(q):
e,pa=q.pop()#ここをpopleftにすると幅優先探索BFSになる
if par[e]!=-1:continue
par[e]=pa
self.ikigake.append(e)
for ne in edge[e]:q.append((ne,e))
for e in reversed(self.ikigake):
pa=par[e]
if pa==e:continue
ans=self.unit
de=self.dics[e]
for ne in edge[e]:
if ne==pa:continue
ans=self.func(ans,self.addnode(de[ne]))
self.dics[pa][e]=ans
#print(self.dics)
def forward(self,start):
self._dfs(start)
#print(t2-t1)
#count=0
for e in self.ikigake:
pa=self.par[e]
de=self.dics[e]
nes=tuple(de.keys())
nvals=tuple(de.values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
cleft=self.unit
cright=self.unit
for i in range(l-1):
aleft.append(self.func(aleft[-1],self.addnode(nvals[i])))
aright.append(self.func(aright[-1],self.addnode(nvals[-i-1])))
#count+=4
#print(e,l,self.dics)
self.tot[e]=self.func(aright[-1],self.addnode(nvals[0]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.func(aleft[i],aright[-1-i])
#count+=1
#print(t3-t2)
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def tree_init(N):
edgelist = [[] for _ in range(N)]
elist=set()
for a, b in [map(int, input().split()) for i in range(N-1)]:#木じゃない場合N-1をNに変える
edgelist[a-1].append(b-1)#ノードの番号が0から始まる場合-1を消す
edgelist[b-1].append(a-1)
elist.add((a-1,b-1))
return edgelist,elist
edge,elist=tree_init(N)
cb=comb(N)
rt=rerooting(N,edge)
rt.forward(0)
for a in range(N):
print(rt.tot[a][0])
if __name__ == "__main__":
main()
#%%
| p02728 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.