input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import functools
import math
N, X = [int(i) for i in input().split()]
x_list = [int(i) for i in input().split()]
x_list.append(X)
num_list = sorted(x_list)
tmp = [abs(x[0] - x[1]) for x in zip(num_list[:-1],num_list[1:])]
D = functools.reduce(lambda acc, x: math.gcd(acc, x), tmp, 0)
print(D)
| import functools
import math
N, X = [int(i) for i in input().split()]
x_list = [abs(int(i) - X) for i in input().split()]
D = functools.reduce(lambda acc, x: math.gcd(acc, x), x_list, 0)
print(D) | p03262 |
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
y = [abs(xi - X) for xi in x]
k = min(y)
for i in range(k):
p = k -i
z = [yi % p for yi in y]
if sum(z) == 0:
print(p)
break
| def gcd(x, y):
while y != 0:
x, y = y, x % y
return x
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
y = [abs(xi - X) for xi in x]
r = y[0]
for i in range(N-1):
if y[i+1] != 0:
r = gcd(r, y[i+1])
print(r)
| p03262 |
N, X = list(map(int, input().split()))
A = list(map(int, input().split()))
def gcd(x, y):
return x if y == 0 else gcd(y, x % y)
D = []
for a in A:
D.append(abs(X - a))
answer = 0
for d in D:
answer = gcd(answer, d)
print(answer) | N, X = list(map(int, input().split()))
A = list([abs(X - int(x)) for x in input().split()])
def gcd(x, y):
return x if y == 0 else gcd(y, x % y)
answer = 0
for a in A:
answer = gcd(answer, a)
print(answer) | p03262 |
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y)
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
if len(x) == 1:
print((abs(x[0] - X)))
else:
x.sort()
s = x[1] - x[0]
for i in range(1, n-1):
s = gcd(s, x[i+1]-x[i])
a = 1
for i in range(n):
a = max(a, gcd(abs(X-x[i]), s))
print(a) | def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y)
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
a = abs(x[0] - X)
for i in x[1:]:
a = gcd(a, abs(i - X))
print(a) | p03262 |
a=list(map(int,input().split()))
b=[]
for i in input().split():
b.append(abs(int(i)-a[1]))
def ucl(a,b):
if a%b==0:
return b
else:
return ucl(b,a%b)
while len(b)>1:
b.append(ucl(b[0],b[1]))
del b[0],b[1]
print((b[0])) | a=list(map(int,input().split()))
x=[]
for i in input().split():
x.append(abs(int(i)-a[1]))
def ucl(a,b):
if a%b==0:
return b
else:
return ucl(b,a%b)
while len(x) > 1:
x2 = []
mn_x = min(x)
for n in range(len(x)):
mod = x[n] % mn_x
if mod != 0:
x2.append(mod)
x2.append(mn_x)
x = x2
print((x[0])) | p03262 |
N, X = list(map(int, input().split()))
axis = list(map(int, input().split()))
ans = abs(axis[0] - X)
def gcd(n, m) :
n, m = max(n, m), min(n, m)
if m == 0 :
return n
return gcd(m, n % m)
for a in axis :
ans = gcd(ans, abs(a - X))
print(ans) | N, X = list(map(int, input().split()))
A = [X] + list(map(int, input().split()))
def gcd(n, m):
if m == 0:
return n
return gcd(m, n % m)
B = [abs(a - A[0]) for a in A]
ans = 0
for d in B:
ans = gcd(ans, d)
print(ans)
| p03262 |
import collections
N, X = list(map(int, input().split()))
x = [int(i) for i in input().split()]
y = [abs(X-i) for i in x]
y.append(0)
y.sort()
z = [(y[i+1] - y[i]) for i in range(0, N)]
zz = []
for i in range(0, N):
if z[i] != 0 and not(z[i] in zz):
zz.append(z[i])
a = list(collections.Counter(zz).keys())
D = min(a)
f = True
for i in range(D, 0, -1):
f = True
for j in range(0, N):
if y[j]%D != 0:
f = False
break
if f:
break
D = i
print(D) | import collections
N, X = list(map(int, input().split()))
x = [int(i) for i in input().split()]
y = [abs(X-i) for i in x]
y.append(0)
y.sort()
z = [(y[i+1] - y[i]) for i in range(0, N) if (y[i+1] - y[i]) != 0]
z = list(set(z))
a = list(collections.Counter(z).keys())
D = min(a)
f = True
for i in range(D, 0, -1):
f = True
for j in range(0, N):
if y[j]%D != 0:
f = False
break
if f:
break
D = i
print(D) | p03262 |
import collections
N, X = list(map(int, input().split()))
x = [int(i) for i in input().split()]
y = [abs(X-i) for i in x]
y.append(0)
y.sort()
z = [(y[i+1] - y[i]) for i in range(0, N) if (y[i+1] - y[i]) != 0]
z = list(set(z))
a = list(collections.Counter(z).keys())
D = min(a)
f = True
for i in range(D, 0, -1):
f = True
for j in range(0, N):
if y[j]%D != 0:
f = False
break
if f:
break
D = i
print(D) | import collections
N, X = list(map(int, input().split()))
x = [int(i) for i in input().split()]
y = [abs(X-i) for i in x]
y.append(0)
y.sort()
D = min(collections.Counter(list(set([(y[i+1] - y[i]) for i in range(0, N) if (y[i+1] - y[i]) != 0]))).keys())
f = True
for i in range(D, 0, -1):
f = True
for j in range(0, N):
if y[j]%D != 0:
f = False
break
if f:
break
D = i
print(D) | p03262 |
def gcd(a, b):
if(b % a == 0):
return a
elif(a % b == 0):
return b
else:
ans = 1
i = 2
while a!= 1:
if(a % i == 0):
while a % i == 0:
a/= i
while b % i == 0:
b/= i
ans*= i
i+= 1
return ans
def ggcd(lista):
if(len(lista) == 1):
return lista.pop()
else:
l = lista.pop()
for i in range(1, len(lista)):
l = gcd(l, lista.pop())
return l
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x.append(X)
d = []
gcds = set()
x.sort()
for i in range(N):
d.append(x[i+ 1]- x[i])
gcds.add(d[0])
for i in range(N- 1):
if(d[i+ 1] != d[i]):
gcds.add(d[i+ 1])
print((ggcd(gcds))) | def gcd(a, b):
if(a == b):
return a
elif(a % b == 0):
return b
elif(b % a == 0):
return a
elif(a == 1 or b == 1):
return 1
elif(a > b):
return gcd(a- a// b* b, b)
elif(a < b):
return gcd(a, b- b// a* a)
def ggcd(lista):
if(len(lista) == 1):
return lista.pop()
else:
l = lista.pop()
for i in range(1, len(lista)):
l = gcd(l, lista.pop())
return l
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x.append(X)
d = []
gcds = set()
x.sort()
for i in range(N):
d.append(x[i+ 1]- x[i])
gcds.add(d[0])
for i in range(N- 1):
if(d[i+ 1] != d[i]):
gcds.add(d[i+ 1])
print((ggcd(gcds))) | p03262 |
N,X=list(map(int,input().split()))
inputcities=list(map(int, input().split()))
cities=list(set([abs(inputcities[i]-X) for i in range(N)]))
N=len(cities)
count=0
flag=0
minimum=min(cities)
for j in range(minimum+1)[::-1]:
for i in range(N):
if cities[i]%j==0:
count+=1
else:
count=0
break
if count==N:
print(j)
flag=1
break
if flag==1:
break | def gcd(a,b):
if a < b:
a,b = b,a
if a % b == 0:
return b
else:
return gcd(b,(a % b))
N,X=list(map(int,input().split()))
inputcities=list(map(int, input().split()))
cities=[abs(inputcities[i]-X) for i in range(N)]
cities.sort()
D=cities[0]
for i in range(N):
D=gcd(D,cities[i])
print(D) | p03262 |
N,X = list(map(int, input().split()))
l = sorted(map(int, input().split()+[X]))
r = [l[n+1] - l[n] for n in range(N)]
ans = r.pop()
for i in r:
while ans%i != 0:
ans,i = i,ans%i
ans = i
print(ans) | N,X = list(map(int, input().split()))
r = [abs(X-i) for i in map(int, input().split())]
ans = r.pop()
for i in r:
while ans%i != 0:
ans,i = i,ans%i
ans = i
print(ans) | p03262 |
N, X = list(map(int, input().split()))
L = list(map(int, input().split()))
L.append(X)
L.sort()
cand = []
def gcd(x, y):
if x > y:
small = y
else:
small = x
for i in range(1, small + 1):
if ((x % i == 0) and (y % i == 0)):
gcd = i
return gcd
for i in range(N):
cand.append(abs(L[i] - L[i+1]))
for i, can in enumerate(cand):
if i == 0:
tmp = can
continue
tmp = gcd(tmp, can)
print(tmp)
| N, X = list(map(int, input().split()))
L = list(map(int, input().split()))
L.append(X)
L.sort()
cand = []
def gcd(x, y):
while y != 0:
(x, y) = (y, x % y)
return x
for i in range(N):
cand.append(abs(L[i] - L[i+1]))
for i, can in enumerate(cand):
if i == 0:
tmp = can
continue
tmp = gcd(tmp, can)
print(tmp)
| p03262 |
N,X = list(map(int,input().split()))
x = [int(i) for i in input().split()]
x = [i-X for i in x]
Min = min([abs(i) for i in x])
flag = False
for i in range(1,Min+1):
if flag == True:
break
flag = True
if Min%i==0:
ans = Min//i
for j in x:
if j%ans!=0:
flag = False
else:
flag = False
print(ans) | N,X = list(map(int,input().split()))
x = [int(i) for i in input().split()]
def main():
global X
global x
print((answer(pre(X,x))))
def pre(a,b):
b = [i-a for i in b]
return b
def answer(k):
Min = min([abs(i) for i in k])
flag = False
for i in range(1,Min+1):
if flag == True:
break
flag = True
if Min%i==0:
ans = Min//i
for j in k:
if j%ans!=0:
flag = False
else:
flag = False
return ans
main() | p03262 |
def g_c_d(x, y):
if x == 0:
return y
elif y == 0:
return x
else:
return g_c_d(y, x%y)
a, b = list(map(int, input().split()))
c = list(map(int, input().split()))
c.append(b)
c.sort()
d = 0
for i in range(1, a + 1):
d = g_c_d(c[i] - c[i-1], d)
print(d)
| def g_c_d(x, y):
if x == 0:
return y
elif y == 0:
return x
else:
return g_c_d(y, x % y)
a, b = list(map(int, input().split()))
c = list(map(int, input().split()))
c.append(b)
d = 0
for i in range(len(c)):
d = g_c_d(d, abs((c[i] - c[i-1])))
print(d)
| p03262 |
N, X = list(map(int, input().split()))
lst = list(map(int, input().split()))
ans = []
for i in lst:
ans.append(abs(i-X))
small = min(ans)
for i in ans:
if i%small == 0:
continue
else:
while i != small:
i = i%small
small = small - i
print(small) | N, X = list(map(int, input().split()))
lst = list(map(int, input().split()))
ans = []
for i in lst:
ans.append(abs(i-X))
small = min(ans)
for i in ans:
if i%small != 0:
while i%small != 0:
i = i%small
small = small - i
print(small) | p03262 |
def nl(): return list(map(int, input().split()))
def gcd(x, y):
if x < y:
# x >= y とする
x, y = y, x
while True:
r = x % y
if r == 0:
break
else:
x, y = y, r
return y
N, X = nl()
x = nl()
x2 = list(map(abs, ([v - X for v in x])))
g = x2[0]
for i in range(1, N):
g = gcd(g, x2[i])
print(g) | def gcd(x, y):
if x < y:# x >= y とする
x, y = y, x
r = x % y
res = y if r == 0 else gcd(y, r)
return res
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x2 = [abs(i - X) for i in x]
g = x2[0]
for i in x2:
g = gcd(g, i)
print(g) | p03262 |
def gcd(a, b):
if b == 0: return a
return gcd(b, a % b)
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x = sorted(x)
x = list([abs(arg - X) for arg in x])
g = x[0]
for xx in x:
g = gcd(g, xx)
print(g)
| def gcd(a, b):
if b == 0: return a
return gcd(b, a % b)
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x = list([abs(arg - X) for arg in x])
g = x[0]
for xx in x[1:]:
g = gcd(g, xx)
print(g)
| p03262 |
#coding: utf-8
from functools import reduce
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x = [abs(X - x[i]) for i in range(N)]
l = [x[0]]
for i in range(len(x)):
for j in range(i+1, len(x)):
l.append(gcd(max(x[i], x[j]), min(x[i], x[j])))
print((min(l))) | #coding: utf-8
from functools import reduce
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x = [abs(X - x[i]) for i in range(N)]
it = iter(x)
value = x[0]
for i in it:
value = gcd(value, i)
print(value) | p03262 |
from math import gcd
n, x = list(map(int, input().split()))
m = [x]+list(map(int, input().split()))
m.sort()
if n==1:
print((m[1]-m[0]))
else:
res = gcd(m[1]-m[0], m[2]-m[1])
for i in range(1, n-1):
a = m[i+1]-m[i]
b = m[i+2]-m[i+1]
if res >= gcd(a,b):
if res%gcd(a,b)==0:
res = gcd(a,b)
else:
res = gcd(res, gcd(a, b))
else:
if gcd(a,b)%res!=0:
res = gcd(res, gcd(a, b))
print(res) | import math
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))+[a]
x.sort()
if n==1:
print((abs(x[0]-x[1])))
exit()
res=x[1]-x[0]
for i in range(1,n):
res=math.gcd(res,x[i+1]-x[i])
print(res) | p03262 |
def gcd(A, B):
if A%B == 0:
return B
else:
return gcd(B, A%B)
N, X = list(map(int, input().split()))
x = [abs(int(i) - X) for i in input().split()]
if N == 1:
print((x[0]))
exit()
gcd_x = []
for i in range(N-1):
gcd_x.append(gcd(x[i], x[i+1]))
print((min(gcd_x))) | def gcd(A, B):
while B != 0:
A, B = B, A%B
return A
N, X = list(map(int, input().split()))
x = [abs(int(i) - X) for i in input().split()]
y = x[0]
for i in range(N):
if x[i] % y == 0:
continue
y = gcd(y, x[i])
print(y) | p03262 |
import sys
def main():
input = sys.stdin.readline
N, S = list(map(int, input().split()))
C = list(map(int, input().split()))
C = list(set([abs(c - S) for c in C]))
min_C = min(C)
ans = 1
for i in range(min_C, 1, -1):
if min_C % i != 0:
continue
if all([c % i == 0 for c in C]):
ans = i
break
print(ans)
if __name__ == '__main__':
main() | import sys
def gcd(a, b):
a, b = max(a, b), min(a, b)
if b == 0:
return a
else:
return gcd(b, a % b)
def main():
input = sys.stdin.readline
N, S = list(map(int, input().split()))
C = list(map(int, input().split()))
C = list(set([abs(c - S) for c in C]))
ans = C[0]
for i in range(1, len(C)):
ans = gcd(ans, C[i])
print(ans)
if __name__ == '__main__':
main()
| p03262 |
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
N, S = list(map(int,input().split()))
x = list(map(int,input().split()))
x.append(S)
x = sorted(x)
t = x[1]-x[0]
for k in range(N):
t = gcd(t,x[k+1]-x[k])
print(t) | N, X = list(map(int,input().split()))
x = list(map(int,input().split()))
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
ans = abs(X-x[0])
for k in range(1,N):
ans = gcd(ans,abs(x[k]-x[k-1]))
print(ans)
| p03262 |
values = input()
n,x = int(values.split(" ")[0]), int(values.split(" ")[1])
cities = input()
cities = [int(i) for i in cities.split(" ")]
distances = []
for i in cities:
distances.append(abs(i-x))
m = max(distances)
D = m
while(D<=m):
pos = x
flag = True
for i in range(len(cities)):
if cities[i]<pos:
k = (cities[i]-pos)/float(-D)
else:
k = (cities[i]-pos)/float(D)
if k!=int(k):
flag = False
pos = cities[i]
#print("\t",k, pos)
if flag == True:
print(D)
break
D -= 1 | values = input()
n,x = int(values.split(" ")[0]), int(values.split(" ")[1])
cities = input()
cities = [int(i) for i in cities.split(" ")]
cities = sorted(cities)
distances = []
for i in cities:
distances.append(abs(i-x))
for i in range(1,len(cities)):
distances.append(abs(cities[i]-cities[i-1]))
def hcd(a,b):
while b!=0:
t = b
b = a % b
a = t
return a
m = distances[0]
for i in range(1,len(distances)):
m = hcd(m, distances[i])
print(m) | p03262 |
N, X = [int(x) for x in input().split(' ')]
city = [abs(int(x) - X) for x in input().split(' ')]
max_fact = city[0]
for x in city:
while x!=0:
if x > max_fact:
x -= max_fact
elif x == max_fact:
break
else:
tmp = max_fact
max_fact = x
x = tmp
if max_fact==1:
break
print(max_fact) | N, X = [int(x) for x in input().split(' ')]
city = [abs(int(x) - X) for x in input().split(' ')]
max_fact = city[0]
for x in city:
while x!=0:
x %= max_fact
if x > 0:
tmp = max_fact
max_fact = x
x = tmp
if max_fact==1:
break
print(max_fact) | p03262 |
import math
def count_factor(factor, factors):
count = 0
# print("factor: " + str(factor))
# print(factors)
for f in factors:
if f == factor:
count += 1
return count
def divide_to_prime_factors(num):
factor = 1
factors = []
while factor <= math.sqrt(num):
if num % factor == 0:
factors.append(factor)
if factor * factor != num:
factors.append(int(num / factor))
factor += 1
return factors
n_and_x = input().split(" ")
city_num = int(n_and_x[0])
start = int(n_and_x[1])
city_places = [int(n) for n in input().split(" ")]
city_distances = []
for place in city_places:
city_distances.append(abs(place - start))
dist_factors = []
for dist in city_distances:
dist_factors.extend(divide_to_prime_factors(dist))
#print(dist_factors)
step = 1
for factor in dist_factors:
if factor > step:
fact_count = count_factor(factor, dist_factors)
# print(fact_count)
if fact_count == city_num:
step = factor
#step = int(max(city_distances) / 2)
#can_travel = False
#while can_travel == False:
# can_travel = True
# for city in city_places:
# if abs(city - start) % step != 0:
# can_travel = False
# if can_travel == False:
# step -= 1
print(step) | import math
def is_common(dists, factor):
count = 0
# print("factor: " + str(factor))
# print(factors)
# print(factor)
# print(factors[1:]
for dist in dists:
if dist % factor != 0:
return False
return True
def divide_to_prime_factors(num):
factor = 1
factors = []
while factor <= math.sqrt(num):
if num % factor == 0:
factors.append(factor)
if factor * factor != num:
factors.append(int(num / factor))
factor += 1
return factors
n_and_x = input().split(" ")
city_num = int(n_and_x[0])
start = int(n_and_x[1])
city_places = [int(n) for n in input().split(" ")]
city_distances = []
for place in city_places:
city_distances.append(abs(place - start))
dist_factors = reversed(sorted(divide_to_prime_factors(city_distances[0])))
step = 1
for fact in dist_factors:
if is_common(city_distances[1:], fact):
step = fact
break
# print(fact_count)
#step = int(max(city_distances) / 2)
#can_travel = False
#while can_travel == False:
# can_travel = True
# for city in city_places:
# if abs(city - start) % step != 0:
# can_travel = False
# if can_travel == False:
# step -= 1
print(step)
| p03262 |
n,x = list(map(int,input().split()))
xl = list(map(int,input().split()))
xl = [i-x for i in xl]
def gcd(a, b):
while b:
a, b = b, a % b
return a
ans = abs(xl[0])
for xx in xl:
ans = abs(gcd(ans, xx))
print(ans) | n,x = list(map(int,input().split()))
xl = list(map(int,input().split()))
xl = [abs(x-i) for i in xl]
# a,bの最大公約数
def gcd(a, b):
while b:
a, b = b, a % b
return a
ans = xl[0]
for x in xl:
ans = gcd(ans, x)
print(ans)
| p03262 |
import sys
N,X=list(map(int,input().split()))
x=list(map(int,input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
if N==1:
print((abs(X-x[0])))
sys.exit()
x.append(X)
x.sort()
ANS=gcd(x[1]-x[0],x[2]-x[1])
for i in range(N):
ANS=gcd(ANS,x[i+1]-x[i])
print(ANS)
| N,X=list(map(int,input().split()))
A=list(map(int,input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
s=abs(A[0]-X)
for i in range(1,N):
s=gcd(s,abs(A[i]-X))
print(s) | p03262 |
n, x = list(map(int, input().split()))
xi = list(map(int, input().split()))
diff = max(max(xi) - x, x - min(xi))
for d in range(diff, 1, -1):
xd = x%d
sol = True
for xval in xi:
if ((xval % d) - xd)%d != 0:
sol = False
break
if sol:
print(d)
break | n, x = list(map(int, input().split()))
xi = list(map(int, input().split()))
xi = [abs(xval - x) for xval in xi]
def gcd(a, b):
if a == 0:
return b
elif b == 0:
return a
else:
return gcd(b, a%b)
res = xi[0]
for i in range(1, len(xi)):
res = gcd(res, xi[i])
print(res) | p03262 |
def gcd(x,y):
if y>x:
a=y
y=x
x=a
a=1
while a*y:
a=x%y
x=y
y=a
return x
a,b=list(map(int,input().split()))
c=list(map(int,input().split()))
c.append(b)
c.sort()
for i in range(a):
c[-1-i]-=c[-2-i]
b=0
for i in range(a):
b=gcd(c[i+1],b)
print(b) | def gcd(x,y):
if y>x:
a=y
y=x
x=a
while y:
a=x%y
x=y
y=a
return x
a,b=list(map(int,input().split()))
c=list(map(int,input().split()))
c.append(b)
c.sort()
for i in range(a):
c[-1-i]-=c[-2-i]
b=0
for i in range(a):
b=gcd(c[i+1],b)
print(b) | p03262 |
n, x = list(map(int, input().split()))
l = list(map(int, input().split()))
def gcd(x, y):
while (y != 0):
x, y = y, x%y
return x
diff = []
for j in l:
diff.append(abs(j - x))
ans = diff[0]
for d in diff[1:]:
ans = gcd(ans, d)
print(ans)
| n, x = list(map(int, input().split()))
l = list(map(int, input().split()))
def gcd(x, y):
while (y != 0):
x, y = y, x%y
return x
ans = abs(l[0] - x)
for d in l[1:]:
ans = gcd(ans, abs(d - x))
print(ans)
| p03262 |
# encoding: utf-8
N, X = list(map(int, input().split()))
dx = list([x - X for x in list(map(int, input().split()))])
dx_nearest = 10**9
for dxi in dx:
if (2 *(dxi > 0) - 1) * dxi < dx_nearest: dx_nearest = (2 *(dxi > 0) - 1) * dxi
for D in range(dx_nearest + 1)[::-1]:
for dxi in dx:
if dxi % D > 0: break
else: continue
else:
print(D)
break
else: print("oops") | # encoding: utf-8
import math
N, X = list(map(int, input().split()))
x = sorted(list(map(int, input().split())) + [X])
def gcf2(a, b):
if b == 0: return a
else: return gcf2(b, (a % b))
# Greatest common factor
# print(x)
GCF = x[1] - x[0]
x_min = x[0]
for i, xi in enumerate(x):
if i == 0: continue
GCF = gcf2(GCF, (xi - x_min))
print(GCF) | p03262 |
# encoding: utf-8
import math
N, X = list(map(int, input().split()))
x = sorted(list(map(int, input().split())) + [X])
def gcf2(a, b):
if b == 0: return a
else: return gcf2(b, (a % b))
# Greatest common factor
# print(x)
GCF = x[1] - x[0]
x_min = x[0]
for i, xi in enumerate(x):
if i == 0: continue
GCF = gcf2(GCF, (xi - x_min))
print(GCF) | N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
# targ = []
# # targ.append(abs(X - x[0]))
# for i in range(N - 1):
# targ.append(abs(x[i + 1] - x[i]))
def mygcd(a, b):
# print("#", a, b)
if a < b: return mygcd(b, a)
elif b == 0: return a
else: return mygcd(b, a % b)
ans = abs(X - x[0])
for i in range(N - 1):
ans = mygcd(ans, abs(x[i + 1] - x[i]))
print(ans) | p03262 |
N,X=list(map(int,input().split()))
x=sorted([int(x)-X if int(x)-X>0 else -(int(x)-X) for x in input().split()])
for i in range(x[0]+1)[::-1]:
if sum([x%i for x in x])==0:
print(i)
break | N,X=list(map(int,input().split()))
x=sorted([int(x)-X if int(x)-X>0 else -(int(x)-X) for x in input().split()])
for i in range(x[0]+1)[::-1]:
if x[0]%i:continue
if sum([x%i for x in x])==0:
print(i)
break | p03262 |
from functools import reduce
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
for i in range(n):
x[i] -= X
x[i] = abs(x[i])
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def gcd_list(n):
return reduce(gcd, n)
print((gcd_list(x))) | from functools import reduce
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def gcd_list(n):
return reduce(gcd, n)
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
dx = [abs(X - i) for i in x]
print((gcd_list(dx))) | p03262 |
def make_divisors(n):
divisors = []
n=abs(n)
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return set(divisors)
def main():
n,m=list(map(int,input().split()))
x=list(map(int,input().split()))
s=make_divisors(x[0]-m)
for i in range(1,n):
s=s&make_divisors(x[i]-x[i-1])
print((max(s)))
main() | def make_divisors(n):
divisors = []
n=abs(n)
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return set(divisors)
def main():
n,m=list(map(int,input().split()))
x=list(map(int,input().split()))
s=make_divisors(x[0]-m)
news=[]
for i in range(1,n):
d=x[i]-x[i-1]
news=[]
for j in s:
if d%j==0:
news.append(j)
s=set(news)
print((max(s)))
main() | p03262 |
def gcd(p, q):
a, b = (p, q) if p >= q else (q, p)
c = a % b
while c != 0:
a, b = (b, c) if b >= c else (c, b)
c = a % b
return b
N, X = [int(x) for x in input().split()]
xn = sorted([int(x) for x in input().split()])
diffs = []
if X < xn[0]:
diffs.append(xn[0] -X)
for n in range(N-1):
if xn[n] < X < xn[n+1]:
diffs.append(X - xn[n])
diffs.append(xn[n+1] - X)
else:
diffs.append(xn[n+1] - xn[n])
if X > xn[N-1]:
diffs.append(X - xn[N-1])
if len(diffs) > 1:
D = gcd(diffs[0], diffs[1])
for i in range(N-2):
D = gcd(D, diffs[i+2])
else:
D = diffs[0]
print(D)
|
def gcd(x, y):
#assert x >= y
return gcd(y, x%y) if y else x
N, X = [int(i) for i in input().split()]
Xn = [int(i) for i in input().split()]
dx =[abs(x-X) for x in Xn]
gcd_num = dx[0]
for x in dx:
a, b = (gcd_num, x) if gcd_num > x else (x, gcd_num)
gcd_num = gcd(a, b)
print(gcd_num)
| p03262 |
n,x=list(map(int,input().split()))
huga=list(map(int,input().split()))
hoge=[]
for i in range(n):
hoge.append(abs(huga[i]-x))
hoge.sort(reverse=True)
D=hoge[0]
for i in range(D):
ans=D-i
flag=0
for j in range(n):
if(hoge[j]%ans>0):
flag=1
if(flag==0):
print(ans)
break | #ユークリッド互除法
def gcd(a,b):
if(a<b):
a,b=b,a
if(b==0):
return a
c= a%b
return gcd(b,c)
n,x=list(map(int,input().split()))
hoge=list(map(int,input().split()))
ans=abs(x-hoge[0])
for i in range(n):
ans=gcd(ans,abs(hoge[i]-x))
print(ans) | p03262 |
#abc110 C
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
distance = [ abs(x[i]-X) for i in range(N)]
for d in range(min(distance),0,-1):
flag = 1
for i in range(N):
if distance[i] % d != 0:
flag = 0
if flag == 1:
print(d)
break | #abc110 C 最大公約数
N, X = list(map(int, input().split()))
x= list(map(int, input().split()))
distance = [ abs(x[i]-X) for i in range(N)]
def gcd( x , y ):
while y != 0:
x,y = y, x%y
return x
def GCD(lis):
g = lis[0]
for i in range(1,len(lis)):
g = gcd( g , lis[i] )
return g
maxD = GCD(distance)
print(maxD) | p03262 |
from functools import reduce
def gcd(a, b):
while b:
a, b = b, a % b
return a
def gcd_n(numbers):
return reduce(gcd, numbers)
def main():
N, X, *x = list(map(int, open(0).read().split()))
x = [abs(X - int(i)) for i in x]
print((gcd_n(x)))
return
main()
| from functools import reduce
def gcd(a, b):
while b:
a, b = b, a % b
return a
def gcd_n(numbers):
return reduce(gcd, numbers)
def main():
N, X = list(map(int, input().split()))
x = [abs(X - int(i)) for i in input().split()]
print((gcd_n(x)))
return
main()
| p03262 |
def gcd(a, b):
while b:
a, b = b, a % b
return a
def main():
N, X, *xn = list(map(int, open(0).read().split()))
ans = None
for x in xn:
if ans is not None:
ans = gcd(ans, abs(X - x))
else:
ans = abs(X - xn[0])
print(ans)
return
main()
| def gcd(a, b):
while b:
a, b = b, a % b
return a
def main():
N, X, *xn = list(map(int, open(0).read().split()))
ans = None
for x in xn:
if ans is not None:
if abs(X - x) % ans:
ans = gcd(ans, abs(X - x))
else:
ans = abs(X - xn[0])
print(ans)
return
main()
| p03262 |
# coding: utf-8
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x%y)
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x.append(X)
x = sorted(x)
A = [ abs(x[i+1] - x[i]) for i in range(N)]
for i in range(len(A)):
if i == 0:
ans = A[i]
else:
ans = gcd(ans, A[i])
print(ans) | def gcd(x, y):
while y != 0:
x, y = y, x % y
return x
N, X = list(map(int, input().split()))
x = [int(a) for a in input().split()]
ans = 0
for xx in x:
ans = gcd(ans, abs(X - xx))
print(ans) | p03262 |
n,s = (int(i) for i in input().split())
x = list(int(i) for i in input().split())
x = sorted(x)
if n>1:
dif = []
for i in range(n-1):
dif.append(x[i+1]-x[i])
difs = []
for i in range(n):
difs.append(abs(s-x[i]))
res = min(min(dif),min(difs))
for i in range(res):
flag = True
for j in range(n-1):
if dif[j]%(res-i)!=0:
flag = False
break
if flag:
res -= i
break
print(res)
else:
print((abs(x[0]-s))) | N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
dist = [abs(x[0]-X)]
for i in range(N - 1):
dist.append(x[i + 1] - x[i])
# dist内の最大公約数を求めればよい
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
res = dist[0]
for i in range(1, N):
res = gcd(res, dist[i])
print(res) | p03262 |
def gcd(a,b):
while b != 0:
a, b = b, a%b
# print(a,b)
return(a)
def main():
N,X = list(map(int,input().split()))
x = list(map(int,input().split()))
for i in range(N):
x[i] = abs(x[i]-X)
while len(x) > 1:
# print(x[0],x[1])
y = gcd(x[0],x[1])
x.pop(0)
x.pop(0)
x.insert(0,y)
# print(x)
print((x[0]))
if __name__ == "__main__":
main() | def gcd(a,b):
while b != 0:
a, b = b, a%b
return(a)
def main():
N,X = list(map(int,input().split()))
x = list(map(int,input().split()))
for i in range(N):
x[i] = abs(x[i]-X)
y = x[0]
for i in range(N):
if x[i]%y == 0:
continue
y = gcd(y,x[i])
print(y)
if __name__ == "__main__":
main() | p03262 |
n=list(map(int,input().split()))
Y=list(map(int,input().split()))
XX=[abs(Y[i]-n[1]) for i in range(n[0])]
X=sorted(XX)
def gcd(x,y):
if y == 0:
return x
else:
return gcd(y, x%y)
for i in range(n[0]-1):
X[0]=gcd(X[0],X[1])
X=[X[0]]+X[2:]
print((max(X))) | n=list(map(int,input().split()))
Y=list(map(int,input().split()))
XX=[abs(Y[i]-n[1]) for i in range(n[0])]
X=sorted(XX)
def gcd(x,y):
if y == 0:
return x
else:
return gcd(y, x%y)
ans=X[0]
for i in range(n[0]-1):
ans=gcd(ans,X[i])
print(ans) | p03262 |
n, x = list(map(int, input().split()))
xlis = list(map(int, input().split()))
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b, a%b)
if n > 1:
d = gcd(abs(xlis[0]-x), abs(xlis[1]-x))
for i in range(2, n):
d = gcd(d, abs(xlis[i]-x))
print(d)
else:
print((abs(xlis[0] - x))) | n, x = list(map(int, input().split()))
xlis = list(map(int, input().split()))
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b, a%b)
d = 0
for i in range(n):
d = gcd(d, abs(xlis[i]-x))
print(d) | p03262 |
# abc109c
def gcd(a, b):
if a < b:
a, b = b, a
r = a % b
if r == 0:
return b
return gcd(r, b)
N,X = list(map(int,input().split()))
x = list(map(int,input().split()))
x.append(X)
x.sort()
diff = [x[1]-x[0]]
for i in range(N):
diff.append(x[i+1]-x[i])
D = gcd(diff[0],diff[1])
for i in range(2,N+1):
D = gcd(D,diff[i])
print(D) | def gcd(a, b):
if a < b:
a, b = b, a
r = a % b
if r == 0:
return b
return gcd(r, b)
N,X = list(map(int,input().split()))
x = list(map(int,input().split()))
x.append(X)
x.sort()
diff = [x[1]-x[0]]
for i in range(N):
diff.append(x[i+1]-x[i])
D = gcd(diff[0],diff[1])
for i in range(2,N+1):
D = gcd(D,diff[i])
print(D) | p03262 |
from functools import reduce
from math import gcd
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))
b = []
for ai in a:
b.append(abs(ai-x))
print((reduce(gcd,b))) | from functools import reduce
from math import gcd
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))
print((reduce(gcd,(abs(ai-x) for ai in a)))) | p03262 |
from functools import reduce
from math import gcd
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))
print((reduce(gcd,(abs(ai-x) for ai in a)))) | from functools import reduce
from math import gcd
n, x = list(map(int, input().split()))
print((reduce(gcd, (abs(ai - x) for ai in map(int,input().split())))))
| p03262 |
N, X = list(map(int,input().split()))
x = list(map(int,input().split()))
def gcd(m, n):
while n:
m, n = n, m%n
return m
sub_list = []
for i in range(N):
sub_list.append(abs(x[i] - X))
ans = sub_list[0]
for i in range(N):
if(sub_list[i]%ans != 0):
ans = gcd(ans, sub_list[i])
print(ans) | N, X = list(map(int,input().split()))
x = list(map(int,input().split()))
def gcd(m, n):
while n:
m, n = n, m%n
return m
subs = []
for i in range(N):
subs.append(abs(x[i] - X))
ans = subs[0]
for sub in subs:
if(sub%ans != 0):
ans = gcd(ans, sub)
print(ans) | p03262 |
N, X = list(map(int,input().split()))
x = list(map(int,input().split()))
def gcd(m, n):
while n:
m, n = n, m%n
return m
tmp = [abs(X-xx) for xx in x]
ans = tmp[0]
for i in range(1,N):
ans = gcd(ans, tmp[i])
print(ans) | def gcd(m, n):
while n:
m, n = n, m%n
return m
def ans():
N, X = list(map(int,input().split()))
x = list(map(int,input().split()))
xx = [abs(X-n) for n in x]
res = xx[0]
for i in range(1,N):
res = gcd(res, xx[i])
print(res)
ans() | p03262 |
N,X=list(map(int,input().split()))
x=list(map(int,input().split()))
diffx=[abs(X-x[i]) for i in range(N)]
minDiff=min(diffx)
isFinished=0
for i in range(minDiff,0,-1):
if minDiff%i==0:
canDivide=1
for j in range(N):
if diffx[j]%i:
canDivide=0
break
if canDivide:
print(i)
isFinished=1
break
if isFinished:
break
| N,X=list(map(int,input().split()))
x=list(map(int,input().split()))
diffx=[abs(X-x[i]) for i in range(N)]
def euclid(a,b):
if b==0:
return a
else:
return euclid(b,a%b)
gcd=diffx[0]
for i in range(1,N):
gcd=euclid(diffx[i],gcd)
print(gcd) | p03262 |
import sys
sys.setrecursionlimit(10**6)
import math
def ggcd(a):
if len(a)==0:
return 0
i=0
return math.gcd(a[i],ggcd(a[i+1:]))
n,x=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[]
for i in range(n-1):
b.append(abs(a[i]-a[i+1]))
c=ggcd(b)
d=abs(x-a[0])
print((math.gcd(c,d))) | n,x=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[]
if n==1 and x==a[0]:
print((max(x,10**9-x)))
exit()
for i in range(n):
b.append(abs(a[i]-x))
import math
c=0
for i in range(n):
c=math.gcd(c,b[i])
if c==1:
break
print(c) | p03262 |
N,X = list(map(int,input().split()))
L = list(map(int,input().split()))
for i in range(N):
L[i] = abs(L[i]-X)
L.sort()
L.reverse()
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
def listgcd(L):
p = L[0]
for i in range(1,N):
p = gcd(p,L[i])
return p
if len(L) >= 2:
print((listgcd(L)))
else:
print((L[0])) | N,X = list(map(int,input().split()))
L = list(map(int,input().split()))
for i in range(N):
L[i] = abs(L[i]-X)
L.sort()
def gcd(x,y):
while y != 0:
k = x
x = y
y = k%y
return x
cur = L[0]
for i in range(1,N):
cur = gcd(L[i],cur)
print(cur) | p03262 |
import sys
input = sys.stdin.readline
def gcd(a, b):
while a > 0:
if a < b:
a, b = b, a
a = a % b
return b
def main():
n, x = list(map(int, input().split()))
distance = (abs(x - int(y)) for y in input().split())
res = next(distance)
for d in distance:
res = gcd(res, d)
print(res)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def gcd(a, b):
while a > 0:
if a < b:
a, b = b, a
a = a % b
return b
def main():
n, x = list(map(int, input().split()))
town = list(map(int, input().split()))
distance = (abs(x-y) for y in town)
res = next(distance)
for d in distance:
if d % res != 0:
res = gcd(res, d)
print(res)
if __name__ == "__main__":
main() | p03262 |
def gcd(a, b):
if a < b:
a, b = b, a
while b > 0:
a = a % b
a, b = b, a
return a
def main():
n, x = list(map(int, input().split()))
town = list(map(int, input().split()))
distance = (abs(x-y) for y in town)
res = next(distance)
for d in distance:
if d % res != 0:
res = gcd(res, d)
print(res)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def gcd(a, b):
while a > 0:
if a < b:
a, b = b, a
a = a % b
return b
def main():
n, x = list(map(int, input().split()))
town = list(map(int, input().split()))
distance = (abs(x-y) for y in town)
res = next(distance)
for d in distance:
if d % res != 0:
res = gcd(res, d)
print(res)
if __name__ == "__main__":
main() | p03262 |
N,X=list(map(int,input().split()))
x=list(map(int,input().split()))
x.append(X)
x=sorted(x)
dif=[0]*(len(x)-1)
for i in range(len(x)-1):
dif[i]=x[i+1]-x[i]
def gcd(a,b):
if b>a:
a,b=b,a
while True:
if a%b==0:
return b
else:
a,b=b,a%b
ans=dif[0]
for i in range(1,len(dif)):
ans=gcd(ans,dif[i])
print(ans) | n,x=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
def gcd(a,b):
if a<b:
a,b=b,a
while a%b>0:
a,b=b,a%b
return b
ans=abs(x-p[0])
for i in range(1,n):
ans=gcd(ans,p[i]-p[i-1])
print(ans) | p03262 |
n,x=list(map(int,input().split()))
l=list(map(int,input().split()))
def make_divisor_list(num):
if num < 1:
return []
elif num == 1:
return [1]
else:
divisor_list = []
divisor_list.append(1)
for i in range(2, num // 2 + 1):
if num % i == 0:
divisor_list.append(i)
divisor_list.append(num)
return divisor_list
if n==1:
print((abs(x-l[0])))
else:
l.append(x)
minimum=min(l)
maximum=max(l)
delta=maximum-minimum
if delta==1:
print((1))
else:
kouho=make_divisor_list(delta)
ans=1
for num in kouho:
signal=1
j=0
while(j<n):
if (l[j]-minimum)%num!=0:
signal=0
break
else:
j+=1
if signal==1:
ans=num
print(ans)
| n,x=list(map(int,input().split()))
l=list(map(int,input().split()))
def gcd(a, b):
while b > 0:
a, b = b, a%b
return a
kouho=[abs(l[i]-x) for i in range(n)]
ans=kouho[0]
for i in range(n-1):
ans = gcd(ans,kouho[i+1])
print(ans) | p03262 |
N,X = list(map(int,input().split()))
list = [int(x) for x in input().split()]
list_dist = sorted([abs(x - X) for x in list])
def gcd(a, b):
if a < b:
a , b = b , a
while b:
a, b = b, a % b
return a
ans = list_dist[0]
for x in list_dist[1:]:
ans = gcd(ans,x)
print(ans) | N,X = list(map(int,input().split()))
list = list(map(int,input().split()))
diff = [abs(x - X) for x in list]
diff.sort()
def gcd(a,b):
while b:
a,b = b,a%b
return a
#差の最大公約数を取得
gcd_val = diff[0]
for i in diff[1:]:
gcd_val = gcd(i,gcd_val)
print(gcd_val)
| p03262 |
n, x = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort(reverse=True)
D = []
for i in range(len(X)):
dist = abs(x - X[i])
D.append(dist)
def gcd(i, j):
while j != 0:
i, j = j, i % j
return i
for i in range(len(D) - 1):
D[i + 1] = gcd(D[i], D[i + 1])
print((D[-1])) | n, x = list(map(int, input().split()))
city = list(map(int, input().split()))
D = []
for i in range(n):
dis = abs(x - city[i])
D.append(dis)
def gdc(x, y):
if x%y == 0:
return y
x, y = y, x%y
return gdc(x, y)
for i in range(n-1):
D[i + 1] = gdc(D[i], D[i + 1])
print((D[-1])) | p03262 |
import bisect
def gcd(x , y):
max_val = max(x , y)
min_val = min(x , y)
while min_val != 0:
max_val , min_val = min_val , max_val % min_val
return max_val
N , X = list(map(int,input().split()))
x = list(map(int,input().split()))
x.sort()
split_idx = bisect.bisect_left(x , X)
BeforeList = x[:split_idx]
AfterList = x[split_idx:]
now = X
ans = 0
DistanceList = []
for val in AfterList:
distance = abs(val - now)
DistanceList.append(distance)
now = val
for val in BeforeList:
distance = abs(val - now)
DistanceList.append(distance)
now = val
ans = DistanceList[0]
for i in range(1,len(DistanceList)):
ans = gcd(DistanceList[i] , ans)
print(ans) | def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x.insert(0, X)
distance = []
for i in range(1, len(x)):
distance.append(abs(x[i] - x[i - 1]))
ans = distance[0]
for i in range(1, len(distance)):
ans = gcd(distance[i], ans)
print(ans) | p03262 |
# coding: utf-8
# Here your code !
import sys
from collections import Iterable
import unittest
def top_face_after_rolling_dice():
try:
faces = [int(num) for num in input().rstrip().split()]
rollings = input().rstrip()
except:
return __input_error()
dice = CubicArbitraryValueDice(faces[0], faces[1], faces[2], faces[3], faces[4], faces[5])
dice.put(dice.TOP, dice.SOUTH, dice.EAST, dice.WEST, dice.NORTH, dice.BOTTOM)
for direction in rollings:
dice.roll(direction)
print((dice.faces[dice.direction[dice.TOP]]))
class CubicArbitraryValueDice():
TOP = "top"
BOTTOM = "bottom"
EAST = "E"
WEST = "W"
SOUTH = "S"
NORTH = "N"
OPOSITE_DIRECTION_PAIRS = ( (EAST, WEST), (SOUTH, NORTH) )
#??¢???index??§???????????????????????????
def __init__(self, n_f0, n_f1, n_f2, n_f3, n_f4, n_f5):
self.faces = [n_f0, n_f1, n_f2, n_f3, n_f4, n_f5]
#???????????¢???index?????¢??£??????
def put(self, dir_f0, dir_f1, dir_f2, dir_f3, dir_f4, dir_f5): #?????°????????£?????????
self.direction = { dir_fi : i for i,dir_fi in enumerate([dir_f0, dir_f1, dir_f2, dir_f3, dir_f4, dir_f5]) }
#??¢???index????????´
def roll(self, direction) : #dirction: (EAST, WEST, SOUTH, NORTH) ??????????????????
for pair in self.OPOSITE_DIRECTION_PAIRS :
if direction in pair :
oposite = pair[0] if (pair[1] == direction) else pair[1]
current = {}
for direct in (self.TOP, self.BOTTOM, direction, oposite):
current.update({direct : self.direction[direct]})
# direction to bottom, bottom to oposite, oposite to top, top to direction
for pair in ((direction, self.BOTTOM), (self.BOTTOM, oposite), (oposite, self.TOP), (self.TOP, direction)):
self.direction[pair[1]] = current[pair[0]]
def __input_error():
print("input error")
return -1
class __TestValueClass(unittest.TestCase):
def testEqual(self, func, tuples, eff_digit = None, print_success = False):
self.testFunction(self.assertEqual,func,tuples,eff_digit,print_success)
def testFunction(self,assertfunc,func,tuples,eff_digit,print_success):
#tuples[index] = ([*arguments of func], compared value)
for item in tuples:
try:
if isinstance(item[0], Iterable):
value = func(*item[0])
else:
value = func(item[0])
if eff_digit is None :
assertfunc(value,item[1])
else :
format_str = "{0:."+str(eff_digit)+"g}"
assertfunc(format_str.format(value),format_str.format(item[1]))
except Exception as msg:
swidth = 15
print(("="*50))
print(("-- Assertion Error in '" + func.__name__ + "' --"))
info = []
info.append(["arguments" , item[0] ])
info.append(["compared value", item[1] ])
info.append(["message" , "\n" + msg ])
for state in info :
print((state[0].ljust(swidth) + ":", state[1]))
sys.exit()
if print_success :
print((func.__name__,": succeeded"))
#test
if __name__ == "__main__" :
# test = __TestValueClass()
top_face_after_rolling_dice()
| # coding: utf-8
# Here your code !
from sys import exit
from collections import Iterable
from unittest import TestCase
#import numpy as np
def top_face_after_rolling_dice():
try:
faces = [int(num) for num in input().rstrip().split()]
rollings = input().rstrip()
except:
return __input_error()
dice = CubicArbitraryValueDice(faces[0], faces[1], faces[2], faces[3], faces[4], faces[5])
dice.put(dice.TOP, dice.SOUTH, dice.EAST, dice.WEST, dice.NORTH, dice.BOTTOM)
for operator in rollings:
dice.roll(operator)
print((dice.get_value(dice.TOP)))
class CubicArbitraryValueDice():
(TOP, BOTTOM, EAST, WEST, SOUTH, NORTH, RIGHT, LEFT) = ("top", "bottom", "E", "W", "S", "N", "R", "L")
(stVALUE, stDIRECTION) = ("value", "direction")
(plus_x, minus_x, plus_y, minus_y, plus_z, minus_z) = ( (1,0,0), (-1,0,0), (0,1,0), (0,-1,0), (0,0,1), (0,0,-1) )
# ROLL_x2y = np.array([ [ 0,-1, 0], [ 1, 0, 0], [ 0, 0, 1] ])
# ROLL_y2x = np.array([ [ 0, 1, 0], [-1, 0, 0], [ 0, 0, 1] ])
# ROLL_y2z = np.array([ [ 1, 0, 0], [ 0, 0,-1], [ 0, 1, 0] ])
# ROLL_z2y = np.array([ [ 1, 0, 0], [ 0, 0, 1], [ 0,-1, 0] ])
# ROLL_z2x = np.array([ [ 0, 0, 1], [ 0, 1, 0], [-1, 0, 0] ])
# ROLL_x2z = np.array([ [ 0, 0,-1], [ 0, 1, 0], [ 1, 0, 0] ])
ROLL_x2y = ( ( 0,-1, 0), ( 1, 0, 0), ( 0, 0, 1) )
ROLL_y2x = ( ( 0, 1, 0), (-1, 0, 0), ( 0, 0, 1) )
ROLL_y2z = ( ( 1, 0, 0), ( 0, 0,-1), ( 0, 1, 0) )
ROLL_z2y = ( ( 1, 0, 0), ( 0, 0, 1), ( 0,-1, 0) )
ROLL_z2x = ( ( 0, 0, 1), ( 0, 1, 0), (-1, 0, 0) )
ROLL_x2z = ( ( 0, 0,-1), ( 0, 1, 0), ( 1, 0, 0) )
DIRECTION = { EAST : plus_x, WEST : minus_x, NORTH : plus_y, SOUTH : minus_y, TOP : plus_z, BOTTOM : minus_z }
OPERATOR = { EAST : ROLL_z2x, WEST : ROLL_x2z, NORTH : ROLL_z2y, SOUTH : ROLL_y2z, RIGHT : ROLL_y2x, LEFT : ROLL_x2y }
#??¢???index??§?????????,???????????????
def __init__(self, n_f0, n_f1, n_f2, n_f3, n_f4, n_f5):
self.info = [ {self.stVALUE: n_fi} for n_fi in [n_f0, n_f1, n_f2, n_f3, n_f4, n_f5]]
def put(self, dir_f0, dir_f1, dir_f2, dir_f3, dir_f4, dir_f5): #?????°????????£?????????
for (info, dir_fi) in zip(self.info, [dir_f0, dir_f1, dir_f2, dir_f3, dir_f4, dir_f5]):
info[self.stDIRECTION] = self.DIRECTION[dir_fi]
def roll(self, operator) : #opetator: (EAST, WEST, SOUTH, NORTH, RIGHT, LEFT) ??????????????????
for info in self.info:
# info[self.stDIRECTION] = tuple( np.dot(self.OPERATOR[operator], np.array(info[self.stDIRECTION])))
vector = info[self.stDIRECTION]
matrix = self.OPERATOR[operator]
info[self.stDIRECTION] = tuple([sum( [matrix[row][col]*vector[col] for col in range(len(vector))] ) for row in range(len(matrix))])
def get_value(self, direction):
for info in self.info:
if info[self.stDIRECTION] == self.DIRECTION[direction] :
return info[self.stVALUE]
def get_direction(self, value):
for info in self.info:
if info[self.stVALUE] == value :
dir_key_values = list(self.DIRECTION.items())
for items in dir_key_values:
if info[self.stDIRECTION] in items:
return items[0]
def __input_error():
print("input error")
return -1
class __TestValueClass(TestCase):
def testEqual(self, func, tuples, eff_digit = None, print_success = False):
self.testFunction(self.assertEqual,func,tuples,eff_digit,print_success)
def testFunction(self,assertfunc,func,tuples,eff_digit,print_success):
#tuples[index] = ([*arguments of func], compared value)
for item in tuples:
try:
if isinstance(item[0], Iterable):
value = func(*item[0])
else:
value = func(item[0])
if eff_digit is None :
assertfunc(value,item[1])
else :
format_str = "{0:."+str(eff_digit)+"g}"
assertfunc(format_str.format(value),format_str.format(item[1]))
except Exception as msg:
swidth = 15
print(("="*50))
print(("-- Assertion Error in '" + func.__name__ + "' --"))
info = []
info.append(["arguments" , item[0] ])
info.append(["compared value", item[1] ])
info.append(["message" , "\n" + msg ])
for info_state in info :
print((info_state[0].ljust(swidth) + ":", info_state[1]))
exit()
if print_success :
print((func.__name__,": succeeded"))
#test
if __name__ == "__main__" :
# test = __TestValueClass()
top_face_after_rolling_dice()
| p02383 |
# -*- coding: utf-8 -*-
class dice_class:
def __init__(self, top, front, right, left, back, bottom):
self.top = top
self.front = front
self.right = right
self.left = left
self.back = back
self.bottom = bottom
def roll(self, s):
for i in s:
if i == 'E':
self.rollE()
elif i == 'N':
self.rollN()
elif i == 'S':
self.rollS()
elif i == 'W':
self.rollW()
def rollE(self):
tmp = self.top
self.top = self.left
self.left = self.bottom
self.bottom = self.right
self.right = tmp
def rollN(self):
tmp = self.top
self.top = self.front
self.front = self.bottom
self.bottom = self.back
self.back = tmp
def rollS(self):
tmp = self.top
self.top = self.back
self.back = self.bottom
self.bottom = self.front
self.front = tmp
def rollW(self):
tmp = self.top
self.top = self.right
self.right = self.bottom
self.bottom = self.left
self.left = tmp
if __name__ == "__main__":
a = list(map(int, input().split()))
s = str(input())
dice = dice_class(a[0], a[1], a[2], a[3], a[4], a[5])
dice.roll(s)
print(dice.top) | # -*- coding: utf-8 -*-
class dice_class:
def __init__(self, list):
self.num = list
def roll(self, s):
for i in s:
if i == 'E':
self.rollE()
elif i == 'N':
self.rollN()
elif i == 'S':
self.rollS()
elif i == 'W':
self.rollW()
def rollE(self):
self.num = [self.num[3], self.num[1], self.num[0], self.num[5], self.num[4], self.num[2]]
def rollN(self):
self.num = [self.num[1], self.num[5], self.num[2], self.num[3], self.num[0], self.num[4]]
def rollS(self):
self.num = [self.num[4], self.num[0], self.num[2], self.num[3], self.num[5], self.num[1]]
def rollW(self):
self.num = [self.num[2], self.num[1], self.num[5], self.num[0], self.num[4], self.num[3]]
if __name__ == "__main__":
dice = dice_class(list(map(int, input().split())))
s = str(input())
dice.roll(s)
print(dice.num[0]) | p02383 |
# AGC019B - Reverse and Compare
from collections import Counter
def main():
S = input().rstrip()
C, N = list(Counter(S).values()), len(S)
ans = N * (N - 1) // 2 + 1 # all possible patterns
ans -= sum(i * (i - 1) // 2 for i in C) # duplicates
print(ans)
if __name__ == "__main__":
main() | # AGC019B - Reverse and Compare
def main():
S = input().rstrip()
N = len(S)
ans = N * (N - 1) // 2 + 1 # all possible patterns
abc = "abcdefghijklmnopqrstuvwxyz"
for a in abc:
x = S.count(a)
ans -= x * (x - 1) // 2 # exclude duplicates
print(ans)
if __name__ == "__main__":
main() | p03618 |
num=input()
out=0
for i in range(len(num)):
#out+=num[i:].count(num(i))
#print len(num[i:])-num[i:].count(num[i])
out+=len(num[i:])-num[i:].count(num[i])
print(out+1) | num=input()
out=0
d={}
for i in set(num):
d[i]=num.count(i)
#print d
#aaa
for i in range(len(num)):
#out+=num[i:].count(num(i))
#print len(num[i:])-num[i:].count(num[i])
#out+=len(num[i:])-num[i:].count(num[i])
out+=len(num[i:])-d[num[i]]
d[num[i]]-=1
print(out+1)
| p03618 |
I = input()
import re
if re.match("^(a|i|u|e|o){1}$", I):
print('vowel', flush=True)
else:
print('consonant', flush=True)
| I = input()
import re
# if re.match("^(a|i|u|e|o){1}$", I):
if I in 'aiueo':
# if 'aiueo'.find(I):
print('vowel', flush=True)
else:
print('consonant', flush=True)
| p03852 |
# li = sorted(list(map(int, input().split())))
# n, m = map(int, input().split())
c = input()
print("vowel") if c in "aeiou" else print("consonant")
| print("vowel") if input() in "aeiou" else print("consonant")
| p03852 |
while True:
n = int(eval(input()))
if n == 0:break
to = []
for i in range(n):
line = list(map(int, input().split()))
for j in range(n):
x, y = line[2 * j:2 * j + 2]
to.append(y * n + x)
order = []
used = [False] * (n * n)
def dfs(x):
if used[x]:return
used[x] = True
dfs(to[x])
order.append(x)
for i in range(n * n):
dfs(i)
order.reverse()
def dfs2(x, used, group):
if used[x]:return False
if x in group:return True
group.add(x)
return dfs2(to[x], used, group)
used = [False] * (n * n)
ans = 0
for i in order:
group = set()
if not used[i]:
if dfs2(i, used, group):ans += 1
for g in group:used[g] = True
print(ans)
| while True:
n = int(eval(input()))
if n == 0:break
to = []
for i in range(n):
line = list(map(int, input().split()))
for j in range(n):
x, y = line[2 * j:2 * j + 2]
to.append(y * n + x)
order = []
used = [False] * (n * n)
def dfs(x):
if used[x]:return
used[x] = True
dfs(to[x])
order.append(x)
for i in range(n * n):
dfs(i)
order.reverse()
def dfs2(x, used, group):
if x in group:return True
if used[x]:return False
group.add(x)
used[x] = True
return dfs2(to[x], used, group)
used = [False] * (n * n)
ans = 0
for i in order:
group = set()
if not used[i]:
if dfs2(i, used, group):ans += 1
print(ans)
| p01334 |
import collections
import sys
input = sys.stdin.readline
class AtCoder:
def main(self):
S = input().rstrip()
K = int(eval(input()))
if len(S) == 1:
print((K // 2))
exit()
ans = 0
start = 0
end = len(S)
cnt_1 = 1
cnt_2 = 1
if len(collections.Counter(S)) == 1:
print(((len(S) * K) // 2))
exit()
if S[0] == S[-1]:
for i in range(1, len(S) - 1):
if S[i] != S[0]:
start = i
break
else:
cnt_1 += 1
for i in range(1, len(S) - 1)[::-1]:
if S[i] != S[0]:
end = i + 1
break
else:
cnt_2 += 1
ans += (cnt_1 // 2) + ((cnt_1 + cnt_2) // 2) * (K - 1) + (cnt_2 // 2)
before = S[start]
length = 1
changes = 0
for i in range(start + 1, end):
if S[i] == before:
length += 1
else:
changes += length // 2
length = 1
before = S[i]
changes += length // 2
ans += changes * K
print(ans)
# Run main
if __name__ == '__main__':
AtCoder().main()
| import collections
import sys
input = sys.stdin.readline
class AtCoder:
def main(self):
S = input().rstrip()
K = int(eval(input()))
if len(collections.Counter(S)) == 1:
print(((len(S) * K) // 2))
exit()
k1 = self.connection_and_disconnection(S)
k2 = self.connection_and_disconnection(S * 2)
ans = k1 + (k2 - k1) * (K - 1)
print(ans)
def connection_and_disconnection(self, S: str):
S = S + '$'
cont_same_letter = 1
need_to_change = 0
for i in range(len(S) - 1):
if S[i] == S[i + 1]:
cont_same_letter += 1
else:
need_to_change += cont_same_letter // 2
cont_same_letter = 1
return need_to_change
# Run main
if __name__ == '__main__':
AtCoder().main()
| p02891 |
import sys
input = sys.stdin.readline
s = input().rstrip()
k = int(eval(input()))
def check_count(s):
cnt_list = [1]
cnt = 1
for i in range(1, len(s)):
if s[i-1] == s[i]:
cnt_list[-1] += 1
else:
cnt_list.append(1)
return cnt_list
def calc_ans(cnt_list, k):
_ans = 0
for c in cnt_list:
_ans += c//2
return(_ans * k)
if len(s)==1:
ans = k//2
else:
cnt_list = check_count(s)
if len(cnt_list)==1:
ans = (len(s)*k)//2
else:
ans = calc_ans(cnt_list, k)
if s[0]==s[-1]:
if cnt_list[0]%2==1 and cnt_list[-1]%2==1:
ans += k - 1
print(ans) | import sys
input = sys.stdin.readline
s = input().rstrip()
k = int(eval(input()))
def check_count(s):
cnt_list = []
cnt = 1
for i in range(1, len(s)):
if s[i-1] == s[i]:
cnt += 1
else:
cnt_list.append(cnt)
cnt = 1
if cnt>1:
cnt_list.append(cnt)
return cnt_list
def calc_ans(cnt_list, k):
_ans = 0
for c in cnt_list:
_ans += c//2
return(_ans * k)
if len(s)==1:
ans = k//2
else:
cnt_list = check_count(s)
if len(cnt_list)==1:
ans = (len(s)*k)//2
else:
ans = calc_ans(cnt_list, k)
if s[0]==s[-1]:
if cnt_list[0]%2==1 and cnt_list[-1]%2==1:
ans += k - 1
print(ans) | p02891 |
def f(k):
T = S*k
N = len(T)
cur = T[0]
cnt = 1
ans = 0
for i in range(1,N):
if T[i]==cur:
cnt += 1
else:
ans += cnt//2
cur = T[i]
cnt = 1
ans += cnt//2
return ans
S = input().strip()
K = int(eval(input()))
ans1 = f(1)
ans2 = f(2)
ans3 = f(3)
d1 = f(2)-f(1)
d2 = f(3)-f(2)
k = (K-1)//2
if (K-1)%2==0:
print((f(1)+(d1+d2)*k))
else:
print((f(1)+(d1+d2)*k+d1)) | C = {}
S = input().strip()
N = len(S)
K = int(eval(input()))
for i in range(N):
s = S[i]
if s not in C:
C[s]=0
C[s] += 1
if len(C)>1:
a = 0
cnt = 1
for i in range(1,N):
if S[i]==S[i-1]:
cnt += 1
else:
a += cnt//2
cnt = 1
a += cnt//2
X = S+S
b = 0
cnt = 1
for i in range(1,2*N):
if X[i]==X[i-1]:
cnt += 1
else:
b += cnt//2
cnt = 1
b += cnt//2
d = b-a
print((a+d*(K-1)))
else:
A = list(C.items())
k = A[0][1]
if k%2==0:
print(((k//2)*K))
else:
if K%2==0:
a = k
b = 2*k
d = k
print((a+d*((K//2)-1)))
else:
a = k//2
b = (k*3)//2
d = b-a
print((a+d*(K//2))) | p02891 |
from sys import stdin
from itertools import groupby
S = stdin.readline().rstrip()
K = int(stdin.readline().rstrip())
l = len(S)
# Run Length Encoding
rle = [len(list(g)) for k, g in groupby(S)]
if len(set(S)) == 1:
print((len(S) * K //2))
else:
tmp_ans = sum([l // 2 for l in rle])*K
if S[0] != S[-1]:
print(tmp_ans)
else:
print((tmp_ans - (rle[0] // 2 + rle[-1] // 2 - (rle[0] + rle[-1]) // 2) * (K-1))) | from sys import stdin
from itertools import groupby
S = stdin.readline().rstrip()
K = int(stdin.readline().rstrip())
l = len(S)
# Run Length Encoding
rle = [(k, sum(1 for _ in g)) for k, g in groupby(S)]
if len(set(S)) == 1:
print((len(S) * K // 2))
else:
tmp_ans = sum([t[1] // 2 for t in rle])*K
if S[0] != S[-1]:
print(tmp_ans)
else:
print((tmp_ans - (rle[0][1] // 2 + rle[-1][1] // 2 - (rle[0][1] + rle[-1][1]) // 2) * (K-1))) | p02891 |
from itertools import*
s,k=open(0)
k,x=int(k),0
g=[len(list(v))for _,v in groupby(s)]
for c in g:x+=c//2
x*=k
if(s[0]==s[-2])*g[0]%2&g[-2]%2:x+=k//2if-len(s)==~g[0]else k-1
print(x) | from itertools import*
s,k=open(0)
k=int(k)
g=[len(list(v))for _,v in groupby(s)]
print((sum(c//2for c in g)*k+((s[0]==s[-2])*g[0]%2&g[-2]%2)*(k//2*(-len(s)==~g[0])or k-1))) | p02891 |
from itertools import*
s,k=open(0)
k=int(k)
g=[len(list(v))for _,v in groupby(s)]
print((sum(c//2for c in g)*k-((s[0]==s[-2])*g[0]%2&g[-2]%2)*(-k//2**(len(s)-1==g[0])+1))) | from itertools import*
s,k=open(0)
k=int(k)
g=[len(list(v))for _,v in groupby(s)]
print((sum(c//2for c in g)*k-(g[0]%2*g[-2]%2*s[0]==s[-2])*(-k//2**(len(s)-1==g[0])+1))) | p02891 |
from itertools import*
s,k=open(0)
k=int(k)
g=[len(list(v))for _,v in groupby(s)]
print((sum(c//2for c in g)*k-(g[0]%2*g[-2]%2*s[0]==s[-2])*(-k//2**(len(s)-1==g[0])+1))) | from itertools import*
s,k=open(0)
k=int(k)
g=[len(list(v))for _,v in groupby(s)]
print((sum(c//2for c in g)*k-(g[0]*g[-2]%2*s[0]==s[-2])*(-k//2**(len(s)-1==g[0])+1))) | p02891 |
from itertools import*
s,k=open(0)
k=int(k)
g=[len(list(v))for _,v in groupby(s)]
print((sum(c//2for c in g)*k+((g[0]*g[-2]%2*s[0]==s[-2])*~-k>>(len(s)-1==g[0])))) | from itertools import*
s,k=open(0)
k=int(k)
g=[len(list(v))for _,v in groupby(s)]
print((sum(c//2for c in g)*k+((g[0]*g[-2]%2*s[0]==s[-2])*~-k>>(len(s)-2<g[0])))) | p02891 |
# 75
import sys
sys.setrecursionlimit(10**8)
MOD = 10**9+7
N = int(eval(input()))
g_l = [[] for i in range(N)]
check_l = [-1] * N
num_l = [0] * N
for i in range(N-1):
ai, bi = list(map(int, input().split()))
g_l[ai-1].append(bi-1)
g_l[bi-1].append(ai-1)
def dfs(n):
d = 1
if check_l[n] > 0:
return num_l[n]
check_l[n] = 1
for next_n in g_l[n]:
d += dfs(next_n)
num_l[n] = d
return d
def modpow(a, n):
# calc : (a**n)%MOD
ret = 1
while n > 0:
if n & 1:
ret = (ret * a) % MOD
a = (a * a) % MOD
n >>= 1
return ret
def modinv(a):
# calc : (a**(-1)) %MOD
return modpow(a, MOD-2)
dfs(0)
ans = 0
# for i in range(1, N):
# ans += (1 - (1/2)**num_l[i]) * (1 - (1/2)**(N-num_l[i]))
# ans += 1 - (1/2)**N # 辺の期待値→頂点の期待値に変換(空集合以外は+1される)
# ans -= N/2 # 黒点の期待値を引く
for i in range(1, N):
ans = (ans + (pow(2, num_l[i], MOD)-1) *
(pow(2, N-num_l[i])-1) % MOD) % MOD
ans = (ans + (pow(2, N, MOD) - 1) - (N * pow(2, N-1, MOD)) % MOD) % MOD
y = ans
x = pow(2, N, MOD)
z = (y * modinv(x)) % MOD
print(z)
| # 75
import sys
sys.setrecursionlimit(10**8)
MOD = 10**9+7
N = int(eval(input()))
g_l = [[] for i in range(N)]
check_l = [-1] * N
num_l = [0] * N
for i in range(N-1):
ai, bi = list(map(int, input().split()))
g_l[ai-1].append(bi-1)
g_l[bi-1].append(ai-1)
def dfs(n):
d = 1
if check_l[n] > 0:
return num_l[n]
check_l[n] = 1
for next_n in g_l[n]:
d += dfs(next_n)
num_l[n] = d
return d
def modinv(a):
# calc : (a**(-1)) %MOD
return pow(a, MOD-2, MOD)
def solve():
dfs(0)
pow_l = [None]*(N+1)
pow_l[0] = 1
for i in range(1, N+1):
pow_l[i] = (pow_l[i-1] * 2) % MOD
ans = 0
# for i in range(1, N):
# ans += (1 - (1/2)**num_l[i]) * (1 - (1/2)**(N-num_l[i]))
# ans += 1 - (1/2)**N # 辺の期待値→頂点の期待値に変換(空集合以外は+1される)
# ans -= N/2 # 黒点の期待値を引く
for i in range(1, N):
ans = (ans + (pow_l[num_l[i]]-1) *
(pow_l[N-num_l[i]]-1) % MOD) % MOD
ans = (ans + (pow_l[N] - 1) - (N * pow_l[N-1]) % MOD) % MOD
y = ans
x = pow(2, N, MOD)
z = (y * modinv(x)) % MOD
print(z)
solve()
| p02822 |
import sys
sys.setrecursionlimit(10**6)
from collections import defaultdict
mod = 10**9+7
N = int(eval(input()))
g = [[] for _ in range(N)]
d = defaultdict(lambda:-1)
p2 = [1]*(N+1)
p2[1] = pow(2,mod-2,mod)
for i in range(N):
p2[i+1] = (p2[i]*p2[1])%mod
for i in range(N-1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
def dfs(i,j):
if d[(i,j)]!=-1:
return d[(i,j)]
res = 1
for k in g[j]:
if k==i:
continue
res += dfs(j,k)
d[(i,j)] = res
return res
for i in range(N):
if len(g[i])==1:
dfs(i,g[i][0])
break
ans = 1-p2[N]-N*p2[1]
for i in range(N):
for j in g[i]:
if j<i:
continue
n = max(d[(i,j)],d[(j,i)])
ans += (1-p2[n])*(1-p2[N-n])
ans %= mod
print(ans) | from collections import defaultdict,deque
mod = 10**9+7
N = int(eval(input()))
g = [[] for _ in range(N)]
d = defaultdict(lambda:-1)
p2 = [1]*(N+1)
p2[1] = pow(2,mod-2,mod)
for i in range(N):
p2[i+1] = (p2[i]*p2[1])%mod
for i in range(N-1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
q = deque([[a,b]])
while q:
i,j = q.pop()
s = 1
f = True
for k in g[j]:
if k == i:
continue
if (j,k) not in d:
if f:
q.append([i,j])
q.append([j,k])
f = False
else:
s += d[(j,k)]
if f:
d[(i,j)] = s
q = deque([[b,a]])
while q:
i,j = q.pop()
s = 1
f = True
for k in g[j]:
if k == i:
continue
if (j,k) not in d:
if f:
q.append([i,j])
q.append([j,k])
f = False
else:
s += d[(j,k)]
if f:
d[(i,j)] = s
ans = 1-p2[N]-N*p2[1]
for i in range(N):
for j in g[i]:
if j<i:
continue
n = max(d[(i,j)],d[(j,i)])
ans += (1-p2[n])*(1-p2[N-n])
ans %= mod
print(ans) | p02822 |
# ref https://qiita.com/ZhangChaoran/items/71fab0e4b8647a93d3a0
from collections import deque
import sys
input = sys.stdin.readline
n = int(eval(input()))
g = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
g[a].append(b)
g[b].append(a)
mod = 10**9 + 7
par = [0] * (n + 1)
order = []
stk = deque()
stk.append(1)
while stk:
v = stk.pop()
order.append(v)
for x in g[v]:
if x == par[v]:
continue
par[x] = v
stk.append(x)
rev = pow(2, mod - 2, mod)
po2_inv = [1] * (n + 1)
size = [1] * (n + 1)
for i, y in enumerate(order[::-1], 1):
p = par[y]
size[p] += size[y]
po2_inv[i] = po2_inv[i - 1] * rev % mod
ans = 1
for i in size[2:]:
ans += (1 - po2_inv[i] - po2_inv[n - i] + po2_inv[n]) % mod
ans -= po2_inv[n] + n * po2_inv[1]
ans %= mod
print(ans)
| # ref https://qiita.com/ZhangChaoran/items/71fab0e4b8647a93d3a0
from collections import deque
import sys
input = sys.stdin.readline
n = int(eval(input()))
g = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
g[a].append(b)
g[b].append(a)
mod = 10**9 + 7
par = [0] * (n + 1)
order = []
stk = deque()
stk.append(1)
while stk:
v = stk.pop()
order.append(v)
for x in g[v]:
if x == par[v]:
continue
par[x] = v
stk.append(x)
rev = (mod + 1) // 2
po2_inv = [1] * (n + 1)
size = [1] * (n + 1)
for i, y in enumerate(order[::-1], 1):
p = par[y]
size[p] += size[y]
po2_inv[i] = po2_inv[i - 1] * rev % mod
ans = 1
for i in size[2:]:
ans += (1 - po2_inv[i] - po2_inv[n - i] + po2_inv[n]) % mod
ans -= po2_inv[n] + n * po2_inv[1]
ans %= mod
print(ans)
| p02822 |
import sys
from itertools import accumulate
sys.setrecursionlimit(10 ** 5)
def dfs1(v, p):
parent[v] = p
stc = subtree_count[v]
cnt = 1
for u in links[v]:
if u == p:
continue
result = dfs1(u, v)
stc[u] = result
cnt += result
return cnt
def dfs2(v, pc):
# pc: vを根とした時の、parent方面の部分木のノード数
global ans
if len(subtree_count[v]) == 0:
return
p = parent[v]
children, st_counts = list(map(list, list(zip(*list(subtree_count[v].items())))))
children.append(p)
st_counts.append(pc)
cl = len(st_counts)
ct = sum(st_counts)
for u, stc in list(subtree_count[v].items()):
dfs2(u, ct - stc + 1)
if cl == 1:
return
prob_fwd = [0] + list(accumulate(st_counts[:-1]))
prob_bwd = [0] + list(accumulate(st_counts[-1:0:-1]))
prob_bwd.reverse()
tmp = 0
for pf, pb in zip(prob_fwd, prob_bwd):
tmp = (tmp + d2s[pf + pb]) % MOD
tmp = (tmp - d2s[ct] * (cl - 1)) % MOD
ans = (ans + (1 - tmp) * d2) % MOD
n = int(eval(input()))
links = [set() for _ in range(n)]
for line in sys.stdin:
a, b = list(map(int, line.split()))
a -= 1
b -= 1
links[a].add(b)
links[b].add(a)
root = 0
parent = [-1] * n
subtree_count = [{} for _ in range(n)] # 根がrootの時の、vの子の各部分木のノード数
MOD = 10 ** 9 + 7
d2 = 500000004 # 2^-1 mod 10**9+7
d2s = [1]
for i in range(n):
d2s.append(d2s[-1] * d2 % MOD)
ans = 0
dfs1(root, -1)
# print(parent)
# print(subtree_count)
dfs2(root, 0)
print(ans)
| import sys
sys.setrecursionlimit(200001)
def dfs1(v, p):
parent[v] = p
stc = subtree_count[v]
cnt = 1
for u in links[v]:
if u == p:
continue
result = dfs1(u, v)
stc[u] = result
cnt += result
return cnt
def dfs2(v, pc):
# pc: vを根とした時の、parent方面の部分木のノード数
global ans
if len(subtree_count[v]) == 0:
return
p = parent[v]
children, st_counts = list(map(list, list(zip(*list(subtree_count[v].items())))))
children.append(p)
st_counts.append(pc)
cl = len(st_counts)
ct = sum(st_counts)
for u, stc in list(subtree_count[v].items()):
dfs2(u, ct - stc + 1)
if cl == 1:
return
tmp = 0
for stc in st_counts:
tmp = (tmp + d2s[ct - stc]) % MOD
tmp = (tmp - d2s[ct] * (cl - 1)) % MOD
ans = (ans + (1 - tmp) * d2) % MOD
n = int(eval(input()))
links = [set() for _ in range(n)]
for line in sys.stdin:
a, b = list(map(int, line.split()))
a -= 1
b -= 1
links[a].add(b)
links[b].add(a)
root = 0
parent = [-1] * n
subtree_count = [{} for _ in range(n)] # 根がrootの時の、vの子の各部分木のノード数
MOD = 10 ** 9 + 7
d2 = 500000004 # 2^-1 mod 10**9+7
d2s = [1]
for i in range(n):
d2s.append(d2s[-1] * d2 % MOD)
ans = 0
dfs1(root, -1)
# print(parent)
# print(subtree_count)
dfs2(root, 0)
print(ans)
| p02822 |
import sys
readline = sys.stdin.readline
class Segtree:
def __init__(self, A, intv, initialize = True, segf = max):
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.intv = intv
self.segf = segf
if initialize:
self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)
for i in range(self.N0-1, 0, -1):
self.data[i] = self.segf(self.data[2*i], self.data[2*i+1])
else:
self.data = [intv]*(2*self.N0)
def update(self, k, x):
k += self.N0
self.data[k] = x
while k > 0 :
k = k >> 1
self.data[k] = self.segf(self.data[2*k], self.data[2*k+1])
def query(self, l, r):
L, R = l+self.N0, r+self.N0
s = self.intv
while L < R:
if R & 1:
R -= 1
s = self.segf(s, self.data[R])
if L & 1:
s = self.segf(s, self.data[L])
L += 1
L >>= 1
R >>= 1
return s
def binsearch(self, l, r, check, reverse = False):
L, R = l+self.N0, r+self.N0
SL, SR = [], []
while L < R:
if R & 1:
R -= 1
SR.append(R)
if L & 1:
SL.append(L)
L += 1
L >>= 1
R >>= 1
if reverse:
for idx in (SR + SL[::-1]):
if check(self.data[idx]):
break
else:
return -1
while idx < self.N0:
if check(self.data[2*idx+1]):
idx = 2*idx + 1
else:
idx = 2*idx
return idx - self.N0
else:
for idx in (SL + SR[::-1]):
if check(self.data[idx]):
break
else:
return -1
while idx < self.N0:
if check(self.data[2*idx]):
idx = 2*idx
else:
idx = 2*idx + 1
return idx - self.N0
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
MOD = 10**9+7
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, readline().split()))
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
pow2 = [1]*(N+3)
for i in range(1, len(pow2)):
pow2[i] = (2*pow2[i-1])%MOD
P, L = parorder(Edge, 0)
C = getcld(P)
dp1 = [0]*N
dp2 = [0]*N
size = [1]*N
for p in L[::-1]:
sr = 1
for c in C[p]:
sr += size[c]
size[p] = sr
res1 = pow2[size[p]-1]-1
res2 = pow2[size[p]-1]-1
for c in C[p]:
k = pow2[size[p]-1-size[c]]
res1 = (res1 - (pow2[size[c]]-1) + dp1[c] + dp2[c]*(2*k-1))%MOD
res2 = (res2 + 2*k*dp2[c])
dp1[p] = res1
dp2[p] = res2
print((dp1[0]*pow(pow(2, N, MOD), MOD-2, MOD)%MOD)) | import sys
readline = sys.stdin.readline
class Segtree:
def __init__(self, A, intv, initialize = True, segf = max):
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.intv = intv
self.segf = segf
if initialize:
self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)
for i in range(self.N0-1, 0, -1):
self.data[i] = self.segf(self.data[2*i], self.data[2*i+1])
else:
self.data = [intv]*(2*self.N0)
def update(self, k, x):
k += self.N0
self.data[k] = x
while k > 0 :
k = k >> 1
self.data[k] = self.segf(self.data[2*k], self.data[2*k+1])
def query(self, l, r):
L, R = l+self.N0, r+self.N0
s = self.intv
while L < R:
if R & 1:
R -= 1
s = self.segf(s, self.data[R])
if L & 1:
s = self.segf(s, self.data[L])
L += 1
L >>= 1
R >>= 1
return s
def binsearch(self, l, r, check, reverse = False):
L, R = l+self.N0, r+self.N0
SL, SR = [], []
while L < R:
if R & 1:
R -= 1
SR.append(R)
if L & 1:
SL.append(L)
L += 1
L >>= 1
R >>= 1
if reverse:
for idx in (SR + SL[::-1]):
if check(self.data[idx]):
break
else:
return -1
while idx < self.N0:
if check(self.data[2*idx+1]):
idx = 2*idx + 1
else:
idx = 2*idx
return idx - self.N0
else:
for idx in (SL + SR[::-1]):
if check(self.data[idx]):
break
else:
return -1
while idx < self.N0:
if check(self.data[2*idx]):
idx = 2*idx
else:
idx = 2*idx + 1
return idx - self.N0
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
MOD = 10**9+7
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, readline().split()))
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
pow2 = [1]*(N+3)
for i in range(1, len(pow2)):
pow2[i] = (2*pow2[i-1])%MOD
P, L = parorder(Edge, 0)
dp1 = [0]*N
dp2 = [0]*N
size = [1]*N
for l in L[:0:-1]:
p = P[l]
size[p] += size[l]
for l in L[:0:-1]:
p = P[l]
dp1[l] = (dp1[l] + pow2[size[l]-1] - 1)%MOD
dp2[l] = (dp2[l] + pow2[size[l]-1] - 1)%MOD
k = pow2[size[p]-1-size[l]]
dp1[p] = (dp1[p] - (pow2[size[l]]-1) + (2*k-1)*dp2[l] + dp1[l])%MOD
dp2[p] = (dp2[p] + 2*dp2[l]*k)%MOD
dp1[0] = (dp1[0] + pow2[size[0]-1] - 1)%MOD
print((dp1[0]*pow(pow(2, N, MOD), MOD-2, MOD)%MOD))
| p02822 |
p = 1000000007
N = int(eval(input()))
T = [[] for _ in range(N)]
for _ in range(N - 1):
(a, b) = (int(x) - 1 for x in input().split())
T[a].append(b)
T[b].append(a)
P = [-1] * N
P[0] = 0
Q = [0]
for i in range(N):
q = Q[i]
for adj in T[q]:
if 0 <= P[adj]:
continue
P[adj] = q
Q.append(adj)
ST = [[] for _ in range(N)]
for q in Q[N - 1:0:-1]:
s = sum(ST[q]) + 1
ST[P[q]].append(s)
ST[q].append(N - s)
B = [pow(1 << i, p - 2, p) for i in range(N)]
H = [0] * N
ans = 0
for S in ST:
ans += B[1] * ((1 - B[-1] - sum([(B[N - 1 - s] * (1 - B[s])) % p for s in S])) % p)
ans %= p
print(ans) | p = 1000000007
N = int(eval(input()))
T = [[] for _ in range(N)]
for _ in range(N - 1):
(a, b) = (int(x) - 1 for x in input().split())
T[a].append(b)
T[b].append(a)
P = [-1] * N
P[0] = 0
Q = [0]
for i in range(N):
q = Q[i]
for adj in T[q]:
if 0 <= P[adj]:
continue
P[adj] = q
Q.append(adj)
ST = [[] for _ in range(N)]
for q in Q[N - 1:0:-1]:
s = sum(ST[q]) + 1
ST[P[q]].append(s)
ST[q].append(N - s)
B = [1] * N
B[-1] = pow(1 << (N - 1), p - 2, p)
for i in range(N - 1, 0, -1):
B[i - 1] = B[i] * 2 % p
H = [0] * N
ans = 0
for S in ST:
ans += B[1] * ((1 - B[-1] - sum([(B[N - 1 - s] * (1 - B[s])) % p for s in S])) % p)
ans %= p
print(ans) | p02822 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
from argparse import ArgumentParser
args=ArgumentParser()
args.add_argument('-loc', '--local', type=bool,default=False)
LOCAL=args.parse_args().local
def input():
x=sys.stdin.readline();
if x[-1]=="\n":
return x.rstrip()
return x
def printe(*x):_=print("## ",*x,file=sys.stderr) if LOCAL else 0
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)]
def binr(x): return bin(x)[2:]
def bitcount(x): #xは64bit整数
x= x - ((x >> 1) & 0x5555555555555555)
x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x+= (x >> 8); x+= (x >> 16); x+= (x >> 32)
return x & 0x7f
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef func,および親の追加処理def addnode設定すること
#tot[親]:すべての子の値の累計
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=0
self.edge=edge
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
self._forward(0)
def func(self,x,y):
return x+y
def addnode(self,x):#辺(距離)に関するdpのとき必要
return x+1
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[1:]):
pa=par[e]
ans=self.unit
de=self.dics[e]
for val in de.values():
ans=self.func(ans,val)
self.dics[pa][e]=self.addnode(ans)
def _forward(self,start):
self._dfs(start)
for e in self.ikigake:
pa=self.par[e]
nes=list(self.dics[e].keys())
nvals=list(self.dics[e].values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
for i in range(l-1):
aleft.append(self.func(aleft[-1],nvals[i]))
aright.append(self.func(aright[-1],nvals[-i-1]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.addnode(self.func(aleft[i],aright[-1-i]))
self.tot[e]=self.func(aright[-1],nvals[0])
return self.dics
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=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)) #改行行列
edge = [[] for i in range(N)]
for i in range(N-1):#木の場合M=N-1
a,b= map(int,input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1) #有向のばあいコメントアウト
rt=rerooting(N,edge)
d=rt.dics
tot=rt.tot
i2=pow(2,mod-2,mod)
i2n=pow(i2,N,mod)
i2n1=pow(i2,N-1,mod)
ans=0
cur0=(i2-i2n)%mod
p2=[pow(2,i,mod) for i in range(N+1)]
for i in range(N):
if len(edge[i])<2:
continue
cur=cur0
for ne in d[i].values():
cur-=(p2[ne]-1)*i2n
ans+=cur
ans%=mod
print(ans)
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
from argparse import ArgumentParser
args=ArgumentParser()
args.add_argument('-loc', '--local', type=bool,default=False)
LOCAL=args.parse_args().local
def input():
x=sys.stdin.readline();
if x[-1]=="\n":
return x.rstrip()
return x
def printe(*x):_=print("## ",*x,file=sys.stderr) if LOCAL else 0
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)]
def binr(x): return bin(x)[2:]
def bitcount(x): #xは64bit整数
x= x - ((x >> 1) & 0x5555555555555555)
x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x+= (x >> 8); x+= (x >> 16); x+= (x >> 32)
return x & 0x7f
class rerooting:#全方位木
def __init__(self,N,edge):#単位元self.unitとモノイドdef func,および親の追加処理def addnode設定すること
#tot[親]:すべての子の値の累計
#dics[親][根（親の隣接点)]=その部分木での値
self.unit=0
self.edge=edge
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
self._forward(0)
def func(self,x,y):
return x+y
def addnode(self,x):#辺(距離)に関するdpのとき必要
return x+1
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[1:]):
pa=par[e]
ans=self.unit
de=self.dics[e]
for val in de.values():
ans=self.func(ans,val)
self.dics[pa][e]=self.addnode(ans)
def _forward(self,start):
self._dfs(start)
for e in self.ikigake:
pa=self.par[e]
nes=list(self.dics[e].keys())
nvals=list(self.dics[e].values())
l=len(nes)
aleft=[self.unit]
aright=[self.unit]
for i in range(l-1):
aleft.append(self.func(aleft[-1],nvals[i]))
aright.append(self.func(aright[-1],nvals[-i-1]))
for i,ne in enumerate(nes):
if ne==pa:
continue
self.dics[ne][e]=self.addnode(self.func(aleft[i],aright[-1-i]))
self.tot[e]=self.func(aright[-1],nvals[0])
return self.dics
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=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)) #改行行列
edge = [[] for i in range(N)]
for i in range(N-1):#木の場合M=N-1
a,b= map(int,input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1) #有向のばあいコメントアウト
rt=rerooting(N,edge)
d=rt.dics
tot=rt.tot
i2=pow(2,mod-2,mod)
i2n=pow(i2,N,mod)
i2n1=pow(i2,N-1,mod)
ans=0
cur0=(i2-i2n)%mod
p2=[1]*(N+1)
for i in range(1,N+1):
p2[i]=p2[i-1]*2%mod
for i in range(N):
if len(edge[i])<2:
continue
cur=cur0
for ne in d[i].values():
cur-=(p2[ne]-1)*i2n
ans+=cur
ans%=mod
print(ans)
if __name__ == "__main__":
main()
| p02822 |
class Tree:
C, RL = {}, {}
R, N, D, S, P = None, None, None, None, None
SN = None
def __init__(s, num):
s.N = num
def set(s, a, b):
if a in s.C: s.C[a].append(b)
else: s.C[a] = [b]
if b in s.C: s.C[b].append(a)
else: s.C[b] = [a]
def makeRank(s, root):
s.R = [0] * s.N #各ノードのランク
s.R[root] = 1
s.RL[1] = [root] #各ランクのノード
s.S = [[] for _ in range(s.N)] #各ノードの子ノード
s.P = [-1] * s.N #各ノードの親ノード
F = [root]
s.D = 2
while F != []:
Ft = []
s.RL[s.D] = []
for i in F:
for j in s.C[i]:
if s.R[j] == 0:
s.R[j] = s.D
Ft.append(j)
s.RL[s.D].append(j)
s.S[i].append(j)
s.P[j] = i
s.D += 1
F = Ft
def dfs(s, x): #最遠のノード,距離
t = [-1] * s.N
S = [x]
ans = x
ansn = 0
t[x] = 0
while S != []:
k = S.pop()
for i in s.C[k]:
if t[i] == -1:
t[i] = t[k] + 1
S.append(i)
if t[i] > ansn:
ansn = t[i]
ans = i
return ans, ansn
def getDi(s, x = 0): #直径
a, _ = s.dfs(x)
b, ans = s.dfs(a)
return ans
def getDeep(s, x): #xの子孫のうち一番深い深さ
ans = 0
if x in s.S:
for i in s.S[x]:
ans = max(ans, s.getDeep(i))
return ans + 1
else:
return 0
def getParent(s, x, n): #xのn世代前の親
if n == 0:
return x
if s.P[x] == -1:
return -n
return s.getParent(s.P[x], n - 1)
def countSon(s):
s.SN = [0] * s.N
for i in range(s.D - 1, 0, -1):
for j in s.RL[i]:
cnt = 1
for k in s.S[j]:
cnt += s.SN[k]
s.SN[j] = cnt
class powmod():
F = [1, 2]
Fi = [1, 2]
I = [0, 1]
def __init__(self, num, mod):
self.MOD = mod
k = 2
for i in range(2, num + 1):
self.F.append((self.F[-1] * k) % mod)
self.I.append(mod - self.I[mod % k] * (mod // k) % mod)
self.Fi.append(self.Fi[-1] * self.I[k] % mod)
class Inv:
def __init__(s, mod):
s.MOD = mod
def modpow(s, a, n):
res = 1
while n > 0:
if n & 1:
res = res * a % s.MOD
a = a * a % s.MOD
n >>= 1
return res
def invx(s, a):
return s.modpow(a, s.MOD - 2)
def invL(s, a, n):
ia = s.invx(a)
L = [1] * (n + 1)
for i in range(1, n + 1):
L[i] = L[i - 1] * ia % s.MOD
return L
N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(N - 1)]
T = Tree(N)
L = [0] * N
for a, b in AB:
T.set(a - 1, b - 1)
L[a - 1] += 1
L[b - 1] += 1
for i in range(N):
if L[i] == 1:
root = i
T.makeRank(root)
T.countSon()
MOD = 10 ** 9 + 7
ans = 0
PM = powmod(N, MOD)
I = Inv(MOD)
ans = 0
for i in range(N):
if i == root: continue
if T.S[i] == []: continue
L = []
cnt = 0
for j in T.S[i]:
L.append(T.SN[j])
cnt += T.SN[j]
L.append(N - cnt - 1)
t = PM.F[N - 1] - 1
for j in L:
t = t - PM.F[j] + 1
if t < 0:
t += MOD
ans = (ans + t * I.invx(PM.F[N])) % MOD
print(ans)
| class Tree:
C, RL = {}, {}
R, N, D, S, P = None, None, None, None, None
SN = None
def __init__(s, num):
s.N = num
def set(s, a, b):
if a in s.C: s.C[a].append(b)
else: s.C[a] = [b]
if b in s.C: s.C[b].append(a)
else: s.C[b] = [a]
def makeRank(s, root):
s.R = [0] * s.N #各ノードのランク
s.R[root] = 1
s.RL[1] = [root] #各ランクのノード
s.S = [[] for _ in range(s.N)] #各ノードの子ノード
s.P = [-1] * s.N #各ノードの親ノード
F = [root]
s.D = 2
while F != []:
Ft = []
s.RL[s.D] = []
for i in F:
for j in s.C[i]:
if s.R[j] == 0:
s.R[j] = s.D
Ft.append(j)
s.RL[s.D].append(j)
s.S[i].append(j)
s.P[j] = i
s.D += 1
F = Ft
def dfs(s, x): #最遠のノード,距離
t = [-1] * s.N
S = [x]
ans = x
ansn = 0
t[x] = 0
while S != []:
k = S.pop()
for i in s.C[k]:
if t[i] == -1:
t[i] = t[k] + 1
S.append(i)
if t[i] > ansn:
ansn = t[i]
ans = i
return ans, ansn
def getDi(s, x = 0): #直径
a, _ = s.dfs(x)
b, ans = s.dfs(a)
return ans
def getDeep(s, x): #xの子孫のうち一番深い深さ
ans = 0
if x in s.S:
for i in s.S[x]:
ans = max(ans, s.getDeep(i))
return ans + 1
else:
return 0
def getParent(s, x, n): #xのn世代前の親
if n == 0:
return x
if s.P[x] == -1:
return -n
return s.getParent(s.P[x], n - 1)
def countSon(s):
s.SN = [0] * s.N
for i in range(s.D - 1, 0, -1):
for j in s.RL[i]:
cnt = 1
for k in s.S[j]:
cnt += s.SN[k]
s.SN[j] = cnt
class powmod():
F = [1, 2]
Fi = [1, 2]
I = [0, 1]
def __init__(self, num, mod):
self.MOD = mod
k = 2
for i in range(2, num + 1):
self.F.append((self.F[-1] * k) % mod)
self.I.append(mod - self.I[mod % k] * (mod // k) % mod)
self.Fi.append(self.Fi[-1] * self.I[k] % mod)
class Inv:
def __init__(s, mod):
s.MOD = mod
def modpow(s, a, n):
res = 1
while n > 0:
if n & 1:
res = res * a % s.MOD
a = a * a % s.MOD
n >>= 1
return res
def invx(s, a):
return s.modpow(a, s.MOD - 2)
def invL(s, a, n):
ia = s.invx(a)
L = [1] * (n + 1)
for i in range(1, n + 1):
L[i] = L[i - 1] * ia % s.MOD
return L
N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(N - 1)]
T = Tree(N)
L = [0] * N
for a, b in AB:
T.set(a - 1, b - 1)
L[a - 1] += 1
L[b - 1] += 1
for i in range(N):
if L[i] == 1:
root = i
T.makeRank(root)
T.countSon()
MOD = 10 ** 9 + 7
ans = 0
PM = powmod(N, MOD)
I = Inv(MOD)
y = I.invx(PM.F[N])
ans = 0
for i in range(N):
if i == root: continue
if T.S[i] == []: continue
L = []
cnt = 0
for j in T.S[i]:
L.append(T.SN[j])
cnt += T.SN[j]
L.append(N - cnt - 1)
t = PM.F[N - 1] - 1
for j in L:
t = t - PM.F[j] + 1
if t < 0:
t += MOD
ans = (ans + t * y) % MOD
print(ans)
| p02822 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
mod = 10 ** 9 + 7
N = int(eval(input()))
vec = [[] for _ in range(N)]
for _ in range(N - 1) :
A, B = list(map(int, input().split()))
vec[A-1].append(B-1)
vec[B-1].append(A-1)
sub_size = [[] for _ in range(N)]
def dfs(cur, pre) :
s = 0
for nex in vec[cur] :
if nex == pre :
continue
t = dfs(nex, cur)
s += t
sub_size[cur].append(t)
if s != N - 1 :
sub_size[cur].append(N - 1 - s)
return s + 1
dfs(0, -1)
fac = [1]
inv = [1]
div = pow(2, mod - 2, mod)
for _ in range(N) :
fac.append(fac[-1] * 2 % mod)
inv.append(inv[-1] * div % mod)
ret = 0
for i in range(N) :
if len(sub_size[i]) < 2 :
continue
a, b = 1, 1
for ss in sub_size[i] :
a *= inv[ss]
b += fac[ss] - 1
a %= mod
b %= mod
ret += (1 - a * b) % mod
ret %= mod
ret = ret * div % mod
print(ret) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
mod = 10 ** 9 + 7
N = int(eval(input()))
vec = [[] for _ in range(N)]
for _ in range(N - 1) :
A, B = list(map(int, input().split()))
vec[A-1].append(B-1)
vec[B-1].append(A-1)
own_size = [0] * N
sub_size = [[] for _ in range(N)]
# pythonのdfs重すぎて自分でstack書かないと通らない。
# く〜〜つらいとこね、これ！！！！
stack = [(0, -1)]
for i in range(N) :
cur, pre = stack[i]
for nex in vec[cur] :
if nex != pre :
stack.append((nex, cur))
while stack :
cur, pre = stack.pop()
if pre != -1 :
sub_size[pre].append(own_size[cur] + 1)
own_size[pre] += own_size[cur] + 1
if own_size[cur] != N - 1 :
sub_size[cur].append(N - 1 - own_size[cur])
fac = [1]
inv = [1]
div = pow(2, mod - 2, mod)
for _ in range(N) :
fac.append(fac[-1] * 2 % mod)
inv.append(inv[-1] * div % mod)
ret = 0
for i in range(N) :
if len(sub_size[i]) < 2 :
continue
a, b = 1, 1
for ss in sub_size[i] :
a *= inv[ss]
b += fac[ss] - 1
a %= mod
b %= mod
ret += (1 - a * b) % mod
ret %= mod
ret = ret * div % mod
print(ret) | p02822 |
import sys
sys.setrecursionlimit(5+10**5)
mod=10**9+7
N=int(eval(input()))
G=[[] for i in range(N)]
for i in range(N-1):
A,B=list(map(int,input().split()))
G[A-1].append(B-1)
G[B-1].append(A-1)
Child=[[] for i in range(N)]
#print(Child)
#print(Parents)
#print(G)
reached=[0 for i in range(N)]
Childnum=[0 for i in range(N)]
def dp(i):
if reached[i]==1:
return Childnum[i]
reached[i]=1
res=0
for j in G[i]:
if reached[j]==1:
continue
Child[i].append(j)
res+=dp(j)+1
Childnum[i]=res
return res
dp(0)
#print(Child)
#print(Childnum)
def inv(x):
return pow(x,mod-2,mod)
inv2=[inv(pow(2,i,mod)) for i in range(N+1)]
ans=(N*(1-inv(pow(2,N-1,mod))))%mod
for r in range(N):
tmp=0
for p in Child[r]:
ai=Childnum[p]+1
tmp+=ai
k1=(1-inv2[ai])%mod
k2=inv2[N-1-ai]
#print(r,p,(k1*k2)%mod)
ans-=(k1*k2)%mod
ans%=mod
ai=N-1-tmp
k1=(1-inv2[ai])%mod
k2=inv2[N-1-ai]
ans-=(k1*k2)%mod
#print(r,-1,(k1*k2)%mod)
ans%=mod
print(((ans*inv(2))%mod))
| import sys
sys.setrecursionlimit(2*10**5)
mod=10**9+7
N=int(eval(input()))
G=[[] for i in range(N)]
for i in range(N-1):
A,B=list(map(int,input().split()))
G[A-1].append(B-1)
G[B-1].append(A-1)
Child=[[] for i in range(N)]
#print(Child)
#print(Parents)
#print(G)
reached=[0 for i in range(N)]
Childnum=[0 for i in range(N)]
def dp(i):
if reached[i]==1:
return Childnum[i]
reached[i]=1
res=0
for j in G[i]:
if reached[j]==1:
continue
Child[i].append(j)
res+=dp(j)+1
Childnum[i]=res
return res
dp(0)
#print(Child)
#print(Childnum)
def inv(x):
return pow(x,mod-2,mod)
inv2=[inv(pow(2,i,mod)) for i in range(N+1)]
ans=(N*(1-inv(pow(2,N-1,mod))))%mod
for r in range(N):
tmp=0
for p in Child[r]:
ai=Childnum[p]+1
tmp+=ai
k1=(1-inv2[ai])%mod
k2=inv2[N-1-ai]
#print(r,p,(k1*k2)%mod)
ans-=(k1*k2)%mod
ans%=mod
ai=N-1-tmp
k1=(1-inv2[ai])%mod
k2=inv2[N-1-ai]
ans-=(k1*k2)%mod
#print(r,-1,(k1*k2)%mod)
ans%=mod
print(((ans*inv(2))%mod))
| p02822 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
d = [0]*n
d[0] = 1
q = deque([0])
p = [None]*n
while q:
x = q.popleft()
nd = d[x]+1
for y in v[x]:
if not d[y]:
d[y] = nd
p[y] = x
q.append(y)
V = list(range(n))
V.sort(key = lambda x:-d[x])
t = [1]*n
for x in V[:-1]:
t[p[x]] += t[x]
ans = n
for x in range(n):
tx = t[x]
s = 0
for y in v[x]:
ty = t[y]
if tx < ty:
s += pow(2,t[0]-tx,mod)-1
else:
s += pow(2,ty,mod)-1
s %= mod
ans += s
ans %= mod
print(((n*pow(2,mod-2,mod)-ans*pow(2,(mod-2)*n%(mod-1),mod))%mod))
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
d = [0]*n
d[0] = 1
q = deque([0])
p = [None]*n
while q:
x = q.popleft()
nd = d[x]+1
for y in v[x]:
if not d[y]:
d[y] = nd
p[y] = x
q.append(y)
V = list(range(n))
V.sort(key = lambda x:-d[x])
t = [1]*n
for x in V[:-1]:
t[p[x]] += t[x]
ans = n
for x in range(n):
tx = t[x]
for y in v[x]:
ty = t[y]
if tx < ty:
ans += pow(2,t[0]-tx,mod)-1
else:
ans += pow(2,ty,mod)-1
ans %= mod
print(((n*pow(2,mod-2,mod)-ans*pow(2,(mod-2)*n%(mod-1),mod))%mod))
return
#Solve
if __name__ == "__main__":
solve()
| p02822 |
import sys
sys.setrecursionlimit(2 * 10 ** 5 + 10)
mod = 10 ** 9 + 7
N, *AB = list(map(int, open(0).read().split()))
E = [[] for _ in range(N)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
E[a - 1].append((b - 1, i))
E[b - 1].append((a - 1, i))
X = [0] * N
def dfs(u, p):
res = 1
for v, c in E[u]:
if p != c:
res += dfs(v, c)
X[p] = res
return res
dfs(0, -1)
I = [1] * (N + 1)
inv = pow(2, mod - 2, mod)
for i in range(N):
I[i + 1] = I[i] * inv % mod
ans = - inv * N - I[N] + 1
for e in range(N - 1):
ans += (1 - I[X[e]]) * (1 - I[N - X[e]])
ans %= mod
print(ans) | import sys
sys.setrecursionlimit(2 * 10 ** 5 + 10)
mod = 10 ** 9 + 7
N, *AB = list(map(int, open(0).read().split()))
E = [[] for _ in range(N)]
for i, (a, b) in enumerate(zip(*[iter(AB)] * 2)):
E[a - 1].append((b - 1, i))
E[b - 1].append((a - 1, i))
X = [0] * N
def dfs(u, p):
res = 1
for v, c in E[u]:
if p != c:
res += dfs(v, c)
X[p] = res
return res
dfs(0, -1)
I = [1] * (N + 1)
inv = pow(2, mod - 2, mod)
for i in range(N):
I[i + 1] = I[i] * inv % mod
ans = - inv * N - I[N] + 1 + sum((1 - I[x]) * (1 - I[N - x]) for x in X)
ans %= mod
print(ans) | p02822 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] != "Yes":
visit[i] = "Yes"
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist[node].append(W[i])
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
#DFS
W = [1] * N
Wlist = [[0] for i in range(N)]
visit = ["No"] * N
visit[0] = "Yes"
DFS(G, W, Wlist, visit, 0)
# print(W)
# print(Wlist)
for i in range(N):
Wlist[i].append(N - 1 - sum(Wlist[i]))
# print(Wlist)
ans_up = 0
pow2 = pow(2, N - 1, con)
for i in range(N):
ans_up += pow2 - 1
for j in Wlist[i]:
ans_up -= pow(2, j, con) - 1
# print(ans_up)
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] != "Yes":
visit[i] = "Yes"
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist[node].append(W[i])
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
#DFS
W = [1] * N
Wlist = [[0] for i in range(N)]
visit = ["No"] * N
visit[0] = "Yes"
DFS(G, W, Wlist, visit, 0)
# print(W)
# print(Wlist)
for i in range(N):
Wlist[i].append(N - W[i])
# print(Wlist)
ans_up = 0
pow2 = pow(2, N - 1, con)
for i in range(N):
ans_up += pow2 - 1
for j in Wlist[i]:
ans_up -= pow(2, j, con) - 1
ans_up %= con
# print(ans_up)
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | p02822 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] != "Yes":
visit[i] = "Yes"
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist[node].append(W[i])
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
#DFS
W = [1] * N
Wlist = [[] for i in range(N)]
visit = ["No"] * N
visit[0] = "Yes"
DFS(G, W, Wlist, visit, 0)
# print(W)
# print(Wlist)
for i in range(N):
Wlist[i].append(N - W[i])
# print(Wlist)
pow2 = pow(2, N - 1, con)
ans_up = N * (pow2 - 1)
for i in range(N):
for j in Wlist[i]:
ans_up -= pow(2, j, con) - 1
ans_up %= con
# print(ans_up)
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] != "Yes":
visit[i] = "Yes"
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist.append(W[i])
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
#DFS
W = [1] * N
Wlist = []
visit = ["No"] * N
visit[0] = "Yes"
DFS(G, W, Wlist, visit, 0)
# print(W)
# print(Wlist)
for i in range(N):
Wlist.append(N - W[i])
# print(Wlist)
pow2 = pow(2, N - 1, con)
ans_up = N * (pow2 - 1)
for i in Wlist:
ans_up -= pow(2, i, con) - 1
ans_up %= con
# print(ans_up)
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | p02822 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] != "Yes":
visit[i] = "Yes"
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist.append(W[i])
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
#DFS
W = [1] * N
Wlist = []
visit = ["No"] * N
visit[0] = "Yes"
DFS(G, W, Wlist, visit, 0)
# print(W)
# print(Wlist)
for i in range(N):
Wlist.append(N - W[i])
# print(Wlist)
pow2 = pow(2, N - 1, con)
ans_up = N * (pow2 - 1)
for i in Wlist:
ans_up -= pow(2, i, con) - 1
ans_up %= con
# print(ans_up)
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] != 1:
visit[i] = 1
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist.append(W[i])
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
#DFS
W = [1] * N
Wlist = []
visit = [0] * N
visit[0] = 1
DFS(G, W, Wlist, visit, 0)
# print(W)
# print(Wlist)
for i in range(N):
Wlist.append(N - W[i])
# print(Wlist)
pow2 = pow(2, N - 1, con)
ans_up = N * (pow2 - 1)
for i in Wlist:
ans_up -= pow(2, i, con) - 1
ans_up %= con
# print(ans_up)
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | p02822 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] == 0:
visit[i] = 1
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist.append(W[i])
class power(object):
def __init__(self, con):
self.power = [0] * 19
self.power[0] = 2
for i in range(1, 19):
self.power[i] = (self.power[i - 1] ** 2) % con
def calc(self, M, con):
ans = 1
for i in range(19):
if M & 1 == 1:
ans = (ans * self.power[i]) % con
M = M >> 1
if M == 0:
break
return ans
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
#DFS
W = [1] * N
Wlist = []
visit = [0] * N
visit[0] = 1
DFS(G, W, Wlist, visit, 0)
# print(W)
# print(Wlist)
for i in range(N):
Wlist.append(N - W[i])
P = power(con)
# print(Wlist)
pow2 = P.calc(N - 1, con)
# print(pow2)
# pow2 = pow(2, N - 1, con)
# print(pow2)
ans_up = N * (pow2 - 1)
for i in Wlist:
ans_up -= P.calc(i, con) - 1
# ans_up -= pow(2, i, con) - 1
ans_up %= con
# print(ans_up)
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
from collections import deque
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def DFS(G, W, Wlist, visit, node):
for i in G.graph[node]:
if visit[i] == 0:
visit[i] = 1
DFS(G, W, Wlist, visit, i)
W[node] += W[i]
Wlist.append(W[i])
class BFS(object):
def __init__(self, graph, s, N):
self.g = graph.graph
self.Q = deque(); self.Q.append(s)
self.dist = [INF] * N; self.dist[s] = 0
self.prev = [None] * N; self.prev[s] = -1
self.order = []
while self.Q:
v = self.Q.popleft()
self.order.append(v)
for i in self.g[v]:
if self.dist[i] == INF:
self.dist[i] = self.dist[v] + 1
self.prev[i] = v
self.Q.append(i)
#処理内容
def main():
#入力
N = int(eval(input()))
G = Graph()
Nedge = [0] * N
for i in range(N - 1):
a, b = getlist()
a -= 1; b -= 1
G.add_edge(a, b)
G.add_edge(b, a)
Nedge[a] += 1; Nedge[b] += 1
W = [1] * N
#葉の場合の処理
# for i in range(N):
# if Nedge[i] == 1:
# W[i] = 1
BF = BFS(G, 0, N)
for i in range(N - 1, 0, -1):
v = BF.order[i]
W[BF.prev[v]] += W[v]
Wlist = []
for i in range(N):
for j in G.graph[i]:
if j != BF.prev[i]:
Wlist.append(W[j])
for i in range(N):
Wlist.append(N - W[i])
pow2 = pow(2, N - 1, con)
ans_up = N * (pow2 - 1)
for i in Wlist:
ans_up -= pow(2, i, con) - 1
ans_up %= con
ans = ans_up * pow(pow2 * 2, con - 2, con)
print((ans % con))
if __name__ == '__main__':
main() | p02822 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def MF(n,d): return ModFraction(n,d)
class ModFraction():
def __init__(self, n, d):
self.n = n
self.d = d
def __add__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = xf.n * self.d % mod
c = self.d * xf.d % mod
return ModFraction((a+b) % mod, c)
def __sub__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = -xf.n * self.d % mod
c = self.d * xf.d % mod
return ModFraction((a+b) % mod, c)
def __mul__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.n % mod
b = self.d * xf.d % mod
return ModFraction(a, b)
def __truediv__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = self.d * xf.n % mod
return ModFraction(a, b)
@classmethod
def xf(cls, x):
if isinstance(x, int):
return ModFraction(x, 1)
return x
@classmethod
def inv(cls, x):
return pow(x, mod - 2, mod)
def int(self):
return self.n * ModFraction.inv(self.d) % mod
def __str__(self):
return "{} / {}".format(self.n, self.d)
def main():
n = I()
ab = [LI_() for _ in range(n-1)]
e = collections.defaultdict(list)
for a,b in ab:
e[a].append(b)
e[b].append(a)
m = {}
def f(i,p):
k = (i,p)
if k in m:
return m[k]
r = 1
for c in e[i]:
if c == p:
continue
r += f(c,i)
m[k] = r
return r
pw = [1]
for i in range(n):
pw.append(pw[-1]*2%mod)
r = 0
for i in range(n):
cs = []
for c in e[i]:
cs.append(f(c,i))
t = sum(cs)
for i in range(len(cs)-1):
t -= cs[i]
k = pw[cs[i]] - 1
l = pw[t] - 1
r += k * l % mod
r %= mod
rf = MF(r, pw[n])
return rf.int()
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def MF(n,d): return ModFraction(n,d)
class ModFraction():
def __init__(self, n, d):
self.n = n
self.d = d
def __add__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = xf.n * self.d % mod
c = self.d * xf.d % mod
return ModFraction((a+b) % mod, c)
def __sub__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = -xf.n * self.d % mod
c = self.d * xf.d % mod
return ModFraction((a+b) % mod, c)
def __mul__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.n % mod
b = self.d * xf.d % mod
return ModFraction(a, b)
def __truediv__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = self.d * xf.n % mod
return ModFraction(a, b)
@classmethod
def xf(cls, x):
if isinstance(x, int):
return ModFraction(x, 1)
return x
@classmethod
def inv(cls, x):
return pow(x, mod - 2, mod)
def int(self):
return self.n * ModFraction.inv(self.d) % mod
def __str__(self):
return "{} / {}".format(self.n, self.d)
def main():
n = I()
ab = [LI_() for _ in range(n-1)]
e = collections.defaultdict(list)
for a,b in ab:
e[a].append(b)
e[b].append(a)
m = {}
def f(i,p):
k = (i,p)
if k in m:
return m[k]
kk = (p,i)
if kk in m:
m[k] = n - m[kk]
return m[k]
r = 1
for c in e[i]:
if c == p:
continue
r += f(c,i)
m[k] = r
return r
pw = [1]
for i in range(n):
pw.append(pw[-1]*2%mod)
r = 0
for i in range(n):
cs = []
for c in e[i]:
cs.append(f(c,i))
t = sum(cs)
for i in range(len(cs)-1):
t -= cs[i]
k = pw[cs[i]] - 1
l = pw[t] - 1
r += k * l % mod
r %= mod
rf = MF(r, pw[n])
return rf.int()
print(main())
| p02822 |
def JOI14_B():
N = I()
A = [I()for _ in range(N)]
A.extend(A)
dp = [[0]*(N*2+1) for _ in range(N*2+1)]
for j in range(N):
for i in range(N*2-j):
if (N-j)%2==1:
dp[i][i+j] = max(dp[i+1][i+j]+A[i],dp[i][i+j-1]+A[i+j])
else:
if A[i]>A[i+j]:
dp[i][i+j] = dp[i+1][i+j]
else:
dp[i][i+j] = dp[i][i+j-1]
ans = 0
for i in range(N):
ans = max(ans,dp[i][i+N-1])
print(ans)
#print(dp)
return
def square869120Contest1_G():
def held_karp(dists,TL):
# Copyright (c) 2016 Carl Ekerot
"""
Implementation of Held-Karp, an algorithm that solves the Traveling
Salesman Problem using dynamic programming with memoization.
Parameters:
dists: distance matrix
Returns:
A tuple, (cost, path).
"""
n = len(dists)
# Maps each subset of the nodes to the cost to reach that subset, as well
# as what node it passed before reaching this subset.
# Node subsets are represented as set bits.
C = {}
dp = defaultdict(int)
# Set transition cost from initial state
for k in range(1, n):
C[(1 << k, k)] = (dists[0][k], 0)
dp[(1 << k, k)] = 1
# Iterate subsets of increasing length and store intermediate results
# in classic dynamic programming manner
for subset_size in range(2, n):
for subset in itertools.combinations(list(range(1, n)), subset_size):
# Set bits for all nodes in this subset
bits = 0
for bit in subset:
bits |= 1 << bit
shortest_length = inf
# Find the lowest cost to get to this subset
for k in subset:
prev = bits & ~(1 << k)
res = []
for m in subset:
if not (prev, m) in C:
continue
if m == 0 or m == k:
continue
if C[(prev, m)][0] + dists[m][k]>TL[m][k]:
continue
res.append((C[(prev, m)][0] + dists[m][k], m))
if shortest_length>C[(prev, m)][0] + dists[m][k]:
shortest_length = C[(prev, m)][0] + dists[m][k]
if not res:
continue
C[(bits, k)] = min(res)
for d,m in res:
if shortest_length!=d:
continue
dp[(bits, k)] += dp[(prev,m)]
# We're interested in all bits but the least significant (the start state)
bits = (2 ** n - 1) - 1
# Calculate optimal cost
res = []
shortest_length = inf
for k in range(1, n):
if not (bits, k) in C:
continue
if C[(bits, k)][0] + dists[k][0] > TL[k][0]:
continue
res.append((C[(bits, k)][0] + dists[k][0], k))
if shortest_length > C[(bits, k)][0] + dists[k][0]:
shortest_length = C[(bits, k)][0] + dists[k][0]
if not res:
return False
opt, parent = min(res)
way = 0
for d, k in res:
if not (bits, k) in C:
continue
if C[(bits, k)][0] + dists[k][0] > TL[k][0]:
continue
if shortest_length < d:
continue
way += dp[(bits,k)]
# Backtrack to find full path
path = []
for i in range(n - 1):
path.append(parent)
new_bits = bits & ~(1 << parent)
_, parent = C[(bits, parent)]
bits = new_bits
# Add implicit start state
path.append(0)
return shortest_length, list(reversed(path)), way
N, M = LI()
dist = [[inf]*N for _ in range(N)]
TL = [[0]*N for _ in range(N)]
for _ in range(M):
s, t, d, time = LI()
s -= 1; t -= 1
dist[s][t] = dist[t][s] = d
TL[s][t] = TL[t][s] = time
ans = held_karp(dist,TL)
if (not ans) or ans[2]==0:
print("IMPOSSIBLE")
return
print((ans[0],ans[2]))
return
def JOI13_D():
def solve(yday,leader,next):
a = [0]*3
for i in range(3):
if next&(1<<i)==(1<<i):
a[i] = 1
rep = 0
if a[leader]==0:
return rep
for i in range(3):
if yday&(1<<i)==(1<<i):
if a[i]==1:
rep = 1
return rep
N = I()
S = SI()
member = {"J":0,"O":1,"I":2}
dp = [[0]*8 for _ in range(N+1)]
dp[0][1] = 1
for i in range(N):
leader = member[S[i]]
for j in range(8):
for k in range(8):
dp[i+1][j] += (dp[i][k]*solve(k,leader,j))
ans = sum(dp[-1])%10007
#print(dp)
print(ans)
return
def JOI16_D():
N, M = LI()
A = [(I()-1)for _ in range(N)]
imos = [[0] * (N + 1) for _ in range(M)]
for i in range(M):
for j in range(N):
imos[i][j + 1] += imos[i][j] + (A[j] != i)
loop = 2**M
dp = [inf]*loop
dp[0] = 0
cnt = Counter(A)
L = [0]*loop
#print(imos)
for i in range(loop):
for j in range(M):
if i&(1<<j)==(1<<j):
continue
next = i|(1<<j)
if L[next]==0:
L[next] = L[i]+cnt[j]
cur = imos[j][L[next]] - imos[j][L[i]]
if dp[next]>dp[i] + cur:
dp[next] = dp[i] + cur
ans = dp[-1]
#print(L)
print(ans)
return
def ABC6_D():
N = I()
C = [I() for _ in range(N)]
LIS = [C[0]]
for i in range(N):
if C[i] > LIS[-1]:
LIS.append(C[i])
else:
LIS[bisect.bisect_left(LIS, C[i])] = C[i]
print((N - len(LIS)))
return
def ABC134_E():
N = I()
A = [I()for _ in range(N)]
que = deque()
que.append(A[0])
L = 1
for i in range(1,N):
cur = bisect.bisect_left(que,A[i])
#print(que,cur,L)
if cur==0:
que.appendleft(A[i])
L += 1
else:
que[cur-1] = A[i]
#print(que)
ans = len(que)
print(ans)
return
def JOI7_F():
def dijkstra_2(edge_adj, node, start):
# node<=2000くらい
# edge_adj[node][to] = [cost]
dist = [inf] * node
used = [False] * node
dist[start] = 0
while True:
v = -1
for i in range(node):
if not used[i] and (v == -1 or dist[v] > dist[i]):
v = i
if v == -1:
break
used[v] = True
for i in range(node):
if dist[i] > dist[v] + edge_adj[v][i]:
dist[i] = dist[v] + edge_adj[v][i]
return dist
N, K = LI()
V = [[inf]*N for _ in range(N)]
ans = []
for _ in range(K):
A = LI()
s = A[1]-1
t = A[2]-1
if A[0]==1:
if V[s][t] <= A[3]:
continue
V[s][t] = A[3]
V[t][s] = A[3]
else:
dist = dijkstra_2(V,N,s)
ans.append(dist[t])
for v in ans:
if v==inf:
print((-1))
continue
print(v)
return
def JOI15_E():
def bfs(n, E, fordfs):
# 点の数、スタートの点、有向グラフ
W = [inf] * n
# 各点の状態量、最短距離とか,見たかどうかとか
que = deque()
for e in E:
e -=1
W[e] = 0
que.append(e)
while que:
now = que.popleft()
nowW = W[now]
for ne in fordfs[now]:
if W[ne] > nowW + 1:
W[ne] = nowW + 1
que.append(ne)
return W
class Dijkstra(object):
"""
construct: O(ElogV)
"""
def __init__(self, edges, start=0):
"""
:param list of list of list of int edges:
:param int start=0:
"""
self.__dist = [inf] * len(edges)
self.__dist[start] = 0
self.__calculate(edges, start)
@property
def dist(self):
return self.__dist
def __calculate(self, edges, start):
Q = [(0, start)] # (dist,vertex)
while (Q):
dist, v = heapq.heappop(Q)
if self.dist[v] < dist: continue # 候補として挙がったd,vだが、他に短いのがある
for u, cost in edges[v]:
if self.dist[u] > self.dist[v] + cost:
self.__dist[u] = self.dist[v] + cost
heapq.heappush(Q, (self.dist[u], u))
N, M, K, S = LI()
P, Q = LI()
C = [I()for _ in range(K)]
V = [[]for _ in range(N)]
for _ in range(M):
s, t = LI()
s -= 1
t -= 1
V[s].append(t)
V[t].append(s)
L = bfs(N,C,V)
#print(L)
cost = [[]for _ in range(N)]
for i in range(N):
for v in V[i]:
if L[v]==0:
continue
elif L[v]<=S:
cost[i].append((v,Q))
else:
cost[i].append((v,P))
di = Dijkstra(cost)
ans = di.dist
#print(cost)
if L[-1]<=S:
print((ans[N-1]-Q))
else:
print((ans[N-1]-P))
return
def JOI13_E():
def bfs(n, e, fordfs):
# 点の数、スタートの点、有向グラフ
W = [inf] * n
# 各点の状態量、最短距離とか,見たかどうかとか
W[e] = 0
que = deque()
que.append(e)
while que:
now = que.popleft()
nowW = W[now]
for ne in fordfs[now]:
if W[ne] == inf:
W[ne] = nowW + 1
que.append(ne)
return W
def dijkstra_2(edge_adj, node, start):
# node<=2000くらい
# edge_adj[node][to] = [cost]
dist = [inf] * node
used = [False] * node
dist[start] = 0
while True:
v = -1
for i in range(node):
if not used[i] and (v == -1 or dist[v] > dist[i]):
v = i
if v == -1:
break
used[v] = True
for i in range(node):
if dist[i] > dist[v] + edge_adj[v][i]:
dist[i] = dist[v] + edge_adj[v][i]
return dist
N, K = LI()
C = [[]for _ in range(N)]
V = [[]for _ in range(N)]
for i in range(N):
C[i] = LI()
for i in range(K):
a, b = LI()
a -= 1
b -= 1
V[a].append(b)
V[b].append(a)
costV = [[inf]*N for _ in range(N)]
for i in range(N):
L = bfs(N,i,V)
c = C[i][0]; l = C[i][1]
for j in range(N):
if i==j:
continue
if L[j]<=l:
costV[i][j] = c
dist = dijkstra_2(costV,N,0)
ans = dist[N-1]
#print(costV)
print(ans)
return
def ABC12_D():
def warshall_floyd(n, d):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
N, M = LI()
V = [[inf]*N for _ in range(N)]
for i in range(N):
V[i][i] = 0
for _ in range(M):
a, b, t = LI()
a -= 1
b -= 1
V[a][b] = t
V[b][a] = t
L = warshall_floyd(N,V)
#print(L)
ans = inf
for i in range(N):
cur = max(L[i])
ans = min(ans,cur)
print(ans)
return
def ABC79_D():
def warshall_floyd(n, d):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
H, W = LI()
C = [LI()for _ in range(10)]
A = [LI()for _ in range(H)]
L = warshall_floyd(10,C)
#print(L)
ans = 0
for a in A:
for i in a:
if i>=0:
ans += L[i][1]
print(ans)
return
def JOIgassyuku10_3():
N, M, K = LI()
V = [[]for _ in range(N)]
for _ in range(M):
a, b, c = LI()
a -= 1
b -= 1
V[a].append((b,c))
V[b].append((a,c))
return
def ABC74_D():
def warshall_floyd(n, d):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
N = I()
A = [LI() for _ in range(N)]
dist = warshall_floyd(N,copy.deepcopy(A))
shortest_path = 0
for i in range(N):
for j in range(N):
if i==j:
continue
if dist[i][j]<A[i][j]:
print((-1))
return
if dist[i][j]>A[i][j]:
continue
flag = True
for k in range(N):
if i==k or j==k:
continue
judge = (dist[i][k]+dist[k][j])-dist[i][j]
if judge==0:
flag = False
if flag:
shortest_path += A[i][j]
ans = shortest_path//2
print(ans)
return
def ABC65_D():
class Kruskal_UnionFind():
# 無向グラフであるという前提に注意
def __init__(self, N):
self.edges = []
self.rank = [0] * N
self.par = [i for i in range(N)]
self.counter = [1] * N
def add(self, u, v, d):
"""
u = from, v = to, d = cost
"""
self.edges.append([u, v, d])
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
z = self.counter[x] + self.counter[y]
self.counter[x], self.counter[y] = z, z
if 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 size(self, x):
x = self.find(x)
return self.counter[x]
def same(self, x, y):
return self.find(x) == self.find(y)
def Kruskal(self):
"""
return: 最小全域木のコストの和
"""
edges = sorted(self.edges, key=lambda x: x[2]) # costでself.edgesをソートする
res = 0
for e in edges:
if not self.same(e[0], e[1]):
self.unite(e[0], e[1])
res += e[2]
return res
N = I()
X = []
for i in range(N):
a, b = LI()
X.append((a,b))
P = defaultdict(set)
for i,x in enumerate(X):
P[x] = i
graph = Kruskal_UnionFind(N + 1)
X.sort(key=lambda x:x[0])
for i in range(N-1):
if X[i+1][0]-X[i][0]>abs(X[i+1][1]-X[i][1]):
continue
r = X[i+1][0]-X[i][0]
graph.add(P[X[i]], P[X[i+1]], r)
X.sort(key=lambda x:x[1])
for i in range(N-1):
if X[i+1][1]-X[i][1]>abs(X[i+1][0]-X[i][0]):
continue
r = X[i+1][1]-X[i][1]
graph.add(P[X[i]], P[X[i+1]], r)
ans = graph.Kruskal()
print(ans)
return
def ABC84_D():
def is_prime(n):
if n == 1: return False
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
def like_2017(x):
if is_prime(x) and is_prime(x//2+1):
return True
return False
Q = I()
maxX = 10**5
imos = [0]*(maxX+1)
for i in range(maxX+1):
if like_2017(i) and i!=2:
imos[i] = imos[i-1] + 1
else:
imos[i] = imos[i - 1]
L = [LI()for _ in range(Q)]
ans = []
for l,r in L:
cur = imos[r]-imos[l-1]
ans.append(cur)
for v in ans:
print(v)
return
def ABC34_C():
# rが小さい時
def cmb(n, r, mod):
cur = 1
for i in range(r):
cur *= (n-i)
cur %= mod
for i in range(r):
cur *= pow(i+1,mod-2,mod)
cur %= mod
return cur
W, H = LI()
r = W+H-2; l = H-1
ans = cmb(r,l,mod)
print(ans)
return
def ABC145_D():
def cmb(n, r, mod):
cur = 1
for i in range(r):
cur *= (n-i)
cur %= mod
for i in range(r):
cur *= pow(i+1,mod-2,mod)
cur %= mod
return cur
X, Y = LI()
if (X+Y)%3!=0:
print((0))
return
r = (X+Y)//3; l = X-(X+Y)//3
if l<0:
print((0))
return
ans = cmb(r,l,mod)
print(ans)
return
def ABC21_D():
def cmb(n, r, mod):
cur = 1
for i in range(r):
cur *= (n-i)
cur %= mod
for i in range(r):
cur *= pow(i+1,mod-2,mod)
cur %= mod
return cur
N = I()
K = I()
r = N+K-1; l = K
ans = cmb(r,l,mod)
print(ans)
return
def ABC149_F():
# 子の数のカウント
def dfs(n,s,edges,children):
cur = 1
children[s] = 0
for i in edges[s]:
if children[i]!=-1:
continue
children[i] = True
now,children = dfs(n,i,edges,children)
cur += now
children[s] = cur
return cur,children
N = I()
V = [[]for _ in range(N)]
for _ in range(N-1):
a, b = LI()
a -= 1; b -= 1
V[a].append(b)
V[b].append(a)
children = [-1]*N
C = dfs(N,0,V,children)[1]
#print(C)
# 分母分子計算
inv = pow(2, mod - 2, mod)
ans = (1 - pow(inv, N, mod) - N * inv) % mod
p = [pow(inv, i, mod) for i in range(N)]
for i in range(1,N):
c = C[i]
d = N-c
cur = (p[c]-1)*(p[d]-1)
ans += cur
ans %= mod
print(ans)
return
def square869120Contest1_E():
N, Q = LI()
A = LI()
C = LI()
C.append(1)
L = [0]*N
for i in range(1,N):
L[i] = pow(A[i-1],A[i],mod) + L[i-1]
#print(L)
ans = 0
now = 0
for i in range(Q+1):
next = C[i]-1
cur = abs(L[next]-L[now])
ans += cur
ans %= mod
now = next
#print(ans)
print(ans)
return
import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
import gc
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**6)
if __name__ == '__main__':
ABC149_F()
"""
"""
| def JOI14_B():
N = I()
A = [I()for _ in range(N)]
A.extend(A)
dp = [[0]*(N*2+1) for _ in range(N*2+1)]
for j in range(N):
for i in range(N*2-j):
if (N-j)%2==1:
dp[i][i+j] = max(dp[i+1][i+j]+A[i],dp[i][i+j-1]+A[i+j])
else:
if A[i]>A[i+j]:
dp[i][i+j] = dp[i+1][i+j]
else:
dp[i][i+j] = dp[i][i+j-1]
ans = 0
for i in range(N):
ans = max(ans,dp[i][i+N-1])
print(ans)
#print(dp)
return
def square869120Contest1_G():
def held_karp(dists,TL):
# Copyright (c) 2016 Carl Ekerot
"""
Implementation of Held-Karp, an algorithm that solves the Traveling
Salesman Problem using dynamic programming with memoization.
Parameters:
dists: distance matrix
Returns:
A tuple, (cost, path).
"""
n = len(dists)
# Maps each subset of the nodes to the cost to reach that subset, as well
# as what node it passed before reaching this subset.
# Node subsets are represented as set bits.
C = {}
dp = defaultdict(int)
# Set transition cost from initial state
for k in range(1, n):
C[(1 << k, k)] = (dists[0][k], 0)
dp[(1 << k, k)] = 1
# Iterate subsets of increasing length and store intermediate results
# in classic dynamic programming manner
for subset_size in range(2, n):
for subset in itertools.combinations(list(range(1, n)), subset_size):
# Set bits for all nodes in this subset
bits = 0
for bit in subset:
bits |= 1 << bit
shortest_length = inf
# Find the lowest cost to get to this subset
for k in subset:
prev = bits & ~(1 << k)
res = []
for m in subset:
if not (prev, m) in C:
continue
if m == 0 or m == k:
continue
if C[(prev, m)][0] + dists[m][k]>TL[m][k]:
continue
res.append((C[(prev, m)][0] + dists[m][k], m))
if shortest_length>C[(prev, m)][0] + dists[m][k]:
shortest_length = C[(prev, m)][0] + dists[m][k]
if not res:
continue
C[(bits, k)] = min(res)
for d,m in res:
if shortest_length!=d:
continue
dp[(bits, k)] += dp[(prev,m)]
# We're interested in all bits but the least significant (the start state)
bits = (2 ** n - 1) - 1
# Calculate optimal cost
res = []
shortest_length = inf
for k in range(1, n):
if not (bits, k) in C:
continue
if C[(bits, k)][0] + dists[k][0] > TL[k][0]:
continue
res.append((C[(bits, k)][0] + dists[k][0], k))
if shortest_length > C[(bits, k)][0] + dists[k][0]:
shortest_length = C[(bits, k)][0] + dists[k][0]
if not res:
return False
opt, parent = min(res)
way = 0
for d, k in res:
if not (bits, k) in C:
continue
if C[(bits, k)][0] + dists[k][0] > TL[k][0]:
continue
if shortest_length < d:
continue
way += dp[(bits,k)]
# Backtrack to find full path
path = []
for i in range(n - 1):
path.append(parent)
new_bits = bits & ~(1 << parent)
_, parent = C[(bits, parent)]
bits = new_bits
# Add implicit start state
path.append(0)
return shortest_length, list(reversed(path)), way
N, M = LI()
dist = [[inf]*N for _ in range(N)]
TL = [[0]*N for _ in range(N)]
for _ in range(M):
s, t, d, time = LI()
s -= 1; t -= 1
dist[s][t] = dist[t][s] = d
TL[s][t] = TL[t][s] = time
ans = held_karp(dist,TL)
if (not ans) or ans[2]==0:
print("IMPOSSIBLE")
return
print((ans[0],ans[2]))
return
def JOI13_D():
def solve(yday,leader,next):
a = [0]*3
for i in range(3):
if next&(1<<i)==(1<<i):
a[i] = 1
rep = 0
if a[leader]==0:
return rep
for i in range(3):
if yday&(1<<i)==(1<<i):
if a[i]==1:
rep = 1
return rep
N = I()
S = SI()
member = {"J":0,"O":1,"I":2}
dp = [[0]*8 for _ in range(N+1)]
dp[0][1] = 1
for i in range(N):
leader = member[S[i]]
for j in range(8):
for k in range(8):
dp[i+1][j] += (dp[i][k]*solve(k,leader,j))
ans = sum(dp[-1])%10007
#print(dp)
print(ans)
return
def JOI16_D():
N, M = LI()
A = [(I()-1)for _ in range(N)]
imos = [[0] * (N + 1) for _ in range(M)]
for i in range(M):
for j in range(N):
imos[i][j + 1] += imos[i][j] + (A[j] != i)
loop = 2**M
dp = [inf]*loop
dp[0] = 0
cnt = Counter(A)
L = [0]*loop
#print(imos)
for i in range(loop):
for j in range(M):
if i&(1<<j)==(1<<j):
continue
next = i|(1<<j)
if L[next]==0:
L[next] = L[i]+cnt[j]
cur = imos[j][L[next]] - imos[j][L[i]]
if dp[next]>dp[i] + cur:
dp[next] = dp[i] + cur
ans = dp[-1]
#print(L)
print(ans)
return
def ABC6_D():
N = I()
C = [I() for _ in range(N)]
LIS = [C[0]]
for i in range(N):
if C[i] > LIS[-1]:
LIS.append(C[i])
else:
LIS[bisect.bisect_left(LIS, C[i])] = C[i]
print((N - len(LIS)))
return
def ABC134_E():
N = I()
A = [I()for _ in range(N)]
que = deque()
que.append(A[0])
L = 1
for i in range(1,N):
cur = bisect.bisect_left(que,A[i])
#print(que,cur,L)
if cur==0:
que.appendleft(A[i])
L += 1
else:
que[cur-1] = A[i]
#print(que)
ans = len(que)
print(ans)
return
def JOI7_F():
def dijkstra_2(edge_adj, node, start):
# node<=2000くらい
# edge_adj[node][to] = [cost]
dist = [inf] * node
used = [False] * node
dist[start] = 0
while True:
v = -1
for i in range(node):
if not used[i] and (v == -1 or dist[v] > dist[i]):
v = i
if v == -1:
break
used[v] = True
for i in range(node):
if dist[i] > dist[v] + edge_adj[v][i]:
dist[i] = dist[v] + edge_adj[v][i]
return dist
N, K = LI()
V = [[inf]*N for _ in range(N)]
ans = []
for _ in range(K):
A = LI()
s = A[1]-1
t = A[2]-1
if A[0]==1:
if V[s][t] <= A[3]:
continue
V[s][t] = A[3]
V[t][s] = A[3]
else:
dist = dijkstra_2(V,N,s)
ans.append(dist[t])
for v in ans:
if v==inf:
print((-1))
continue
print(v)
return
def JOI15_E():
def bfs(n, E, fordfs):
# 点の数、スタートの点、有向グラフ
W = [inf] * n
# 各点の状態量、最短距離とか,見たかどうかとか
que = deque()
for e in E:
e -=1
W[e] = 0
que.append(e)
while que:
now = que.popleft()
nowW = W[now]
for ne in fordfs[now]:
if W[ne] > nowW + 1:
W[ne] = nowW + 1
que.append(ne)
return W
class Dijkstra(object):
"""
construct: O(ElogV)
"""
def __init__(self, edges, start=0):
"""
:param list of list of list of int edges:
:param int start=0:
"""
self.__dist = [inf] * len(edges)
self.__dist[start] = 0
self.__calculate(edges, start)
@property
def dist(self):
return self.__dist
def __calculate(self, edges, start):
Q = [(0, start)] # (dist,vertex)
while (Q):
dist, v = heapq.heappop(Q)
if self.dist[v] < dist: continue # 候補として挙がったd,vだが、他に短いのがある
for u, cost in edges[v]:
if self.dist[u] > self.dist[v] + cost:
self.__dist[u] = self.dist[v] + cost
heapq.heappush(Q, (self.dist[u], u))
N, M, K, S = LI()
P, Q = LI()
C = [I()for _ in range(K)]
V = [[]for _ in range(N)]
for _ in range(M):
s, t = LI()
s -= 1
t -= 1
V[s].append(t)
V[t].append(s)
L = bfs(N,C,V)
#print(L)
cost = [[]for _ in range(N)]
for i in range(N):
for v in V[i]:
if L[v]==0:
continue
elif L[v]<=S:
cost[i].append((v,Q))
else:
cost[i].append((v,P))
di = Dijkstra(cost)
ans = di.dist
#print(cost)
if L[-1]<=S:
print((ans[N-1]-Q))
else:
print((ans[N-1]-P))
return
def JOI13_E():
def bfs(n, e, fordfs):
# 点の数、スタートの点、有向グラフ
W = [inf] * n
# 各点の状態量、最短距離とか,見たかどうかとか
W[e] = 0
que = deque()
que.append(e)
while que:
now = que.popleft()
nowW = W[now]
for ne in fordfs[now]:
if W[ne] == inf:
W[ne] = nowW + 1
que.append(ne)
return W
def dijkstra_2(edge_adj, node, start):
# node<=2000くらい
# edge_adj[node][to] = [cost]
dist = [inf] * node
used = [False] * node
dist[start] = 0
while True:
v = -1
for i in range(node):
if not used[i] and (v == -1 or dist[v] > dist[i]):
v = i
if v == -1:
break
used[v] = True
for i in range(node):
if dist[i] > dist[v] + edge_adj[v][i]:
dist[i] = dist[v] + edge_adj[v][i]
return dist
N, K = LI()
C = [[]for _ in range(N)]
V = [[]for _ in range(N)]
for i in range(N):
C[i] = LI()
for i in range(K):
a, b = LI()
a -= 1
b -= 1
V[a].append(b)
V[b].append(a)
costV = [[inf]*N for _ in range(N)]
for i in range(N):
L = bfs(N,i,V)
c = C[i][0]; l = C[i][1]
for j in range(N):
if i==j:
continue
if L[j]<=l:
costV[i][j] = c
dist = dijkstra_2(costV,N,0)
ans = dist[N-1]
#print(costV)
print(ans)
return
def ABC12_D():
def warshall_floyd(n, d):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
N, M = LI()
V = [[inf]*N for _ in range(N)]
for i in range(N):
V[i][i] = 0
for _ in range(M):
a, b, t = LI()
a -= 1
b -= 1
V[a][b] = t
V[b][a] = t
L = warshall_floyd(N,V)
#print(L)
ans = inf
for i in range(N):
cur = max(L[i])
ans = min(ans,cur)
print(ans)
return
def ABC79_D():
def warshall_floyd(n, d):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
H, W = LI()
C = [LI()for _ in range(10)]
A = [LI()for _ in range(H)]
L = warshall_floyd(10,C)
#print(L)
ans = 0
for a in A:
for i in a:
if i>=0:
ans += L[i][1]
print(ans)
return
def JOIgassyuku10_3():
N, M, K = LI()
V = [[]for _ in range(N)]
for _ in range(M):
a, b, c = LI()
a -= 1
b -= 1
V[a].append((b,c))
V[b].append((a,c))
return
def ABC74_D():
def warshall_floyd(n, d):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
N = I()
A = [LI() for _ in range(N)]
dist = warshall_floyd(N,copy.deepcopy(A))
shortest_path = 0
for i in range(N):
for j in range(N):
if i==j:
continue
if dist[i][j]<A[i][j]:
print((-1))
return
if dist[i][j]>A[i][j]:
continue
flag = True
for k in range(N):
if i==k or j==k:
continue
judge = (dist[i][k]+dist[k][j])-dist[i][j]
if judge==0:
flag = False
if flag:
shortest_path += A[i][j]
ans = shortest_path//2
print(ans)
return
def ABC65_D():
class Kruskal_UnionFind():
# 無向グラフであるという前提に注意
def __init__(self, N):
self.edges = []
self.rank = [0] * N
self.par = [i for i in range(N)]
self.counter = [1] * N
def add(self, u, v, d):
"""
u = from, v = to, d = cost
"""
self.edges.append([u, v, d])
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
z = self.counter[x] + self.counter[y]
self.counter[x], self.counter[y] = z, z
if 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 size(self, x):
x = self.find(x)
return self.counter[x]
def same(self, x, y):
return self.find(x) == self.find(y)
def Kruskal(self):
"""
return: 最小全域木のコストの和
"""
edges = sorted(self.edges, key=lambda x: x[2]) # costでself.edgesをソートする
res = 0
for e in edges:
if not self.same(e[0], e[1]):
self.unite(e[0], e[1])
res += e[2]
return res
N = I()
X = []
for i in range(N):
a, b = LI()
X.append((a,b))
P = defaultdict(set)
for i,x in enumerate(X):
P[x] = i
graph = Kruskal_UnionFind(N + 1)
X.sort(key=lambda x:x[0])
for i in range(N-1):
if X[i+1][0]-X[i][0]>abs(X[i+1][1]-X[i][1]):
continue
r = X[i+1][0]-X[i][0]
graph.add(P[X[i]], P[X[i+1]], r)
X.sort(key=lambda x:x[1])
for i in range(N-1):
if X[i+1][1]-X[i][1]>abs(X[i+1][0]-X[i][0]):
continue
r = X[i+1][1]-X[i][1]
graph.add(P[X[i]], P[X[i+1]], r)
ans = graph.Kruskal()
print(ans)
return
def ABC84_D():
def is_prime(n):
if n == 1: return False
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
def like_2017(x):
if is_prime(x) and is_prime(x//2+1):
return True
return False
Q = I()
maxX = 10**5
imos = [0]*(maxX+1)
for i in range(maxX+1):
if like_2017(i) and i!=2:
imos[i] = imos[i-1] + 1
else:
imos[i] = imos[i - 1]
L = [LI()for _ in range(Q)]
ans = []
for l,r in L:
cur = imos[r]-imos[l-1]
ans.append(cur)
for v in ans:
print(v)
return
def ABC34_C():
# rが小さい時
def cmb(n, r, mod):
cur = 1
for i in range(r):
cur *= (n-i)
cur %= mod
for i in range(r):
cur *= pow(i+1,mod-2,mod)
cur %= mod
return cur
W, H = LI()
r = W+H-2; l = H-1
ans = cmb(r,l,mod)
print(ans)
return
def ABC145_D():
def cmb(n, r, mod):
cur = 1
for i in range(r):
cur *= (n-i)
cur %= mod
for i in range(r):
cur *= pow(i+1,mod-2,mod)
cur %= mod
return cur
X, Y = LI()
if (X+Y)%3!=0:
print((0))
return
r = (X+Y)//3; l = X-(X+Y)//3
if l<0:
print((0))
return
ans = cmb(r,l,mod)
print(ans)
return
def ABC21_D():
def cmb(n, r, mod):
cur = 1
for i in range(r):
cur *= (n-i)
cur %= mod
for i in range(r):
cur *= pow(i+1,mod-2,mod)
cur %= mod
return cur
N = I()
K = I()
r = N+K-1; l = K
ans = cmb(r,l,mod)
print(ans)
return
def ABC149_F():
# 子の数のカウント
def dfs(n,s,edges,children):
cur = 1
children[s] = 0
for i in edges[s]:
if children[i]!=-1:
continue
children[i] = True
now,children = dfs(n,i,edges,children)
cur += now
children[s] = cur
return cur,children
N = I()
V = [[]for _ in range(N)]
for _ in range(N-1):
a, b = LI()
a -= 1; b -= 1
V[a].append(b)
V[b].append(a)
children = [-1]*N
C = dfs(N,0,V,children)[1]
#print(C)
# 頂点数の期待値計算
inv = pow(2, mod - 2, mod)
ans = 1
p = [pow(inv, i, mod) for i in range(N)]
for i in range(1,N):
c = C[i]
d = N-c
cur = (1-p[c])*(1-p[d])
ans += cur
ans %= mod
ans -= N * inv
# 全部白なら+１がない
ans -= pow(inv,N,mod)
ans += mod
ans %= mod
print(ans)
return
def square869120Contest1_E():
N, Q = LI()
A = LI()
C = LI()
C.append(1)
L = [0]*N
for i in range(1,N):
L[i] = pow(A[i-1],A[i],mod) + L[i-1]
#print(L)
ans = 0
now = 0
for i in range(Q+1):
next = C[i]-1
cur = abs(L[next]-L[now])
ans += cur
ans %= mod
now = next
#print(ans)
print(ans)
return
import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
import gc
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**6)
if __name__ == '__main__':
ABC149_F()
"""
"""
| p02822 |
#f
import sys
sys.setrecursionlimit(2 * 10 ** 5 + 10)
n = int(eval(input()))
E = [[] for _ in range(n)]
mod = 10**9 + 7
for i in range(n-1):
a,b = [int(x) for x in input().split()]
E[a-1].append((b-1, i))
E[b-1].append((a-1, i))
X = [0] * n
def dfs(u,e):
num = 1
for v,c in E[u]:
if c != e:
num += dfs(v,c)
X[e] = num
return num
dfs(0, -1)
I = [1]
for i in range(n):
I.append(I[-1] * pow(2, mod-2, mod) % mod)
ans = 0
for i in range(n):
x = X[i]
ans += (1-I[x])*(1-I[n-x]) % mod
ans -= n * I[1]
ans += 1 - I[n]
ans %= mod
print(ans)
| #f
import sys
sys.setrecursionlimit(2 * 10 ** 5 + 10)
n = int(eval(input()))
E = [[] for _ in range(n)]
mod = 10**9 + 7
for i in range(n-1):
a,b = [int(x) for x in input().split()]
E[a-1].append((b-1, i))
E[b-1].append((a-1, i))
X = [0] * n
def dfs(u,e):
num = 1
for v,c in E[u]:
if c != e:
num += dfs(v,c)
X[e] = num
return num
dfs(0, -1)
I = [1]
inv = pow(2, mod-2, mod)
for i in range(n):
I.append(I[-1] * inv % mod)
ans = 0
for i in range(n):
x = X[i]
ans += (1-I[x])*(1-I[n-x]) % mod
ans -= n * I[1]
ans += 1 - I[n]
ans %= mod
print(ans)
| p02822 |
N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
mod=10**9+7
from collections import deque
Q=deque()
USE=[0]*(N+1)
Q.append(1)
H=[0]*(N+1)
H[1]=1
USE[1]=1
while Q:
x=Q.pop()
for to in E[x]:
if USE[to]==0:
USE[to]=1
H[to]=H[x]+1
Q.append(to)
EH=[(h,ind+1) for ind,h in enumerate(H[1:])]
EH.sort(reverse=True)
COME=[1]*(N+1)
USE=[0]*(N+1)
for h,ind in EH:
USE[ind]=1
for to in E[ind]:
if USE[to]==0:
COME[to]+=COME[ind]
ANS=0
for i in range(1,N+1):
SCORE=[]
for j in E[i]:
if COME[j]<COME[i]:
SCORE.append(COME[j])
if sum(SCORE)<N-1:
SCORE.append(N-sum(SCORE)-1)
AV=1
for s in SCORE:
AV+=pow(2,s,mod)-1
ANS+=pow(2,N-1,mod)-AV
#print(SCORE,AV)
print(((ANS*pow(pow(2,N,mod),mod-2,mod))%mod)) | N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
mod=10**9+7
from collections import deque
Q=deque()
USE=[0]*(N+1)
Q.append(1)
H=[0]*(N+1)
H[1]=1
USE[1]=1
while Q:
x=Q.pop()
for to in E[x]:
if USE[to]==0:
USE[to]=1
H[to]=H[x]+1
Q.append(to)
EH=[(h,ind+1) for ind,h in enumerate(H[1:])]
EH.sort(reverse=True)
COME=[1]*(N+1)
USE=[0]*(N+1)
for h,ind in EH:
USE[ind]=1
for to in E[ind]:
if USE[to]==0:
COME[to]+=COME[ind]
ANS=0
POW2=[1]
for i in range(N+1):
POW2.append(POW2[-1]*2%mod)
for i in range(1,N+1):
SCORE=[]
for j in E[i]:
if COME[j]<COME[i]:
SCORE.append(COME[j])
if sum(SCORE)<N-1:
SCORE.append(N-sum(SCORE)-1)
AV=1
for s in SCORE:
AV+=POW2[s]-1
ANS+=POW2[N-1]-AV
#print(SCORE,AV)
print(((ANS*pow(POW2[N],mod-2,mod))%mod)) | p02822 |
N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
mod=10**9+7
from collections import deque
Q=deque()
USE=[0]*(N+1)
Q.append(1)
H=[0]*(N+1)
H[1]=1
USE[1]=1
while Q:
x=Q.pop()
for to in E[x]:
if USE[to]==0:
USE[to]=1
H[to]=H[x]+1
Q.append(to)
EH=[(h,ind+1) for ind,h in enumerate(H[1:])]
EH.sort(reverse=True)
COME=[1]*(N+1)
USE=[0]*(N+1)
for h,ind in EH:
USE[ind]=1
for to in E[ind]:
if USE[to]==0:
COME[to]+=COME[ind]
ANS=0
POW2=[1]
for i in range(N+1):
POW2.append(POW2[-1]*2%mod)
for i in range(1,N+1):
SCORE=[]
for j in E[i]:
if COME[j]<COME[i]:
SCORE.append(COME[j])
if sum(SCORE)<N-1:
SCORE.append(N-sum(SCORE)-1)
AV=1
for s in SCORE:
AV+=POW2[s]-1
ANS+=POW2[N-1]-AV
#print(SCORE,AV)
print(((ANS*pow(POW2[N],mod-2,mod))%mod)) | import sys
input = sys.stdin.readline
N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
mod=10**9+7
from collections import deque
Q=deque()
USE=[0]*(N+1)
Q.append(1)
H=[0]*(N+1)
H[1]=1
USE[1]=1
while Q:
x=Q.pop()
for to in E[x]:
if USE[to]==0:
USE[to]=1
H[to]=H[x]+1
Q.append(to)
EH=[(h,ind+1) for ind,h in enumerate(H[1:])]
EH.sort(reverse=True)
COME=[1]*(N+1)
USE=[0]*(N+1)
for h,ind in EH:
USE[ind]=1
for to in E[ind]:
if USE[to]==0:
COME[to]+=COME[ind]
ANS=0
POW2=[1]
for i in range(N+1):
POW2.append(POW2[-1]*2%mod)
for i in range(1,N+1):
SCORE=[]
for j in E[i]:
if COME[j]<COME[i]:
SCORE.append(COME[j])
if sum(SCORE)<N-1:
SCORE.append(N-sum(SCORE)-1)
AV=1
for s in SCORE:
AV+=POW2[s]-1
ANS+=POW2[N-1]-AV
#print(SCORE,AV)
print(((ANS*pow(POW2[N],mod-2,mod))%mod)) | p02822 |
import sys
sys.setrecursionlimit(10**6)
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)
def dfs(v, p=-1):
global ans
res = 1
ts = []
for u in adj[v]:
if (u==p): continue
t = dfs(u,v)
res += t
ts.append(t)
if p != -1:
ts.append(N-res)
# print(v, ts)
now = pow(2, N-1, MOD)-1
for t in ts:
now -= pow(2, t, MOD)-1
ans += now
return res
ans = 0
MOD = 10**9+7
dfs(1)
print(((ans * pow(pow(2, N, MOD), MOD-2, MOD)) % MOD)) | import sys
sys.setrecursionlimit(10**6)
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)
def dfs(v, p=-1):
global ans
res = 1
ts = []
for u in adj[v]:
if (u==p): continue
t = dfs(u,v)
res += t
ts.append(t)
if p != -1:
ts.append(N-res)
# print(v, ts)
# now = pow(2, N-1, MOD)-1
now = pows[N-1]-1
for t in ts:
# now -= pow(2, t, MOD)-1
now -= pows[t] - 1
ans += now
return res
ans = 0
MOD = 10**9+7
# 高速化1
pows = [1] * (N+1)
for i in range(1, N+1):
pows[i] = (pows[i - 1] * 2) % MOD
dfs(1)
print(((ans * pow(pows[N], MOD-2, MOD)) % MOD)) | p02822 |
MOD=10**9+7
class Fp(int):
def __new__(self,x=0):return super().__new__(self,x%MOD)
def inv(self):return self.__class__(super().__pow__(MOD-2,MOD))
def __add__(self,value):return self.__class__(super().__add__(value))
def __sub__(self,value):return self.__class__(super().__sub__(value))
def __mul__(self,value):return self.__class__(super().__mul__(value))
def __floordiv__(self,value):return self.__class__(self*self.__class__(value).inv())
def __pow__(self,value):return self.__class__(super().__pow__(value%(MOD-1), MOD))
__radd__=__add__
__rmul__=__mul__
def __rsub__(self,value):return self.__class__(-super().__sub__(value))
def __rfloordiv__(self,value):return self.__class__(self.inv()*value)
def __iadd__(self,value):self=self+value;return self
def __isub__(self,value):self=self-value;return self
def __imul__(self,value):self=self*value;return self
def __ifloordiv__(self,value):self=self//value;return self
def __ipow__(self,value):self=self**value;return self
def __neg__(self):return self.__class__(super().__neg__())
from sys import setrecursionlimit
setrecursionlimit(200200)
N = int(eval(input()))
AB = [tuple(map(int, input().split())) for _ in range(N-1)]
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(AB):
a -= 1
b -= 1
G[a].append((b, i))
G[b].append((a, i))
P = [0] * N
visited = [False] * N
visited[0] = True
def dfs(x, i):
e = 1
for v, c in G[x]:
if not visited[v]:
visited[v] = True
e += dfs(v, c)
P[i] = e
return e
dfs(0, -1)
ans = Fp(0)
one = Fp(1)
two = Fp(2)
for i in range(N-1):
ans += (one-one//two**P[i])*(one-one//two**(N-P[i]))
print((ans-Fp(N)//2-two**-N+1)) | from sys import setrecursionlimit
setrecursionlimit(200200)
MOD=10**9+7
N = int(eval(input()))
AB = [tuple(map(int, input().split())) for _ in range(N-1)]
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(AB):
a -= 1
b -= 1
G[a].append((b, i))
G[b].append((a, i))
P = [0] * N
visited = [False] * N
visited[0] = True
def dfs(x, i):
e = 1
for v, c in G[x]:
if not visited[v]:
visited[v] = True
e += dfs(v, c)
P[i] = e
return e
dfs(0, -1)
W = [1] * (N + 1)
inv_2 = pow(2, MOD-2, MOD)
for i in range(N):
W[i+1] = W[i]*inv_2%MOD
ans = (W[N] + 1) * (N - 1) % MOD
for i in range(N-1):
ans -= W[P[i]] + W[N-P[i]]
ans %= MOD
print(((ans - inv_2*N - W[N] + 1) % MOD)) | p02822 |
from sys import setrecursionlimit
setrecursionlimit(200200)
MOD=10**9+7
N = int(eval(input()))
AB = [tuple(map(int, input().split())) for _ in range(N-1)]
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(AB):
a -= 1
b -= 1
G[a].append((b, i))
G[b].append((a, i))
P = [0] * N
visited = [False] * N
visited[0] = True
def dfs(x, i):
e = 1
for v, c in G[x]:
if not visited[v]:
visited[v] = True
e += dfs(v, c)
P[i] = e
return e
dfs(0, -1)
W = [1] * (N + 1)
inv_2 = pow(2, MOD-2, MOD)
for i in range(N):
W[i+1] = W[i]*inv_2%MOD
ans = (W[N] + 1) * (N - 1) % MOD
for i in range(N-1):
ans -= W[P[i]] + W[N-P[i]]
ans %= MOD
print(((ans - inv_2*N - W[N] + 1) % MOD)) | import sys
sys.setrecursionlimit(200200)
input = sys.stdin.readline
MOD=10**9+7
N = int(eval(input()))
AB = [tuple(map(int, input().split())) for _ in range(N-1)]
G = [[] for _ in range(N)]
for i, (a, b) in enumerate(AB):
a -= 1
b -= 1
G[a].append((b, i))
G[b].append((a, i))
P = [0] * N
visited = [False] * N
visited[0] = True
def dfs(x, i):
e = 1
for v, c in G[x]:
if not visited[v]:
visited[v] = True
e += dfs(v, c)
P[i] = e
return e
dfs(0, -1)
W = [1] * (N + 1)
inv_2 = pow(2, MOD-2, MOD)
for i in range(N):
W[i+1] = W[i]*inv_2%MOD
ans = (W[N] + 1) * (N - 1) % MOD
for i in range(N-1):
ans -= W[P[i]] + W[N-P[i]]
ans %= MOD
print(((ans - inv_2*N - W[N] + 1) % MOD)) | p02822 |
import heapq
import copy
N = int(eval(input()))
ab = [[] * (N + 1) for i in range(N + 1)]
E = [0] * (N - 1)
for i in range(N - 1):
a, b = list(map(int, input().split()))
ab[a].append(b)
ab[b].append(a)
E[i] = [a, b]
#print(ab)
#xとyを根とする部分木の頂点の数を求める
#辺xy を切り離して考える
def dfs(x, y):
q = copy.deepcopy(ab[x])
count = 1
visited = [0] * (N + 1)
visited[x] = 1
#print(q, visited)
while q:
now = heapq.heappop(q)
visited[now] = 1
if now != y:
count += 1
for i in ab[now]:
if visited[i] == 0:
heapq.heappush(q, i)
return count
#print(dfs(2, 3))
#(1 - (1/ 2) ** c) * (1 - (1/ 2) ** (N - c)) + 1
#上式を辺ごとに全て足し合わせたものがSの頂点の個数の期待値
#そこからN / 2を引けば求める期待値
#逆元を考える必要があるため、分母と分子に分けて考える
t = 2 ** N#分母
s = 0#分子
for i in range(N - 1):
c = dfs(E[i][0], E[i][1])
#print(c)
s += (2 ** N + 1 - 2 ** (N - c) - 2 ** c)
#辺の個数を数えたので、それに2 ** Nを足して、頂点の個数にする
#-1は空グラフをケア
s += 2 ** N - 1
s -= N * 2 ** (N - 1)
#逆元計算
p = 10 ** 9 + 7
t_inv = pow(t, p-2, p)
ans = t_inv * s % p
print(ans)
| #解説方針#解法1
#https://qiita.com/ZhangChaoran/items/71fab0e4b8647a93d3a0
from collections import deque
from heapq import heappop, heappush
#標準入力
N = int(eval(input()))
MOD = 10 ** 9 + 7
L = [[] for i in range(N + 1)] #dfs用
for i in range(N - 1):
a, b = list(map(int, input().split()))
L[a].append(b)
L[b].append(a)
#木の探索
parent = [0] * (N + 1)
order = []
stack = [1]
while stack:
x = stack.pop()
order.append(x) # 行きがけ順探索リスト
for y in L[x]:
if y == parent[x]:
continue
parent[y] = x # 親ノードを記録
stack.append(y)
#print(order, parent)
half = pow(2, MOD - 2, MOD)
power_inv = [1] * (N + 1)#2 ** N の逆元の集合
size = [1] * (N + 1)
for i, v in enumerate(order[::-1], 1):#iが1から
p = parent[v]
x = size[v] # vの子孫ノード数（自分も含む）をとる
size[p] += x # 親にノード数を加算
power_inv[i] = power_inv[i - 1] * half % MOD # [1, 1/2, 1/4, ...]
#print(size)
# 辺iがSに含まれるための必要十分条件による辺の個数の期待値
# (1 - (1/2) ** i)(1 - (1/2) ** (N - i))を展開して計算
# 根である1の頂点以外は、ある頂点とその親を結ぶ辺を考えた際
# i と N - i個の頂点に別れるので,size[2:]でOK
ans = sum((1 - power_inv[i] - power_inv[N - i] + power_inv[N]) %
MOD for i in size[2:])
#ans = sum((1 - (1/2) ** i- (1/2) ** (N - i) + (1/2) ** N) for i in size[2:])
#print(ans)
ans += 1 # 木の頂点の個数は辺の個数+1
# -「すべての辺が含まれない、つまり空グラフの場合の誤加算」-N/2
ans -= power_inv[N] + N * power_inv[1]
#ans -= N * power_inv[1]
ans %= MOD
print(ans) | p02822 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.