input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
MOD = 10**9+7
n = int(eval(input()))
T = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
T[a].append(b)
T[b].append(a)
C = [[] for _ in range(n)]
seen = [False]*n
dp = [0]*n
def dfs(v):
cnt = 1
seen[v] = True
for nv in T[v]:
if seen[nv]:
continue
C[v].append(nv)
cnt += dfs(nv)
dp[v] = cnt
return cnt
dfs(0)
p = [1]*(n+1)
inv = [1]*(n+1)
inv_two = pow(2, MOD-2, MOD)
for i in range(n):
p[i+1] = p[i] * 2 % MOD
inv[i+1] = inv[i] * inv_two % MOD
ans = 0
for i in range(n):
s = 1
t = 1
cnt = 1
for c in C[i]:
l = dp[c]
s *= inv[l]
s %= MOD
t += p[l] - 1
t %= MOD
cnt += l
r = n - cnt
s *= inv[r]
s %= MOD
t += p[r] - 1
t %= MOD
res = (1 - s*t) % MOD * inv_two
res %= MOD
ans += res
ans %= MOD
print(ans) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
def main():
MOD = 10**9+7
n = int(eval(input()))
T = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
T[a].append(b)
T[b].append(a)
C = [[] for _ in range(n)]
seen = [False]*n
dp = [0]*n
def dfs(v):
cnt = 1
seen[v] = True
for nv in T[v]:
if seen[nv]:
continue
C[v].append(nv)
cnt += dfs(nv)
dp[v] = cnt
return cnt
dfs(0)
p = [1]*(n+1)
inv = [1]*(n+1)
inv_two = pow(2, MOD-2, MOD)
for i in range(n):
p[i+1] = p[i] * 2 % MOD
inv[i+1] = inv[i] * inv_two % MOD
ans = 0
for i in range(n):
s = 1
t = 1
cnt = 1
for c in C[i]:
l = dp[c]
s *= inv[l]
s %= MOD
t += p[l] - 1
t %= MOD
cnt += l
r = n - cnt
s *= inv[r]
s %= MOD
t += p[r] - 1
t %= MOD
res = (1 - s*t) % MOD * inv_two
res %= MOD
ans += res
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | p02822 |
import sys
readline = sys.stdin.buffer.readline
N = int(readline())
graph = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b = list(map(int, readline().split()))
lb = 1 << i
graph[a].append(b)
graph[b].append(a)
root = 1
parent = [0] * (N + 1)
order = []
stack = [root]
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
MOD = 10**9 + 7
x = (MOD + 1) // 2
power_inv = [1] * (N + 100)
for i in range(1, N + 100):
power_inv[i] = power_inv[i - 1] * x % MOD
size = [1] * (N + 1)
p_size = [N - 1] * (N + 1)
prod = [1] * (N + 1)
coef = [1] * (N + 1)
for v in order[::-1]:
p = parent[v]
x = size[v]
size[p] += x
ans = 0
for i in size[2:]:
ans += 1 - power_inv[i] - power_inv[N - i] + power_inv[N]
ans %= MOD
ans = ans - N * power_inv[1] + 1 - power_inv[N]
ans %= MOD
print(ans)
| import sys
readline = sys.stdin.readline
N = int(readline())
graph = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b = list(map(int, readline().split()))
graph[a].append(b)
graph[b].append(a)
parent = [0] * (N + 1)
order = []
stack = [1]
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
MOD = 10**9 + 7
half = pow(2, MOD - 2, MOD)
power_inv = [1] * (N + 1)
size = [1] * (N + 1)
for i, v in enumerate(order[::-1], 1):
p = parent[v]
x = size[v]
size[p] += x
power_inv[i] = power_inv[i - 1] * half % MOD
ans = sum((1 - power_inv[i] - power_inv[N - i] + power_inv[N]) % MOD for i in size[2:])
ans -= N * power_inv[1] + power_inv[N] - 1
ans %= MOD
print(ans) | p02822 |
import sys
from functools import lru_cache
sys.setrecursionlimit(1000000)
readline = sys.stdin.readline
N = int(readline())
adj = [[] for i in range(N)]
for i in range(N - 1):
A, B = list(map(int, readline().split()))
A -= 1
B -= 1
adj[A].append(B)
adj[B].append(A)
mod = 10 ** 9 + 7
pow2 = [1] * (N + 1)
for i, j in zip(list(range(N)), list(range(1, N + 1))):
pow2[j] = pow2[i] * 2 % mod
ans = 0
@lru_cache(maxsize=None)
def dfs(node, parent):
global ans
cnt = 1
for child in adj[node]:
if child != parent:
cnt += dfs(child, node)
ans += (pow2[cnt] - 1) * (pow2[N-cnt] - 1)
ans %= mod
return cnt
dfs(0, None)
ans = (ans - N * pow2[N-1] + pow2[N] - 1) % mod
ans = ans * pow(pow2[N], mod - 2, mod) % mod
print(ans)
| import sys
sys.setrecursionlimit(1000000)
readline = sys.stdin.readline
N = int(readline())
adj = [[] for i in range(N)]
for i in range(N - 1):
A, B = list(map(int, readline().split()))
A -= 1
B -= 1
adj[A].append(B)
adj[B].append(A)
mod = 10 ** 9 + 7
pow2 = [1] * (N + 1)
for i, j in zip(list(range(N)), list(range(1, N + 1))):
pow2[j] = pow2[i] * 2 % mod
ans = 0
def dfs(node, parent):
global ans
cnt = 1
for child in adj[node]:
if child != parent:
cnt += dfs(child, node)
ans += (pow2[cnt] - 1) * (pow2[N-cnt] - 1)
ans %= mod
return cnt
dfs(0, None)
ans = (ans - N * pow2[N-1] + pow2[N] - 1) % mod
ans = ans * pow(pow2[N], mod - 2, mod) % mod
print(ans)
| p02822 |
import sys
sys.setrecursionlimit(1000000)
readline = sys.stdin.readline
N = int(readline())
adj = [[] for i in range(N)]
for i in range(N - 1):
A, B = list(map(int, readline().split()))
A -= 1
B -= 1
adj[A].append(B)
adj[B].append(A)
mod = 10 ** 9 + 7
pow2 = [1] * (N + 1)
for i, j in zip(list(range(N)), list(range(1, N + 1))):
pow2[j] = pow2[i] * 2 % mod
ans = 0
def dfs(node, parent):
global ans
cnt = 1
for child in adj[node]:
if child != parent:
cnt += dfs(child, node)
ans += (pow2[cnt] - 1) * (pow2[N-cnt] - 1)
ans %= mod
return cnt
dfs(0, None)
ans = (ans - N * pow2[N-1] + pow2[N] - 1) % mod
ans = ans * pow(pow2[N], mod - 2, mod) % mod
print(ans)
| import sys
readline = sys.stdin.readline
N = int(readline())
graph = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b = list(map(int, readline().split()))
graph[a].append(b)
graph[b].append(a)
parent = [0] * (N + 1)
order = []
stack = [1]
while stack:
x = stack.pop()
order.append(x) # 行きがけ順探索リスト
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x # 親ノードを記録
stack.append(y)
MOD = 10**9 + 7
half = pow(2, MOD - 2, MOD)
power_inv = [1] * (N + 1)
size = [1] * (N + 1)
for i, v in enumerate(order[::-1], 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, ...]
ans = sum((1 - power_inv[i] - power_inv[N - i] + power_inv[N]) % MOD for i in size[2:]) # 解法1の確率式(ノード1を除く)
ans += (1 - power_inv[N]) - N * power_inv[1] # + - N/2
ans %= MOD
print(ans) | p02822 |
# Surrounded Nodes
from collections import deque
import sys
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
N = int(eval(input()))
G = [[] for i 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)
S = -1
for i in range(1, N+1):
if len(G[i]) == 1:
S = i
break
visited = [False for i in range(N+1)]
parent = [-1 for i in range(N+1)]
count = [1 for i in range(N+1)]
ans = N*pow(2, N-1, mod)
stack = deque()
def dfs(node):
visited[node] = True
for child in G[node]:
if visited[child] == False:
parent[child] = node
stack.append((node, child))
dfs(child)
powers = [1 for i in range(2*10**5+1)]
for i in range(1, 2*10**5+1):
powers[i] = powers[i-1]*2 % mod
dfs(S)
while stack:
mom, child = stack.pop()
count[mom] += count[child]
ans = 0
for i in range(1, N+1):
if len(G[i]) > 1:
ans += powers[N-1]
for x in G[i]:
if x != parent[i]:
ans -= powers[count[x]]
ans -= powers[N-count[i]]
ans += len(G[i]) - 1
ans %= mod
D = pow(2, N, mod)
print((ans*pow(D, mod-2, mod) % mod)) | # Surrounded Nodes
import sys
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
N = int(eval(input()))
G = [[] for i 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)
S = -1
for i in range(1, N+1):
if len(G[i]) == 1:
S = i
break
visited = [False for i in range(N+1)]
parent = [-1 for i in range(N+1)]
count = [1 for i in range(N+1)]
ans = N*pow(2, N-1, mod)
def dfs(node):
visited[node] = True
for child in G[node]:
if visited[child] == False:
parent[child] = node
dfs(child)
for child in G[node]:
if child != parent[node]:
count[node] += count[child]
powers = [1 for i in range(2*10**5+1)]
for i in range(1, 2*10**5+1):
powers[i] = powers[i-1]*2 % mod
dfs(S)
ans = 0
for i in range(1, N+1):
if len(G[i]) > 1:
ans += powers[N-1]
for x in G[i]:
if x != parent[i]:
ans -= powers[count[x]]
ans -= powers[N-count[i]]
ans += len(G[i]) - 1
ans %= mod
D = pow(2, N, mod)
print((ans*pow(D, mod-2, mod) % mod)) | p02822 |
N=int(eval(input()))
E=[[] for _ in range(N)]
for _ in range(N-1):
A,B=list(map(int,input().split()))
E[A-1].append(B-1)
E[B-1].append(A-1)
MOD=10**9+7
#dp=子ノードの数+1(自分)
dp=[1]*N
root=0
parent=[0]*N
order=[]
def dfs():
parent[root]=root
stack=[root]
while stack:
node=stack.pop()
order.append(node)
for ss in E[node]:
if parent[node]!=ss:
stack.append(ss)
parent[ss]=node
def solve():
ans=0
inv2=pow(2,MOD-2,MOD)
#p0=すべての部分木に黒頂点が1つも含まれない確率
p0=pow(pow(2,N-1,MOD),MOD-2,MOD)
for i in reversed(order):
if root!=i:
dp[parent[i]]+=dp[i]
p=0
if len(E[i])>=2:
#p0*(p1-1)=どれか1つの各部分木に黒頂点が1つ以上含まれる確率
p1=1
for s in E[i]:
size=0
if parent[i]!=s:
size=dp[s]
elif i!=root:
size=N-dp[i]
else:
continue
p1+=pow(2,size,MOD)-1
p=1-(p0*p1)
p%=MOD
ans+=p
ans%=MOD
#頂点iが白の確率
ans=ans*inv2%MOD
print(ans)
dfs()
solve()
| N=int(eval(input()))
E=[[] for _ in range(N)]
for _ in range(N-1):
A,B=list(map(int,input().split()))
E[A-1].append(B-1)
E[B-1].append(A-1)
MOD=10**9+7
#dp=子ノードの数+1(自分)
dp=[1]*N
root=0
parent=[0]*N
order=[]
def dfs():
parent[root]=root
stack=[root]
while stack:
node=stack.pop()
order.append(node)
for ss in E[node]:
if parent[node]!=ss:
stack.append(ss)
parent[ss]=node
pow2=[1]*(N+1)
for i in range(1,len(pow2)):
pow2[i]=pow2[i-1]*2%MOD
def solve():
ans=0
inv2=pow(2,MOD-2,MOD)
#p0=すべての部分木に黒頂点が1つも含まれない確率
p0=pow(pow2[N-1],MOD-2,MOD)
for i in reversed(order):
if root!=i:
dp[parent[i]]+=dp[i]
p=0
if len(E[i])>=2:
#p0*(p1-1)=どれか1つの各部分木に黒頂点が1つ以上含まれる確率
p1=1
for s in E[i]:
size=0
if parent[i]!=s:
size=dp[s]
elif i!=root:
size=N-dp[i]
else:
continue
p1+=pow2[size]-1
p=1-(p0*p1)
p%=MOD
ans+=p
ans%=MOD
#頂点iが白の確率
ans=ans*inv2%MOD
print(ans)
dfs()
solve()
| p02822 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
mod = 10**9+7
n = int(eval(input()))
g = [[] for _ in range(n)]
pow2 = [0 for _ in range(n+1)]
pow2[0] = 1
for i in range(n):
pow2[i+1] = pow2[i]*2 %mod
for _ in range(n-1):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
depth = [-1]*n
ko_all = [0 for _ in range(n)]
ko_only =[0 for _ in range(n)]
def dfs(v,d):
depth[v] = d
for w in g[v]:
if depth[w] == -1:
dfs(w,d+1)
ko_all[v] += ko_all[w]+1
ko_only[v] += pow2[ko_all[w]+1]-1
dfs(0,0)
cnt = 0
for i in range(n):
tmp = pow2[n-1]-1-(pow2[n-1-ko_all[i]]-1) - ko_only[i]
tmp %=mod
cnt += tmp
cnt %= mod
def inv(a,mod):
r = [1,0,a]
w = [0,1,mod]
while w[2]!=1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = w
w = r_new
x,y = w[0],w[1] # a*x+y*mod = 1
return (mod+x%mod)%mod
print((inv(pow2[n],mod)*cnt %mod))
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
mod = 10**9+7
n = int(eval(input()))
g = [[] for _ in range(n)]
pow2 = [0 for _ in range(n+1)]
pow2[0] = 1
for i in range(n):
pow2[i+1] = pow2[i]*2 % mod
for _ in range(n-1):
a, b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
depth = [-1]*n
ko_all = [0 for _ in range(n)]
ko_only = [0 for _ in range(n)]
depth[0] = 0
stack = [0]
while stack:
v = stack.pop()
if any(depth[w] == -1 for w in g[v]):
stack.append(v)
for w in g[v]:
if depth[w] == -1:
depth[w] = depth[v] + 1
stack.append(w)
elif depth[w] > depth[v]:
ko_all[v] += ko_all[w] + 1
ko_only[v] += pow2[ko_all[w]+1]-1
cnt = 0
for i in range(n):
tmp = pow2[n-1]-1-(pow2[n-1-ko_all[i]]-1) - ko_only[i]
tmp %= mod
cnt += tmp
cnt %= mod
def inv(a, mod):
r = [1, 0, a]
w = [0, 1, mod]
while w[2] != 1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
r = w
w = r_new
x, y = w[0], w[1] # a*x+y*mod = 1
return (mod+x % mod) % mod
print((inv(pow2[n], mod)*cnt % mod))
| p02822 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
mod = 10**9+7
n = int(eval(input()))
g = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
par = [-1]*n
depth = [-1]*n
sizesub = [1 for _ in range(n)]
black = [0 for _ in range(n)]
root = 0
stack = [root]
while stack:
v = stack.pop()
if depth[v] == -1:
if v == root:
depth[v] = 0
else:
depth[v] = depth[par[v]] + 1
stack.append(v)
for w in g[v]:
if depth[w] == -1:
par[w] = v
stack.append(w)
else:
sizesub[par[v]] += sizesub[v]
black[par[v]] += pow(2, sizesub[v], mod) - 1
cnt = 0
for i in range(n):
tmp = pow(2, n-1, mod) - pow(2, n-sizesub[i], mod) - black[i]
tmp %= mod
cnt += tmp
cnt %= mod
def inv(a, mod):
r = [1, 0, a]
w = [0, 1, mod]
while w[2] != 1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
r = w
w = r_new
x, y = w[0], w[1] # a*x+y*mod = 1
return (mod+x % mod) % mod
print((inv(pow(2, n, mod), mod)*cnt % mod))
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
mod = 10**9+7
n = int(eval(input()))
g = [[] for _ in range(n)]
pow2 = [0 for _ in range(n+1)]
pow2[0] = 1
for i in range(n):
pow2[i+1] = pow2[i]*2 % mod
for _ in range(n-1):
a, b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
par = [-1]*n
depth = [-1]*n
sizesub = [1 for _ in range(n)]
black = [0 for _ in range(n)]
root = 0
stack = [root]
while stack:
v = stack.pop()
if depth[v] == -1:
if v == root:
depth[v] = 0
else:
depth[v] = depth[par[v]] + 1
stack.append(v)
for w in g[v]:
if depth[w] == -1:
par[w] = v
stack.append(w)
else:
sizesub[par[v]] += sizesub[v]
black[par[v]] += pow2[sizesub[v]] - 1
cnt = 0
for i in range(n):
tmp = pow2[n-1] - pow2[n-sizesub[i]] - black[i]
tmp %= mod
cnt += tmp
cnt %= mod
def inv(a, mod):
r = [1, 0, a]
w = [0, 1, mod]
while w[2] != 1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
r = w
w = r_new
x, y = w[0], w[1] # a*x+y*mod = 1
return (mod+x % mod) % mod
print((inv(pow2[n], mod)*cnt % mod))
| p02822 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
mod = 10**9+7
n = int(eval(input()))
g = [[] for _ in range(n)]
pow2 = [0 for _ in range(n+1)]
pow2[0] = 1
for i in range(n):
pow2[i+1] = pow2[i]*2 % mod
for _ in range(n-1):
a, b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
par = [-1]*n
depth = [-1]*n
sizesub = [1 for _ in range(n)]
black = [0 for _ in range(n)]
root = 0
stack = [root]
while stack:
v = stack.pop()
if depth[v] == -1:
if v == root:
depth[v] = 0
else:
depth[v] = depth[par[v]] + 1
stack.append(v)
for w in g[v]:
if depth[w] == -1:
par[w] = v
stack.append(w)
else:
sizesub[par[v]] += sizesub[v]
black[par[v]] += pow2[sizesub[v]] - 1
cnt = 0
for i in range(n):
tmp = pow2[n-1] - pow2[n-sizesub[i]] - black[i]
tmp %= mod
cnt += tmp
cnt %= mod
def inv(a, mod):
r = [1, 0, a]
w = [0, 1, mod]
while w[2] != 1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
r = w
w = r_new
x, y = w[0], w[1] # a*x+y*mod = 1
return (mod+x % mod) % mod
print((inv(pow2[n], mod)*cnt % mod))
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
mod = 10**9+7
n = int(eval(input()))
g = [[] for _ in range(n)]
pow2 = [0 for _ in range(n+1)]
pow2[0] = 1
for i in range(n):
pow2[i+1] = pow2[i]*2 % mod
for _ in range(n-1):
a, b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
def func(x):
return pow2[x]-1
class Tree:
def __init__(self, crdinal, adjgrph, root, fnction=lambda x: 0):
self.crdinal = crdinal
self.adjgrph = adjgrph
self.root = root
self.fnction = fnction
self.parent = [-1]*self.crdinal
self.depth = [-1]*self.crdinal
self.subsize = [1]*self.crdinal
self.result = [0]*self.crdinal
s = [root]
while s:
v = s.pop()
if self.depth[v] == -1:
if v == root:
self.depth[v] = 0
else:
self.depth[v] = self.depth[self.parent[v]] + 1
s.append(v)
for w in self.adjgrph[v]:
if self.depth[w] == -1:
self.parent[w] = v
s.append(w)
else:
self.subsize[self.parent[v]] += self.subsize[v]
self.result[self.parent[v]] += self.fnction(self.subsize[v])
def parent(self) -> list:
return self.parent
def depth(self) -> list:
return self.depth
def size(self) -> list:
return self.subsize
def result(self) -> list:
return self.result
tr = Tree(n, g, 0, func)
sizesub = tr.subsize
black = tr.result
cnt = 0
for i in range(n):
tmp = pow2[n-1] - pow2[n-sizesub[i]] - black[i]
tmp %= mod
cnt += tmp
cnt %= mod
def inv(a, mod):
r = [1, 0, a]
w = [0, 1, mod]
while w[2] != 1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
r = w
w = r_new
x, y = w[0], w[1] # a*x+y*mod = 1
return (mod+x % mod) % mod
print((inv(pow2[n], mod)*cnt % mod))
| p02822 |
import sys
sys.setrecursionlimit(10**9)
N = int(eval(input()))
MOD = 10**9 + 7
tree = [[] for i in range(N+1)]
for i in range(N-1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
# 頂点1をルートにして各頂点より下にある部分木の頂点数を求めていく
root, par = 1, 0
sizes = [0] * (N+1)
order = [[root, par]]
def calc_nums(node, par):
global sizes
global order
if sizes[node] > 0:
return sizes[node]
children = tree[node]
res = 1
for child in children:
if child == par:
continue
order.append([child, node])
res += calc_nums(child, node)
sizes[node] = res
return res
calc_nums(root, par)
# 2の累乗を事前に計算しておく
prod2 = [1]
for i in range(N):
prod2.append(prod2[-1] * 2 % MOD)
# 各頂点について、その頂点が穴あき度としてカウントされる状況を独立に計算する
demo = 0 # 分子
div = prod2[N] # 分母
base = prod2[N-1] - 1
for node, par in order:
children = tree[node]
num = base
num_par = N - 1
for child in children:
if child == par:
continue
s = sizes[child]
num_par -= s
num -= prod2[s] - 1
num -= prod2[num_par] - 1
demo += num
ans = demo * pow(div, MOD-2, MOD) % MOD
print(ans) | import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N = int(eval(input()))
MOD = 10**9 + 7
tree = [[] for i in range(N+1)]
for i in range(N-1):
a, b = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
# 頂点1をルートにして各頂点より下にある部分木の頂点数を求めていく
root, par = 1, 0
sizes = [0] * (N+1)
order = [[root, par]]
def calc_nums(node, par):
global sizes
global order
if sizes[node] > 0:
return sizes[node]
children = tree[node]
res = 1
for child in children:
if child == par:
continue
order.append([child, node])
res += calc_nums(child, node)
sizes[node] = res
return res
_ = calc_nums(root, par)
# 2の累乗を事前に計算しておく
prod2 = [1]
for i in range(N):
prod2.append(prod2[-1] * 2 % MOD)
# 各頂点について、その頂点が穴あき度としてカウントされる状況を独立に計算する
demo = 0 # 分子
div = prod2[N] # 分母
base = prod2[N-1] - 1
for node, par in order:
children = tree[node]
num = base
num_par = N - 1
for child in children:
if child == par:
continue
s = sizes[child]
num_par -= s
num -= prod2[s] - 1
num -= prod2[num_par] - 1
demo += num
ans = demo * pow(div, MOD-2, MOD) % MOD
print(ans) | p02822 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
mod = 10**9 + 7
def factorial(N,MOD,r=True):
fact = [1]*(N+1)
rfact = [1]*(N+1)
r = 1
for i in range(1,N+1):
fact[i] = r = r * i % MOD
rfact[N] = r = pow(fact[N],MOD-2,MOD)
for i in range(N, 0, -1):
rfact[i-1] = r = r * i % MOD
if r:
return fact,rfact
else:
return fact
fact,rfact = factorial(2*10**5,mod)
def perm(n,k): #上のfactorialと併用
return fact[n]*rfact[n-k]%mod
def comb(n,k): #上のfactorialと併用
return fact[n]*rfact[k]*rfact[n-k]%mod
n = int(eval(input()))
G = [[] for i in range(n)]
for i in range(n-1):
a,b = [int(x)-1 for x in input().split()]
G[a].append(b)
G[b].append(a)
euler = []
def dfs(pre,now):
euler.append(now)
for to in G[now]:
if to == pre:
continue
dfs(now,to)
euler.append(pre)
dfs(-1,0)
data = [[] for i in range(n)]
last = [-1]*n
for i,x in enumerate(euler[:-1]):
if last[x] == -1:
last[x] = i
continue
data[x].append((i-last[x])//2)
last[x] = i
for i in range(n):
if sum(data[i]) == n-1:
continue
data[i].append(n-1-sum(data[i]))
two = [1]
now = 1
for i in range(n):
now *= 2
now %= mod
two.append(now)
ans = 0
for i in range(n):
now = 1
for x in data[i]:
now += two[x]-1
now %= mod
ans += two[n-1]-now
ans %= mod
ans *= pow(two[n],mod-2,mod)
ans %= mod
print(ans) | n = int(eval(input()))
G = [[] for _ in range(n)]
mod = 10**9 + 7
for _ in range(n-1):
a, b = [int(x)-1 for x in input().split()]
G[a-1].append(b-1)
G[b-1].append(a-1)
stack = [0]
depth = [-1] * n
depth[0] = 0
while stack:
v = stack.pop()
d = depth[v]
for nv in G[v]:
if depth[nv] >= 0:continue
depth[nv] = depth[v] + 1
stack.append(nv)
d_to_i = [[] for _ in range(n)]
for i in range(n):
d_to_i[depth[i]].append(i)
data = [[] for _ in range(n)]
for d in range(n-1, -1, -1):
for v in d_to_i[d]:
for nv in G[v]:
if depth[nv] < depth[v]:
continue
if data[nv]:
data[v].append(n-data[nv][-1])
if data[v]:
data[v].append(n - 1- sum(data[v]))
else:
data[v].append(n - 1)
ans = 0
two = [1]
for i in range(n):
two.append(two[-1] * 2 % mod)
for i in range(n):
now = two[n-1]-1
for x in data[i]:
now -= two[x]-1
now %= mod
ans += now
ans *= pow(two[n], mod-2, mod)
ans %= mod
print(ans)
| p02822 |
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else : return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
import sys
from collections import defaultdict
input = sys.stdin.readline
N = int(eval(input()))
d2 = [1]
for _ in range(N):
d2.append(2*d2[-1]%mod)
G = [[] for _ in range(N+1)]
for v in range(N-1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
v2i = [0 for _ in range(N+1)]
def itt(v, p):
cn = 0
ms = []
for u in G[v]:
if u == p:
continue
un = itt(u, v)
ms.append(un)
cn += un
if p != None:
ms.append(N-1-cn)
v2i[v] = ms
return cn+1
itt(1, None)
r = 0
for v in range(1, N+1):
ff = v2i[v]
for f in ff:
r += d2[f] - 1 % mod
xx = d2[N]
print(((div(N, 2) - div(N+r, xx))%mod))
| import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else : return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
import sys
input = sys.stdin.readline
N = int(eval(input()))
d2 = [1]
for _ in range(N):
d2.append(2*d2[-1]%mod)
G = [[] for _ in range(N+1)]
for v in range(N-1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
v2i = [0 for _ in range(N+1)]
def itt(v, p):
cn = 0
ms = []
for u in G[v]:
if u == p:
continue
un = itt(u, v)
ms.append(un)
cn += un
if p != None:
ms.append(N-1-cn)
v2i[v] = ms
return cn+1
itt(1, None)
r = 0
for v in range(1, N+1):
ff = v2i[v]
for f in ff:
r += d2[f] - 1 % mod
xx = d2[N]
print(((div(N, 2) - div(N+r, xx))%mod))
| p02822 |
from sys import stdin, setrecursionlimit
from functools import lru_cache
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
MOD = 1000000007
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
childs = [0] * N
seen = [False] * N
def dfs1(v):
seen[v] = True
c = 0
for nv in G[v]:
if not seen[nv]:
dfs1(nv)
c += childs[nv] + 1
childs[v] = c
return
dfs1(0)
numer = 0
seen = [False] * N
pow2 = pow(2, N - 1, MOD)
@lru_cache(maxsize=None)
def power(x, y, z):
return pow(x, y, z)
def dfs2(v):
global numer
seen[v] = True
nodes = []
for nv in G[v]:
if seen[nv]:
nodes.append(N - childs[v] - 1)
else:
nodes.append(childs[nv] + 1)
if len(nodes) > 1:
this_numer = power(2, N - 1, MOD) - (sum(power(2, n, MOD) - 1 for n in nodes) + 1)
numer = (numer + this_numer) % MOD
for nv in G[v]:
if not seen[nv]:
dfs2(nv)
return
dfs2(0)
denom = power(2, N, MOD)
ans = numer * pow(denom, MOD - 2, MOD) % MOD
print(ans)
| from sys import stdin, setrecursionlimit
from functools import lru_cache
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
MOD = 1000000007
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
childs = [0] * N
seen = [False] * N
def dfs1(v):
seen[v] = True
c = 0
for nv in G[v]:
if not seen[nv]:
dfs1(nv)
c += childs[nv] + 1
childs[v] = c
return
dfs1(0)
numer = 0
seen = [False] * N
@lru_cache(maxsize=None)
def power(x, y, z):
return pow(x, y, z)
def dfs2(v):
global numer
seen[v] = True
nodes = []
for nv in G[v]:
if seen[nv]:
nodes.append(N - childs[v] - 1)
else:
nodes.append(childs[nv] + 1)
if len(nodes) > 1:
this_numer = power(2, N - 1, MOD) - (sum(power(2, n, MOD) - 1 for n in nodes) + 1)
numer = (numer + this_numer) % MOD
for nv in G[v]:
if not seen[nv]:
dfs2(nv)
return
dfs2(0)
denom = power(2, N, MOD)
ans = numer * pow(denom, MOD - 2, MOD) % MOD
print(ans)
| p02822 |
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *AB = list(map(int, read().split()))
G = [[] for _ in range(N)]
for a, b in zip(AB[::2], AB[1::2]):
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
stack = deque([0])
order = []
prev = [0] * N
prev[0] = -1
while stack:
v = stack.pop()
order.append(v)
for nv in G[v]:
if nv != prev[v]:
stack.append(nv)
prev[nv] = v
pow2 = [0] * (N + 1)
pow2[0] = 1
for i in range(N):
pow2[i + 1] = pow2[i] * 2
nodes = [1] * N
numer = 0
for v in reversed(order):
if prev[v] != -1:
nodes[prev[v]] += nodes[v]
numer = (numer + pow2[N - 1] - 1 - (pow2[N - nodes[v]] - 1)) % MOD
for nv in G[v]:
if nv != prev[v]:
numer = (numer - (pow2[nodes[nv]] - 1)) % MOD
denom = pow2[N]
ans = (numer * pow(denom, MOD - 2, MOD)) % MOD
print(ans)
return
if __name__ == '__main__':
main()
| import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *AB = list(map(int, read().split()))
G = [[] for _ in range(N)]
for a, b in zip(AB[::2], AB[1::2]):
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
stack = deque([0])
order = []
prev = [0] * N
prev[0] = -1
while stack:
v = stack.pop()
order.append(v)
for nv in G[v]:
if nv != prev[v]:
stack.append(nv)
prev[nv] = v
pow2 = [0] * (N + 1)
pow2[0] = 1
for i in range(N):
pow2[i + 1] = pow2[i] * 2 % MOD
nodes = [1] * N
numer = 0
for v in reversed(order):
if prev[v] != -1:
nodes[prev[v]] += nodes[v]
numer = (numer + pow2[N - 1] - 1 - (pow2[N - nodes[v]] - 1)) % MOD
for nv in G[v]:
if nv != prev[v]:
numer = (numer - (pow2[nodes[nv]] - 1)) % MOD
denom = pow2[N]
ans = (numer * pow(denom, MOD - 2, MOD)) % MOD
print(ans)
return
if __name__ == '__main__':
main()
| p02822 |
import sys
input=lambda: sys.stdin.readline().rstrip()
mod=10**9+7
n=int(eval(input()))
edge=[[] for i in range(n)]
for i in range(n-1):
a,b=list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
inf=10**6
Par=[inf]*n
Par[0]=-1
Deg=[0]*n
Deg[0]=0
Chk=[0]
while Chk:
c=Chk.pop()
for next in edge[c]:
if Par[next]==inf:
Par[next]=c
Deg[next]+=1
Chk.append(next)
from collections import deque
TS=list(v for v in range(n) if Deg[v]==0)
D=deque(TS)
while D:
v=D.popleft()
for t in edge[v]:
if t!=Par[v]:
Deg[t]-=1
if Deg[t]==0:
D.append(t)
TS.append(t)
Used=[False]*n
C=[0]*n
for i in reversed(list(range(n))):
v=TS[i]
Used[v]=True
for g in edge[v]:
if not Used[g]:
C[g]+=C[v]+1
H=[0]*n
H[0]=1
H[1]=pow(2,mod-2,mod)
for i in range(2,n):
H[i]=(H[i-1]*H[1])%mod
ans=0
for i in range(n):
if len(edge[i])==1:
continue
else:
A=[]
for e in edge[i]:
if e==Par[i]:
A.append(n-1-C[i])
else:
A.append(C[e]+1)
cur=1+(len(edge[i])-1)*H[-1]
for a in A:
cur-=H[n-1-a]
ans=(ans+cur)%mod
print(((ans*H[1])%mod))
| import sys
input=lambda: sys.stdin.readline().rstrip()
mod=10**9+7
n=int(eval(input()))
edge=[[] for i in range(n)]
for i in range(n-1):
a,b=list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
inf=10**6
Par=[inf]*n
Par[0]=-1
Deg=[0]*n
Deg[0]=0
Chk=[0]
while Chk:
c=Chk.pop()
for next in edge[c]:
if Par[next]==inf:
Par[next]=c
Deg[next]+=1
Chk.append(next)
from collections import deque
TS=list(v for v in range(n) if Deg[v]==0)
D=deque(TS)
while D:
v=D.popleft()
for t in edge[v]:
if t!=Par[v]:
Deg[t]-=1
if Deg[t]==0:
D.append(t)
TS.append(t)
Used=[False]*n
C=[0]*n
for i in reversed(list(range(n))):
v=TS[i]
Used[v]=True
for g in edge[v]:
if not Used[g]:
C[g]+=C[v]+1
H=[0]*n
H[0]=1
H[1]=pow(2,mod-2,mod)
for i in range(2,n):
H[i]=(H[i-1]*H[1])%mod
ans=0
for i in range(n):
if len(edge[i])==1:
continue
else:
A=[]
for e in edge[i]:
if e==Par[i]:
A.append(n-1-C[i])
else:
A.append(C[e]+1)
cur=1+(len(edge[i])-1)*H[-1]
for a in A:
cur-=H[n-1-a]
ans+=cur
print(((ans*H[1])%mod))
| p02822 |
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
mod = 10 ** 9 + 7
N = int(eval(input()))
edge = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
edge[x].append(y)
edge[y].append(x)
# 頂点iから伸びてる枝それぞれのサイズ
memo = [[] for _ in range(N + 1)]
def dfs(s, p=-1):
sub_tree = []
res = 1
for t in edge[s]:
if t == p:
continue
size = dfs(t, s)
sub_tree.append(size)
res += size
if N != res:
sub_tree.append(N - res)
memo[s].extend(sub_tree)
return res
dfs(1)
cnt = 0
for lis in memo[1:]:
if len(lis) == 1:
continue
# 頂点iが穴あきとならない->頂点から伸びてるやつ1つだけ黒の場合がダメ
tmp = pow(2, N - 1, mod) - 1 # ぜんぶ白の場合を引いとく
for x in lis:
black = pow(2, x, mod) - 1
tmp = (tmp - black + mod) % mod
cnt = (cnt + tmp) % mod
div = pow(2, N, mod)
ans = cnt * pow(div, mod - 2, mod) % mod
print(ans) | import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
mod = 10 ** 9 + 7
N = int(eval(input()))
edge = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
edge[x].append(y)
edge[y].append(x)
# 頂点iから伸びてる枝それぞれのサイズ
memo = [[] for _ in range(N + 1)]
def dfs(s, p=-1):
res = 1
for t in edge[s]:
if t == p:
continue
size = dfs(t, s)
memo[s].append(size)
res += size
if N != res:
memo[s].append(N - res)
return res
dfs(1)
cnt = 0
for lis in memo[1:]:
if len(lis) == 1:
continue
# 頂点iが穴あきとならない->頂点から伸びてるやつ1つだけ黒の場合がダメ
tmp = pow(2, N - 1, mod) - 1 # ぜんぶ白の場合を引いとく
for x in lis:
black = pow(2, x, mod) - 1
tmp = (tmp - black + mod) % mod
cnt = (cnt + tmp) % mod
div = pow(2, N, mod)
ans = cnt * pow(div, mod - 2, mod) % mod
print(ans) | p02822 |
h,w,*a=open(0).read().split();b=a.index("snuke");print(([chr(i)for i in range(65,91)][b%int(w)]+str(b//int(w)+1))) | h,w,*a=open(0).read().split();b=a.index("snuke");print((chr(b%int(w)+65)+str(b//int(w)+1))) | p03919 |
import sys
import itertools
def one_step(lo,lis):
nu = [ e for e in lis ]
for j in range(len(nu)):
if lo[0][j] == 1:
nu[j],nu[j+1] = nu[j+1],nu[j]
return lo[1:],nu
def solve(lo,lis):
if len(lo) == 0:
return lis
nu = [ e for e in lis]
lo2,nu2 = one_step(lo,nu)
return solve(lo2,nu2)
while True:
n = eval(input())
if n == 0: exit()
m = eval(input())
star = eval(input())
d = eval(input())
lis = list(range(n+1))
lots = []
for i in range(d):
lots.append( [0] + list(map(int,input())) + [0])
if solve(lots,lis)[star] == m: print(0);continue
for i,j in itertools.product(range(d),range(1,n)):
if lots[i][j-1] + lots[i][j] + lots[i][j+1] == 0:
lots[i][j] = 1
if solve(lots,lis)[star] == m: print(i+1,j);break
lots[i][j] = 0
else: print(1) | import sys
import itertools
def one_step(lo,lis):
nu = [ e for e in lis ]
for j in range(len(nu)):
if lo[0][j] == 1:
nu[j],nu[j+1] = nu[j+1],nu[j]
return lo[1:],nu
def solve(lo,lis):
if len(lo) == 0:
return lis
nu = [ e for e in lis]
lo2,nu2 = one_step(lo,nu)
return solve(lo2,nu2)
def func(lots,lis,n,m,star,d):
for i in range(d):
for j in range(1,n):
if lots[0][j-1] + lots[0][j] + lots[0][j+1] == 0:
lots[0][j] = 1
if solve(lots,lis)[star] == m: print(i+1,j);return True
lots[0][j] = 0
lots,lis = one_step(lots,lis)
return False
while True:
n = eval(input())
if n == 0: exit()
m = eval(input())
star = eval(input())
d = eval(input())
lis = list(range(n+1))
lots = []
for i in range(d):
lots.append( [0] + list(map(int,input())) + [0])
if solve(lots,lis)[star] == m: print(0);continue
elif func(lots,lis,n,m,star,d): continue
else: print(1) | p00069 |
import math
n=int(eval(input()))
a=[int(eval(input())) for _ in range(n)]
if n==1:
print((a[0]))
elif n==2:
print((a[0]*a[1]//math.gcd(a[0],a[1])))
else:
r=a[0]*a[1]//math.gcd(a[0],a[1])
for i in a:
r=r*i//math.gcd(r,i)
print(r) | import math
n=int(eval(input()))
a=[int(eval(input())) for _ in range(n)]
r=a[0]
for i in a:
r=r*i//math.gcd(r,i)
print(r) | p03633 |
import math
a=[int(eval(input())) for _ in range(int(eval(input())))]
r=a[0]
for i in range(len(a)):
r=r*a[i]//math.gcd(r,a[i])
print(r) | import math
n=int(eval(input()));a=[int(eval(input())) for _ in range(n)];r=a[0]
for i in a: r=r*i//math.gcd(r,i)
print(r) | p03633 |
N=int(eval(input()))
s=[int(eval(input())) for i in range(N)]
i=0
while i>=0 :
i+=1
for j in range(N):
if (max(s)*i)%s[j]!=0:
break
else:
print((max(s)*i))
exit() | def f(a,b):
x,y=a,b
while b>0:
a,b=b,a%b
return (x//a)*y
s=1
N=int(eval(input()))
for i in range(N):
a=s
b=int(eval(input()))
s=f(a,b)
print(s)
| p03633 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
from math import gcd
ans = 1
for i in range(N):
t = int(eval(input()))
g = gcd(ans, t)
ans = ans*t//g
print(ans) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
from math import gcd
g = 0
ans = 1
for _ in range(N):
t = int(eval(input()))
g = gcd(t, ans)
ans = t*ans//g
print(ans) | p03633 |
n = int(eval(input()))
t = []
for i in range(n):
t.append(int(eval(input())))
t = sorted(t)[::-1]
biggest = t[0]
for i in range(biggest, 10**18+1, biggest):
ok = True
for j in t[1:]:
if i%j != 0:
ok = False
break
if ok == True:
break
print(i)
| n = int(eval(input()))
t = []
for i in range(n):
t.append(int(eval(input())))
def gcd(a, b):
if b == 0:
return a
return gcd(b, a%b)
def lcm(a, b):
return a*b//gcd(a, b)
result = 1
for i in range(n):
result = lcm(result, t[i])
print(result)
| p03633 |
def lcm(a, b):
ax = a
bx = b
c = 0
if a<b:
ax, bx = (bx, ax)
while True:
if ax%bx == 0:
gcd = bx
break
else:
c = bx
bx = ax%bx
ax = c
return a*b // gcd
n = int(eval(input()))
Mx = int(eval(input()))
lst = [Mx]
lst2 = []
for i in range(n-1):
a = int(eval(input()))
if Mx%a != 0:
lst.append(a)
lst.sort()
if Mx<a:
Mx = a
while True:
y = len(lst)
for i in range(y-1):
lst2.append(lcm(lst[i], lst[i+1]))
x = len(lst2)
if x==1:
print((lst2[0]))
break
lst.clear()
for i in range(x-1):
lst.append(lcm(lst2[i], lst2[i+1]))
y = len(lst)
if y==1:
print((lst[0]))
break
lst2.clear() | def lcm(a, b):
ax = a
bx = b
if a<b:
ax, bx = (bx, ax)
while True:
if ax%bx == 0:
gcd = bx
break
else:
c = bx
bx = ax%bx
ax = c
return a*b // gcd
n = int(eval(input()))
lst = []
lst2 = []
for i in range(n):
a = int(eval(input()))
lst.append(a)
while True:
if n==1:
print((lst[0]))
break
lst2.append(lcm(lst[0], lst[1]))
lst.pop(0)
lst.pop(0)
lst2.extend(lst)
if len(lst2)==1:
print((lst2[0]))
break
lst.clear()
lst.append(lcm(lst2[0], lst2[1]))
lst2.pop(0)
lst2.pop(0)
lst.extend(lst2)
if len(lst)==1:
print((lst[0]))
break
lst2.clear() | p03633 |
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
n = int(eval(input()))
res = int(eval(input()))
while n > 1:
x = int(eval(input()))
res = (res * x) // gcd(res, x);
n -= 1
print(res) | def gcd(a,b):
while b > 0:
a, b = b, a % b
return a
n = int(eval(input()))
s = 1
for i in range(n):
x = int(eval(input()))
s = s // gcd(s, x) * x
print((int(s))) | p03633 |
def gcd(a,b):
if b==0:
return a
return (gcd(b,a%b))
def lcm(a,b):
return a*b//gcd(a,b)
n=int(eval(input()))
if n==1:
print((int(eval(input()))))
exit()
ans=1
for i in range(n):
ans=lcm(ans,int(eval(input())))
print((int(ans))) | def gcd(a,b):
if b==0:
return a
return (gcd(b,a%b))
def lcm(a,b):
return a*b//gcd(a,b)
n=int(eval(input()))
t=[int(eval(input())) for i in range(n)]
if n==1:
print((t[0]))
exit()
ans=1
for i in t:
ans=lcm(ans,i)
print((int(ans))) | p03633 |
import math
from functools import reduce
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
n = int(eval(input()))
l = []
for i in range(n):
t = int(eval(input()))
l.append(t)
print((lcm_list(l)))
| def gcd(m, n):
if m < n:
m, n = n, m
while True:
r = m % n
if r == 0:
return n
else:
m, n = n, r
def lcm(m, n):
return m*n // gcd(m, n)
n = int(eval(input()))
l = []
ans = 1
for i in range(n):
t = int(eval(input()))
ans = lcm(ans, t)
print(ans)
| p03633 |
n = int(eval(input()))
T = [int(eval(input())) for _ in range(n)]
main_t = max(T)
cur = main_t
flag = True
while 1:
for t in T:
if cur%t != 0:
flag = False
break
if flag:
ans = cur
break
cur += main_t
flag = True
# print(cur)
print(ans) | def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
n = int(eval(input()))
T = [int(eval(input())) for _ in range(n)]
ans = 1
for t in T:
ans = ans*t//gcd(ans,t)
print(ans) | p03633 |
n = int(eval(input()))
t = []
for i in range(n):
t.append(int(eval(input())))
i = 0
while True:
i+=1
flag = True
for j in range(n):
if (i*max(t))%t[j] != 0:
break
if j == n-1:
flag = False
if flag == False:
break
print((i*max(t))) | def gcd(a, b):
while b:
a, b = b, a%b
return a
N = int(eval(input()))
ans = 1
for i in range(0,N):
t = int(eval(input()))
ans = t * ans // gcd(ans, t)
print(ans)
| p03633 |
from math import gcd
def lcm(X, Y): # 最小公倍数
return (X * Y) // gcd(X, Y)
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
ans = 1
for i in t:
ans = lcm(ans, i)
print(ans)
| from math import gcd
def lcm(X, Y):
return (X * Y) // gcd(X, Y)
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
ans = 1
for i in t:
ans = lcm(ans, i)
print(ans)
| p03633 |
import sys
from functools import reduce
def gcd(a, b):
while b:
a, b = b, a % b
return abs(a)
def lcm(a, b):
return abs(a // gcd(a, b) * b)
n, *t = list(map(int, sys.stdin.read().split()))
def main():
return reduce(lcm, t)
if __name__ == '__main__':
ans = main()
print(ans) | import sys
def gcd(a, b): return gcd(b, a % b) if b else abs(a)
def lcm(a, b): return abs(a // gcd(a, b) * b)
n, *t = list(map(int, sys.stdin.read().split()))
def main():
res = 1
for x in t:
res = lcm(res, x)
print(res)
if __name__ == '__main__':
main() | p03633 |
from functools import reduce
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
def gcd(x, y):
while y != 0:
x, y = y, x % y
return x
def lcm(x, y):
return x * y // gcd(x, y)
def lcmm(l):
return reduce(lcm, l)
print((lcmm(t)))
| from functools import reduce
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
def lcm(x, y):
return x * y // gcd(x, y)
def lcmm(l):
return reduce(lcm, l)
print((lcmm(t)))
| p03633 |
def f(x,y):
if x<y: x,y = y,x
if y==0: return x
else: return f(y, x%y)
N = int(eval(input()))
ans = 1
for _ in range(N):
T = int(eval(input()))
ans = ans*T//f(ans,T)
print(ans) | N = int(eval(input()))
T = [int(eval(input())) for i in range(N)]
def gcd(x,y):
if x<y:x,y = y,x
if y==0:return x
return gcd(y,x%y)
S = T[0]
for i in range(1,N):
S = S*T[i]//gcd(S,T[i])
print(S) | p03633 |
n = int(eval(input()))
T=[int(eval(input())) for i in range(n)]
T = sorted(T,reverse=True)
a = T[0]
i =1
while True:
if sum([T[0]%x for x in T]) !=0:
T[0] += a
else:
print((T[0]))
exit()
i += 1 | n = int(eval(input()))
T=[int(eval(input())) for i in range(n)]
def euclid(a,b):
r = a % b
return euclid(b,r) if r else b
def lcm(a,b):
return a * b //euclid(a,b)
num = T[0]
for i in range(1,n):
num = lcm(num, T[i])
print(num) | p03633 |
from collections import deque
N = int(eval(input()))
T = sorted(list(set([int(eval(input())) for _ in range(N)])), reverse=True)
ret = 1
while len(T) > 1:
C = int(max(T) ** 0.5)
f = False
for c in range(2, C + 1):
T_ = deque([])
for i, t in enumerate(T):
if t % c == 0:
T_.append(t // c)
f = True
elif t < c:
ret *= t
else:
T_.append(t)
T = sorted(list(set([t for t in T_ if t >= c])), reverse=True)
if f:
ret *= c
break
else:
break
for t in T:
ret *= t
print(ret) | from collections import deque
N = int(eval(input()))
T = list(set([int(eval(input())) for _ in range(N)]))
ret = T[0]
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
for t in T[1:]:
ret = ret * t // gcd(ret, t)
print(ret) | p03633 |
from collections import deque
N = int(eval(input()))
T = list(set([int(eval(input())) for _ in range(N)]))
ret = T[0]
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
for t in T[1:]:
ret = ret * t // gcd(ret, t)
print(ret) | import sys
input = sys.stdin.readline
N = int(eval(input()))
def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
def lcm(x, y):
return x * y // gcd(x, y)
T = int(eval(input()))
for i in range(N-1):
T_ = int(eval(input()))
T = lcm(T, T_)
print(T) | p03633 |
N = int(eval(input()))
L = [ int(eval(input())) for i in range(N)]
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
x = L[0]
for i in range(len(L)-1):
y = lcm(x, L[i+1])
x = y
print(x) | #a,bの最大公約数
def gcd(a, b):
while b:
a, b = b, a % b
return a
#a,bの最小公倍数
def lcm(a, b):
return a * b // gcd (a, b)
N = int(eval(input()))
L = [int(eval(input())) for _ in range(N)]
tmp = L[0]
for i in range(1, N):
tmp = lcm(tmp, L[i])
print(tmp)
| p03633 |
def p(n):
ans = 0
v = n
while True:
if n % 10:
v = n
break
ans += 1
n /= 10
return ans
def vp(n):
v = n
while True:
if n % 10:
v = n
break
n //= 10
return v
def lcm(x, y):
if x > y:
d = p(x)
z = vp(x)
else:
d = p(y)
z = vp(x)
x = vp(x)
y = vp(y)
ans = 0
while True:
if z % x == 0 and z % y == 0:
ans = z
break
z += 1
return ans * 10**d
def resolve():
n = int(eval(input()))
T = []
for _ in range(n):
T.append(int(eval(input())))
ans = 1
for i in range(n):
ans = lcm(ans, T[i])
print(ans)
resolve() | def gcd(a, b):
"""Compute the greatest common divisor of a and b"""
while b > 0:
a, b = b, a % b
return a
def lcm(a, b):
"""Compute the lowest common multiple of a and b"""
return a * b // gcd(a, b)
def resolve():
n = int(eval(input()))
T = []
for _ in range(n):
T.append(int(eval(input())))
ans = 1
for i in range(n):
ans = lcm(ans, T[i])
print((int(ans)))
resolve() | p03633 |
def gcd(a, b):
"""Compute the greatest common divisor of a and b"""
while b > 0:
a, b = b, a % b
return a
def lcm(a, b):
"""Compute the lowest common multiple of a and b"""
return a * b // gcd(a, b)
def resolve():
n = int(eval(input()))
T = []
for _ in range(n):
T.append(int(eval(input())))
ans = 1
for i in range(n):
ans = lcm(ans, T[i])
print((int(ans)))
resolve() | def gcd(a, b):
"""Compute the greatest common divisor of a and b"""
while b > 0:
a, b = b, a % b
return a
def lcm(a, b):
"""Compute the lowest common multiple of a and b"""
return a * b // gcd(a, b)
def resolve():
n = int(eval(input()))
ans = int(eval(input()))
for _ in range(n-1):
ans = lcm(ans, int(eval(input())))
print(ans)
resolve() | p03633 |
N = int(eval(input()))
def gcd(a, b):
tmp_a, tmp_b = a, b
a = max(tmp_a, tmp_b)
b = min(tmp_a, tmp_b)
r = a % b
while r > 0:
a = b
b = r
r = a % b
return b
def lcm(a, b):
return a*b//gcd(a, b)
tmp = 1
for i in range(N):
T = int(eval(input()))
ans = lcm(T, tmp)
tmp = ans
print(ans)
| N = int(eval(input()))
def gcd(a, b):
r = a % b
while r > 0:
a = b
b = r
r = a % b
return b
def lcm(a, b):
return a*b//gcd(a, b)
tmp = 1
for i in range(N):
T = int(eval(input()))
ans = lcm(T, tmp)
tmp = ans
print(ans)
| p03633 |
N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
Amax = max(A)
i = 1
while i * Amax <= 1e18:
fl = False
for a in A:
if i * Amax % a != 0:
fl = True
break
if fl:
i += 1
continue
else:
break
print((i*Amax)) | N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
def GCD(a,b):
if a < b:
a, b = b, a
while b > 0:
a, b = b, a%b
return a
def LCM(a,b):
return a*b // GCD(a,b)
lcm = A[0]
for i in range(1,N):
lcm = LCM(lcm, A[i])
print(lcm) | p03633 |
N = int(eval(input()))
T = sorted([int(eval(input())) for i in range(N)])
def gcd(a, b):
while b != 0:
a, b = b,a%b
return a
if N == 1:
print((T[0]))
else:
ans = T[0]
for i in range(1, N):
ans = (ans*T[i])//(gcd(ans, T[i]))
print(ans) | def gcd(a, b):
while b != 0:
a, b = b, a%b
return a
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
ans = A[0]
for i in A:
ans = (ans*i)//gcd(ans, i)
print(ans) | p03633 |
N = int(eval(input()))
a = [int(eval(input())) for x in range(N)]
ans = max(a)
mx = max(a)
iteration = 1
while (ans <= 1000000000000000000):
flag = True
for item in a:
if not (ans%item == 0):
flag = False
if flag:
print(ans)
break
else:
iteration = iteration + 1
ans = iteration * mx | def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a,b)
N = int(eval(input()))
Ts = []
c = 1
for i in range(N):
c = lcm(c, int(eval(input())))
print((int(c)))
| p03633 |
# -*- coding: utf-8 -*-
N = int(input().strip())
T_list = [int(input().strip()) for _ in range(N)]
#-----
def gcd(a,b):
x = max(a,b)
y = min(a,b)
while y != 0:
r = x % y
x = y
y = r
return x
def lcm(a, b):
return (a * b) // gcd(a, b)
ans = T_list[0]
for i in T_list[1:]:
ans = lcm(ans, i)
print(ans)
| # -*- coding: utf-8 -*-
N = int(input().strip())
T_list = [int(input().strip()) for _ in range(N)]
#-----
def gcd(a,b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
return (a * b) // gcd(a, b)
ans = T_list[0]
for i in T_list[1:]:
ans = lcm(ans, i)
print(ans)
| p03633 |
def gcd(n, m):
# 最大公約数
a = max(n,m)
b = min(n,m)
while b:
a, b = b, a % b
return a
lcd = 1
N = int(eval(input()))
ts = [int(eval(input())) for i in range(N)]
for t in ts:
lcd = (lcd*t)//gcd(lcd,t)
print(lcd) |
N = int(eval(input()))
ts = [int(eval(input())) for i in range(N)]
def lcd(n, m):
# 最小公倍数
a = max(n,m)
b = min(n,m)
while b:
a, b = b, a % b
return n*m//a
ans = 1
for t in ts:
ans = lcd(ans,t)
print(ans) | p03633 |
# 入力 : 自然数 ex) 12
# 出力 : 約数リスト ex) [2, 2, 3]
def factorization(n):
R = int(n)
s = 0
L = []
div = 2
first = True
while s == 0:
for i in range(div, R + 1):
if n % i == 0:
n = n / i
if i == div and not first:
alreadyExist = True
else:
alreadyExist = False
first = False
div = i
if n == 1:
s = 1
if alreadyExist:
L[-1][1] += 1
else:
L.append([i, 1])
break
return L
n = int(eval(input()))
t = [0 for i in range(n)]
fact = []
for i in range(n):
# print(i)
t[i] = int(eval(input()))
if i == 0:
fact = factorization(t[i])
else:
tmpFact = factorization(t[i])
for _tmpFact in tmpFact:
for _fact in fact:
if _fact[0] == _tmpFact[0]:
_fact[1] = max(_fact[1], _tmpFact[1])
break
elif _fact[0] == fact[-1][0]:
fact.append(_tmpFact)
# つまり全t[i]で割り切れる値を出せということ
# 最小公倍数を出せばよい
sum = 1
for _fact in fact:
sum *= _fact[0]**_fact[1]
print(sum) | def gcd(a, b):
while b > 0:
tmp = a
a = b
b = tmp % b
return a
def lcm(a, b):
tmp = gcd(a, b)
return (a//tmp) * b
n = int(eval(input()))
t = [0 for i in range(n)]
for i in range(n):
t[i] = int(eval(input()))
t = sorted(t)
_sum = t[0]
for i in range(1, n):
# print("sum:{} t:{} lcm:{}".format(sum, t, lcm(sum, t)))
_sum = lcm(_sum, t[i])
# print(sum)
print(_sum)
| p03633 |
def lcmm(l,m):
low,high = 1,1
if(l==m):return l
elif(l>m):
if(l % m ==0):return l
high = l
low = m
else:
if(m % l ==0):return m
high = m
low = l
lcm = high
while(lcm%low != 0):
lcm += high
return lcm
n = int(input().strip())
last = 1
lcm = 1
for i in range(n):
num = int(input().strip())
lcm = lcmm(lcm,num)
#print(lcm)
print(lcm)
| def gcd(a,b):
if(a == 0):
return b
else:
return gcd(b % a, a)
def lcmm(l,m):
prod = l * m
gcD = gcd(l,m)
return (prod // gcD)
n = int(input().strip())
lcm = 1
for i in range(n):
num = int(input().strip())
lcm = lcmm(lcm,num)
#print(lcm)
print(lcm)
| p03633 |
import math
from functools import reduce
def lcm_base(x, y):
return (x*y)//math.gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)
def lcm_list(umbers):
return reduce(lcm_base, numbers, 1)
n = int(eval(input()))
t = []
for i in range(n):
t_ = int(eval(input()))
t.append(t_)
print((lcm(*t))) | import math
n=int(eval(input()))
t=[int(eval(input())) for i in range(n)]
res=t[0]
for i in range(1,n):
res=res*t[i]//math.gcd(res,t[i])
print(res) | p03633 |
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
pnmax = {}
def pn(A):
a = A
for n in range(2, A + 1):
if a == 1:
return
c = 0
while not a % n:
c += 1
a //= n
if 0 < c:
if not n in pnmax:
pnmax[n] = c
else:
pnmax[n] = max(pnmax[n], c)
for t in T:
pn(t)
r = 1
for k, v in list(pnmax.items()):
r *= k ** v
#print(pnmax)
print(r)
| N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
def gcd(a, b):
if not a % b:
return b
else:
return gcd(b, a % b)
l = T[0]
for n in range(1, N):
l = l * T[n] // gcd(l, T[n])
print(l)
| p03633 |
N = int(eval(input()))
T = [int(eval(input())) for k in range(N)]
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
# aとbの最小公倍数
# a*b = lcm(a,b)*gcd(a,b) より
def lcm(a,b):
return a*b//gcd(a,b)
ans = 1
for e in T:
ans = lcm(e,ans)
print(ans)
| N = int(eval(input()))
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
def lcm(a,b):
return a*b//gcd(a,b)
T = [int(eval(input())) for _ in range(N)]
ans = T[0]
for e in T:
ans = lcm(e,ans)
print(ans)
| p03633 |
N = int(eval(input()))
T = []
for i in range(N):
T.append(int(eval(input())))
m = max(T)
mm = m
while True:
flg =False
for j in range(N):
if m % T[j] != 0:
flg = True
break
if flg == True:
m += mm
else:
print(m)
exit()
| def gcd(a,b):
while b:
a,b = b,a%b
return a
def lcm(a,b):
return (a*b) // gcd(a,b)
N = int(eval(input()))
T = []
for i in range(N):
T.append(int(eval(input())))
t = T[0]
for i in range(N - 1):
t = lcm(t,T[i+1])
print(t) | p03633 |
def gcd(x,y):
while y>0:
x,y = y,x%y
return x
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
a = T[0]
for i in range(1,N):
b = T[i]
c = gcd(a,b)
a = a*(b//c)
print(a) | def gcd(x,y):
while y>0:
x,y = y,x%y
return x
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
ans = T[0]
for i in range(1,N):
a = gcd(ans,T[i])
ans = (ans//a)*T[i]
print(ans) | p03633 |
def gcd(x,y):
while y>0:
x,y = y,x%y
return x
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
ans = T[0]
for i in range(1,N):
a = gcd(ans,T[i])
ans = (ans//a)*T[i]
print(ans) | def gcd(x,y):
while y>0:
x,y = y,x%y
return x
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
a = T[0]
for i in range(1,N):
b = T[i]
c = gcd(a,b)
a = (a//c)*b
print(a) | p03633 |
N = int(eval(input()))
T = [int(eval(input())) for i in range(N)]
T.sort()
T.reverse()
result = T[0]
for i in range(1, N):
a = 1
while True:
if (result * a) % T[i] == 0:
result *= a
break
a += 1
print(result)
| N = int(eval(input()))
T = [int(eval(input())) for i in range(N)]
result = T[0]
for i in range(1, N):
n = T[i]
m = result
while n % m != 0:
m, n = n%m, m
result = (result * T[i]) // m
print(result)
| p03633 |
from functools import reduce
#def gcd(a, b):
# while b:
# a, b = b, a % b
# return a
def gcd(m, n):
r = m % n
return gcd(n, r) if r else n
def lcm(a, b):
return a * b // gcd(a,b)
N = int(eval(input()))
Ts = []
c = 1
for i in range(N):
c = lcm(c, int(eval(input())))
print((int(c)))
| def gcd(a, b):
while b:
a, b = b, a % b
return a
#def gcd(m, n):
# r = m % n
# return gcd(n, r) if r else n
def lcm(a, b):
return a * b // gcd(a,b)
N = int(eval(input()))
Ts = []
c = 1
for i in range(N):
c = lcm(c, int(eval(input())))
print((int(c)))
| p03633 |
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
from functools import reduce
def lcm_base(x, y):
return (x * y) // gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
print((lcm_list(T))) | N = int(eval(input()))
T = []
for i in range(N):
T.append(int(eval(input())))
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
from functools import reduce
def lcm_base(x, y):
return (x * y) // gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
print((lcm_list(T))) | p03633 |
import sys
import fractions
sys.setrecursionlimit(200000000)
N = int(eval(input()))
NUMS = [int(eval(input())) for _ in range(N)]
NUMS = list(set(NUMS))
def gcd(num1, num2):
if num2 == 0:
return num1
else:
return gcd(num2, num1 % num2)
res = NUMS[0]
for num in NUMS[1:]:
res = res * num // gcd(res, num)
print((int(res))) | import sys
sys.setrecursionlimit(200000000)
N = int(eval(input()))
NUMS = [int(eval(input())) for _ in range(N)]
NUMS = list(set(NUMS))
def gcd(num1, num2):
if num2 == 0:
return num1
else:
return gcd(num2, num1 % num2)
res = NUMS[0]
for num in NUMS[1:]:
res = res * num // gcd(res, num)
print((int(res))) | p03633 |
n=int(eval(input()))
if n==1:
print((eval(input())))
quit()
def gcd(a,b):
if b==0:return a
return gcd(b,a%b)
def lcm(a,b):
return a*b//gcd(a,b)
ans = int(eval(input()))
for i in range(n-1):
tmp = int(eval(input()))
ans = lcm(tmp,ans)
print(ans)
| n=int(eval(input()))
'''
if n==1:
print(input())
quit()
'''
def gcd(a,b):
if b==0:return a
return gcd(b,a%b)
def lcm(a,b):
return a*b//gcd(a,b)
ans = int(eval(input()))
for i in range(n-1):
tmp = int(eval(input()))
ans = lcm(tmp,ans)
print(ans)
| p03633 |
#!/usr/bin/env python
from functools import reduce
import math
# GCD and LCM are not in math module. They are in gmpy, but these are simple enough:
def gcd(a,b):
"""Compute the greatest common divisor of a and b"""
while b > 0:
a, b = b, a % b
return a
def lcm(a, b):
"""Compute the lowest common multiple of a and b"""
return a * b // gcd(a, b)
N = int(eval(input()))
ts = []
for _ in range(N):
T = int(eval(input()))
ts.append(T)
# print(reduce(lcm, ts))
ans = 1
for i in range(N):
ans = lcm(ans, ts[i])
print(ans)
| #!/usr/bin/env python
from functools import reduce
# GCD and LCM are not in math module. They are in gmpy, but these are simple enough:
def gcd(a,b):
"""Compute the greatest common divisor of a and b"""
while b > 0:
a, b = b, a % b
return a
def lcm(a, b):
"""Compute the lowest common multiple of a and b"""
return a * b // gcd(a, b)
N = int(eval(input()))
ts = []
for _ in range(N):
T = int(eval(input()))
ts.append(T)
print((reduce(lcm, ts)))
# ans = 1
# for i in range(N):
# ans = lcm(ans, ts[i])
# print(ans)
| p03633 |
N = int(eval(input()))
Tn = [int(eval(input())) for i in range(N)]
def gcd(a, b):
result = a
k = 0
n = b
while True:
k = result % n
result = n
n = k
if k == 0:
break
return result
def gcd_n(numbers):
l = numbers[0]
for i in range(len(numbers)):
l = gcd(l, numbers[i])
return l
def lcm(a, b):
g = gcd(a, b)
return a * (b // g)
def lcm_n(numbers):
l = numbers[0]
for i in range(len(numbers)):
l = lcm(l, numbers[i])
return l
def main():
print((lcm_n(Tn)))
return
main()
| N = int(eval(input()))
def gcd(a, b):
result = a
k = 0
n = b
while True:
k = result % n
result = n
n = k
if k == 0:
break
return result
def lcm(a, b):
g = gcd(a, b)
return a * (b // g)
def main():
ans = 1
for i in range(N):
ans = lcm(ans, int(eval(input())))
print(ans)
return
main()
| p03633 |
N = int(eval(input()))
T = [int(eval(input())) for i in range(N)]
T.sort()
while True:
flag = False
for i in range(N-1):
if T[-1]%T[i]!=0:
T[-1] += T[-1]
flag = True
break
if flag == False:
print((T[-1]))
break
| N = int(eval(input()))
T = [int(eval(input())) for i in range(N)]
ans = 1
def gcd(a,b):
if b==0:
return a
return gcd(b,a%b)
for i in range(N):
ans = (ans*T[i])//gcd(ans,T[i])
print(ans) | p03633 |
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
f, ans, x = 0, 1, 2
while x<=max(t):
for i in range(n):
if t[i]%x==0:
t[i] //= x
f = 1
if f:
ans *= x
f = 0
else:
x += 1
for i in t:
ans *= i
print(ans) | n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
#a>b
def gcd(a, b):
if b:
return gcd(b, a%b)
else:
return a
def lcm(a, b):
if a>b:
g = gcd(a, b)
return a*b//g
else:
g = gcd(b, a)
return a*b//g
ans = 1
for i in range(n):
ans = lcm(ans, t[i])
print(ans) | p03633 |
def gcd(a, b):
if b == 1:
return 1
# a > b を仮定
r = a % b
if r == 0:
return b
else:
return gcd(b, r)
#def lcm(A, n):
# if n == 2:
# return A[0]*A[1] // gcd(A[0], A[1])
# #lcm(A, n)はA[0]-A[n-1]までの最小公倍数を求める
# a = lcm(A, n-1)
# return a* A[n-1] // gcd(a, A[n-1])
n = int(eval(input()))
#a = []
T1 = int(eval(input()))
for i in range(n-1):
T2 = int(eval(input()))
T1 = T1*T2 // gcd(T1, T2)
#a.append(int(input()))
#a.sort(reverse = True)
#ans = lcm(a, n)
print((str(T1))) | import sys
sys.setrecursionlimit(10000)
def gcd(a, b):
if b == 1:
return 1
r = a % b
if r == 0:
return b
else:
return gcd(b, r)
def lcm(A, n):
if n == 2:
return A[0]* (A[1] // gcd(A[0], A[1]))
#lcm(A, n)はA[0]-A[n-1]までの最小公倍数を求める
rec = lcm(A, n-1)
return rec * (A[n-1] // gcd(rec, A[n-1]))
n = int(eval(input()))
a = []
for i in range(n):
a.append(int(eval(input())))
if n >= 2:
ans = lcm(a, n)
else:
ans = a[0]
print((str(ans))) | p03633 |
import sys
N = int(eval(input()))
T = []
for i in range(N):
T.append(int(eval(input())))
T = sorted(T, reverse=True)
for i in range(1, 10**18//T[0] + 1):
f = True
for n in T[1:]:
if i*T[0] % n != 0:
f = False
break
if f:
print((i*T[0]))
sys.exit() | def gcd(a, b):
"""最大公約数(Greatest Common divisor)を求める.
ユークリッドの互除法の実装.
ああああ
Parameters
----------
a : int
自然数.
b : int
自然数.
Returns
-------
int
最大公約数
"""
while b:
a, b = b, a % b
return a
def lcm(a, b):
"""最小公約数(least common multiple)を求める.
Parameters
----------
a : int
自然数.
b : int
自然数.
Returns
-------
int
最小公倍数
"""
return a * b // gcd(a, b)
N = int(eval(input()))
T = []
for i in range(N):
T.append(int(eval(input())))
ans = 1
for t in T:
ans = lcm(ans, t)
print(ans) | p03633 |
n=int(eval(input()))
l=list(set([int(eval(input())) for d in range(n)]))
a=l[0]
sd=0
for i in l[1:]:
for h in range(min(i,a)+1)[:0:-1]:
if (a%h,i%h)==(0,0):
sd=h
break
a=a*i//sd
print(a) | n=int(eval(input()))
l=list(set([int(eval(input())) for d in range(n)]))
a=l[0]
def gcd(a,s):
a,s=min(a,s),max(a,s)
if a==0:return s
else:return gcd(s%a,a)
for i in l[1:]:
a=a*i//gcd(a,i)
print(a) | p03633 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
# GCD -- START --
def gcd(x,y):
while y:
x,y=y,x%y
return x
# GCD --- END ---
# LCM -- START --
def lcm(x,y):
return x*y//gcd(x,y)
# LCM --- END ---
def main():
n=I()
ans=I()
for _ in range(n-1):
ans=lcm(ans,I())
return ans
# main()
print((main()))
| import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
# GCD -- START --
def gcd(x,y):
while y:
x,y=y,x%y
return x
# GCD --- END ---
# LCM -- START --
def lcm(x,y):
return x*y//gcd(x,y)
# LCM --- END ---
def main():
n=I()
ans=1
for _ in range(n):
ans=lcm(ans,I())
return ans
# main()
print((main()))
| p03633 |
# code-festival-2017-qualcC - Inserting 'x'
from collections import deque
def main():
S = deque(list(input().rstrip()))
ans = 0
while len(S) >= 2:
l, r = S[0], S[-1]
if l == r:
S.popleft(), S.pop()
else:
ans += 1
if l == "x":
S.append("x")
elif r == "x":
S.appendleft("x")
else:
print((-1))
return
print(ans)
if __name__ == "__main__":
main() | # code-festival-2017-qualcC - Inserting 'x'
def main():
S = input().rstrip()
ans, l, r = 0, 0, len(S) - 1
while l < r:
if S[l] == S[r]:
l += 1
r -= 1
else:
ans += 1
if S[l] == "x":
l += 1
elif S[r] == "x":
r -= 1
else:
print((-1))
return
print(ans)
if __name__ == "__main__":
main() | p03569 |
# 2019-11-21 01:26:03(JST)
import sys
import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r, insort_left as in_l
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np
def is_palindrome_in(s):
s = s.replace('x', '')
if list(s) == list(reversed(s)):
return True
return False
def main():
s = sys.stdin.readline().rstrip()
if not is_palindrome_in(s):
print((-1))
sys.exit()
s = list(s)
# deque で insertが使えるのがver3.5以降のようです(AtCoder はver3.4)
# 初めdequeでやっててなぜRuntime Errorになるのか全くわからなかった
# でもこれだとTLEになってしまうかもしれません
count = 0
i, j = 0, 0
while i < len(s) - 1 - j:
if s[i] == 'x':
if s[-1-j] != 'x':
s.insert(len(s)-j, 'x')
count += 1
elif s[-1-j] == 'x':
s.insert(i, 'x')
count += 1
i += 1
j += 1
print(count)
if __name__ == "__main__":
main()
| # 2019-11-21 01:26:03(JST)
import sys
import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r, insort_left as in_l
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np
def is_palindrome_in(s):
s = s.replace('x', '')
if list(s) == list(reversed(s)):
return True
return False
def main():
s = sys.stdin.readline().rstrip()
if not is_palindrome_in(s):
print((-1))
sys.exit()
s = collections.deque(s)
count = 0
while len(s) > 1:
if s[0] == 'x':
if s[-1] == 'x':
s.popleft(); s.pop()
else:
s.popleft()
count += 1
else:
if s[-1] != 'x':
s.popleft(); s.pop()
else:
s.pop()
count += 1
print(count)
if __name__ == "__main__":
main()
| p03569 |
import sys
S=list(input())
cnt=0
while len(S)>1:
#print S,cnt
if S[0]==S[-1]:
S.pop(0)
S.pop()
elif S[0]!=S[-1] and S[0]=="x":
cnt+=1
S.append("x")
elif S[0]!=S[-1] and S[-1]=="x":
cnt+=1
S.insert(0,"x")
else:
print("-1")
sys.exit()
print(cnt) | import sys
S=input()
cnt=0
while len(S)>1:
#print S,cnt
if S[0]==S[-1]:
S=S[1:-1]
elif S[0]!=S[-1] and S[0]=="x":
cnt+=1
S=S+"x"
elif S[0]!=S[-1] and S[-1]=="x":
S="x"+S
cnt+=1
else:
print("-1")
sys.exit()
print(cnt) | p03569 |
import sys
stdin = sys.stdin
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import deque
s = deque(lc())
lens = len(s)
ok = True
ans = 0
while len(s):
if len(s) == 1:
s.pop()
elif s[0] == s[-1]:
s.pop()
s.popleft()
else:
if s[0] == "x":
s.append("x")
ans += 1
elif s[-1] == "x":
s.appendleft("x")
ans += 1
else:
ok = False
break
if ok:
print(ans)
else:
print((-1)) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
# 回文判定
def judge(s):
news = ""
for si in s:
if si != 'x':
news += si
if news == news[::-1]:
return True
else:
return False
# 操作の最小値
def min_insertion(s):
news = ""
for si in s:
if si != 'x':
news += si
n = len(news)
fir = [0] * ((n + 1)//2)
lat = [0] * ((n + 1) // 2)
# 前半
cursor = 0
for si in s:
if si == 'x':
fir[cursor] += 1
else:
cursor += 1
if cursor == (n+1)//2:
break
# 後半
cursor = 0
for si in s[::-1]:
if si == 'x':
lat[cursor] += 1
else:
cursor += 1
if cursor == (n + 1) // 2:
break
ans = 0
for firi, lati in zip(fir, lat):
ans += abs(firi - lati)
return ans
# 入力
s = ns()
# x以外の回文判定
is_kaibun = judge(s)
# 回文でないならおわり
# 回文ならば最小値出す
if is_kaibun:
if len(set(list(s))) == 1:
print((0))
else:
print((min_insertion(s)))
else:
print((-1))
| p03569 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def show(*inp, end='\n'):
if show_flg:
print(*inp, end=end)
YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
s = S()
d = deque(s)
ans = 0
# print(d)
while len(d) > 1:
if d[0] == d[-1]:
d.popleft()
d.pop()
elif d[0] == 'x':
d.append('x')
ans += 1
elif d[-1] == 'x':
d.appendleft('x')
ans += 1
else:
print(-1)
return
print(ans)
if __name__ == '__main__':
main()
| from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def show(*inp, end='\n'):
if show_flg:
print(*inp, end=end)
YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
s = S()
d = deque(s)
ans = 0
while len(d) > 1:
l = d.popleft()
r = d.pop()
if l == r:
continue
elif l == 'x':
ans += 1
d.append(r)
elif r == 'x':
ans += 1
d.appendleft(l)
else:
print(-1)
return
print(ans)
if __name__ == '__main__':
main()
| p03569 |
N, K = list(map(int, input().split()))
arr = [list(map(int, input().split())) for i in range(N)]
arr.sort()
n = 0
for i in range(N):
n += arr[i][1]
if n >= K:
print((arr[i][0]))
break | n,k = list(map(int,input().split()))
li = [list(map(int, input().split())) for i in range(n)]
li.sort()
cnt=0
for i in range(n):
cnt+=li[i][1]
if cnt>=k:
print((li[i][0]))
break | p03721 |
def main():
N, K = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append([a, b])
AB.sort(key=lambda x: x[0])
c = 0
for a, b in AB:
if c <= K <= c + b:
ans = a
break
c += b
print(ans)
if __name__ == "__main__":
main() | def main():
N, K = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append([a, b])
AB.sort(key=lambda x: x[0])
c = 0
for a, b in AB:
if K <= c + b:
ans = a
break
c += b
print(ans)
if __name__ == "__main__":
main() | p03721 |
from collections import deque
n, k = list(map(int, input().split()))
d = deque()
for _ in range(n):
a, b = list(map(int, input().split()))
d.append([a, b])
x = sorted(list(d))
for i in range(n):
k -= x[i][1]
if k < 1:
print((x[i][0]))
break
| n, k = list(map(int, input().split()))
x = []
for _ in range(n):
a, b = list(map(int, input().split()))
x.append([a, b])
x = sorted(x)
for i in range(n):
k -= x[i][1]
if k < 1:
print((x[i][0]))
break
| p03721 |
n,k=list(map(int,input().split()))
s=[]
for i in range(n):
a,b=list(map(int,input().split()))
s.extend([a for _ in range(b)])
s.sort()
print((s[k-1])) | import bisect
n,k=list(map(int,input().split()))
s=[0 for _ in range((10**5)+1)]
maxa=0
for i in range(n):
a,b=list(map(int,input().split()))
s[a]+=b
maxa=max(maxa,a)
s=s[:maxa]
#print(s)
for i in range(1,len(s)):
s[i]+=s[i-1]
#print(s)
print((bisect.bisect_left(s, k))) | p03721 |
N, K = list(map(int, input().split()))
d = []
for i in range(N):
a, b = list(map(int, input().split()))
for j in range(b):
d.append(a)
d.sort()
print((d[K-1])) | import bisect
N, K = list(map(int, input().split()))
d = []
for i in range(N):
a, b = list(map(int, input().split()))
d.append([a,b])
d.sort()
l = [0] * N
l[0] = d[0][1]
for i in range(1, N):
l[i] = d[i][1]+ l[i-1]
pos = bisect.bisect_left(l, K)
print((d[pos][0])) | p03721 |
import bisect
N, K = list(map(int, input().split()))
d = []
for i in range(N):
a, b = list(map(int, input().split()))
d.append([a,b])
d.sort()
l = [0] * N
l[0] = d[0][1]
for i in range(1, N):
l[i] = d[i][1]+ l[i-1]
pos = bisect.bisect_left(l, K)
print((d[pos][0])) | import sys
import bisect
N, K = list(map(int, sys.stdin.readline().split()))
d = []
for i in range(N):
a, b = list(map(int, sys.stdin.readline().split()))
d.append([a,b])
d.sort()
l = [0] * N
l[0] = d[0][1]
for i in range(1, N):
l[i] = d[i][1]+ l[i-1]
pos = bisect.bisect_left(l, K)
print((d[pos][0])) | p03721 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
N,K=LI()
#AB=[LI() for i in range(N)]
counts={}
l=[]
for i in range(N):
ab=LI()
if not counts.get(ab[0]):
counts[ab[0]]=ab[1]
else:
counts[ab[0]]+=ab[1]
if ab[0] not in l:
l.append(ab[0])
l.sort()
c=0
for item in l:
c+=counts.get(item)
if c>=K:
print(item)
exit()
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
N,K=LI()
A=[]
B=[]
AB=[]
for i in range(N):
a,b=LI()
A.append(a)
B.append(b)
AB.append([a,b])
A=list(set(A))
A.sort()
counts={}
for a in A:
counts[a]=0
for ab in AB:
counts[ab[0]]+=ab[1]
if K<N/2:
c=0
for item in A:
c+=counts.get(item)
if c>=K:
print(item)
exit()
else:
c=sum(B)
for item in reversed(A):
c-=counts.get(item)
if c<K:
print(item)
exit()
| p03721 |
#!/usr/bin/env python3
import sys
import itertools
def solve(N: int, K: int, a: "List[int]", b: "List[int]"):
big_array = []
for i in range(N):
big_array += [a[i]]*b[i]
big_array.sort()
print((big_array[K-1]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
a = [int()] * (N) # type: "List[int]"
b = [int()] * (N) # type: "List[int]"
for i in range(N):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, K, a, b)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import itertools
def solve(N: int, K: int, a: "List[int]", b: "List[int]"):
ab = list(zip(a,b))
ab.sort(key=lambda x: x[0])
sumb =0
123334
for i in range(N):
sumb+=ab[i][1]
if sumb>=K:
print((ab[i][0]))
return
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
a = [int()] * (N) # type: "List[int]"
b = [int()] * (N) # type: "List[int]"
for i in range(N):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, K, a, b)
if __name__ == '__main__':
main()
| p03721 |
# coding: utf-8
def add_list(_n):
_l = []
for _ in range(_n):
a, b = list(map(int, input().split()))
_l.append([a for _ in range(b)])
return [j for i in _l for j in i]
n, k = list(map(int, input().split()))
l = add_list(n)
l.sort()
print(l[k-1])
| # coding: utf-8
l = 10 ** 5
num = [0] * (l + 1)
n, k = list(map(int, input().split()))
for _ in range(n):
a, b = list(map(int, input().split()))
num[a] += b
for i in range(1, l+1):
k -= num[i]
if k <= 0:
print(i)
break
| p03721 |
n,k=list(map(int,input().split()))
a,b=[],[]
for i in range(n):
A,B=list(map(int,input().split()))
b=[A]*B
a=a+b
a.sort()
print((a[k-1])) | n,k=list(map(int,input().split()))
a=[]
for i in range(n):
A=list(map(int,input().split()))
a.append(A)
a = sorted(a, key=lambda x: x[0])
b=0
for i in range(n):
b+=a[i][1]
if b>=k:
print((a[i][0]))
exit() | p03721 |
N, K = [int(i) for i in input().split()]
L = []
for i in range(N):
a, b = [int(j) for j in input().split()]
l = [a]*b
L.extend(l)
L.sort()
print((L[K-1])) | N, K = [int(i) for i in input().split()]
L = []
for i in range(N):
a, b = [int(j) for j in input().split()]
L.append([a, b])
L.sort(key=lambda x: x[0])
#print(L)
cnt = 0
for x, y in L:
cnt += y
if cnt >= K:
ans = x
break
print(ans) | p03721 |
N, K = [int(x) for x in input().split()]
Array = list()
a = 0
b = 0
for i in range(N):
a, b = [int(x) for x in input().split()]
Array.extend([a]*b)
if len(Array) > K:
Array.sort()
Array = Array[:K]
print((Array[K - 1])) | from operator import itemgetter
N, K = [int(x) for x in input().split()]
Array = list()
A = list()
count = 0
ans = 0
for i in range(N):
A.append([int(x) for x in input().split()])
A.sort(key=itemgetter(0))
for i in range(N):
count += A[i][1]
if count >= K:
ans = A[i][0]
break
print(ans) | p03721 |
N,K=list(map(int,input().split()))
Array=[]
for n in range(0,N):
a,b=input().split()
Array+=((a+" ")*int(b)).split()
Array.sort()
print((int(Array[K-1])))
| N,K=list(map(int,input().split()))
Array={}
for n in range(0,N):
a,b=list(map(int,input().split()))
if a in Array:
Array[a]+=b
else:
Array[a]=b
numbers=sorted(list(Array.keys()))
n=0
k=0
while True:
k+=Array[numbers[n]]
if k>=K:
break
n+=1
print((numbers[n]))
| p03721 |
N, K = list(map(int, input().split()))
seq = []
for i in range(N):
a, b = list(map(int, input().split()))
for j in range(b):
seq.append(a)
seq.sort()
print((seq[K-1]))
| from collections import defaultdict
N, K = list(map(int, input().split()))
seq = defaultdict(lambda: 0)
for i in range(N):
a, b = list(map(int, input().split()))
seq[a] += b
values = list(seq.keys())
values.sort()
ans = 0
for i in range(len(values)):
K -= seq[values[i]]
if(K<=0):
print((values[i]))
break
| p03721 |
if __name__ == '__main__':
#入力
N, K = list(map(int,input().split()))
lst = []
for i in range(0,N):
a, b = list(map(int,input().split()))
lst.append([a,b])
ans_lst = []
for i in range(0,N):
a = lst[i][0]
b = lst[i][1]
for j in range(0,b):
ans_lst.append(a)
ans_lst.sort()
print((ans_lst[K-1])) | if __name__ == '__main__':
#入力
N, K = list(map(int,input().split()))
lst = []
for i in range(0,N):
a, b = list(map(int,input().split()))
lst.append([a,b])
lst.sort()
indx = 0
for i in range(0,N):
indx += lst[i][1]
if indx >= K:
ans = lst[i][0]
break
print(ans) | p03721 |
N, K = (int(i) for i in input().split())
L = []
for i in range(N):
a, b = (int(i) for i in input().split())
L = L + [a]*b
if len(L) > K:
L.sort()
L = L[:K]
if L[-1] == 1:
print((1))
break
else:
print((L[-1])) | N, K = (int(i) for i in input().split())
D = {}
count = 0
for i in range(N):
a, b = (int(i) for i in input().split())
if a in D:
D[a] += b
else:
D[a] = b
else:
aL = [a for a in list(D.keys())]
aL.sort()
for a in aL:
count += D[a]
if count >= K:
print(a)
break | p03721 |
N, K = list(map(int, input().split()))
lis = []
for i in range(N):
a, b = list(map(int, input().split()))
lis = lis + [a]*b
lis.sort()
print((lis[K-1])) | N, K = list(map(int, input().split()))
from itertools import accumulate
from bisect import bisect_left
lis = []
lis = [tuple(map(int, input().split())) for i in range(N)]
lis.sort()
Bs = [y for x, y in lis]
cB = list(accumulate(Bs))
print((lis[bisect_left(cB, K)][0]))
| p03721 |
n,k=list(map(int,input().split()))
h=[]
for i in range(n):
a,b=list(map(int,input().split()))
for j in range(b):
h.append(a)
h=sorted(h)
print((h[k-1]))
| n,k = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(n)]
a.sort()
now = 0
for i in a:
now += i[1]
if now >= k:
print((i[0]))
break | p03721 |
N,K = list(map(int,input().split()))
temp = []
c,t = K,-1
for i in range(N):
temp.append(list(map(int,input().split())))
temp.sort()
while c>0:
t += 1
c -= temp[t][1]
print((temp[t][0])) | N,K = list(map(int,input().split()))
temp = []
c,t = K,-1
for i in range(N):
temp.append(list(map(int,input().split())))
temp.sort()
while c>0:
t += 1
c -= temp[t][1]
print((temp[t][0])) | p03721 |
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n,k=list(map(int, input().split()))
l=[]
for i in range(n):
a,b=list(map(int, input().split()))
for j in range(b):
l.append(a)
l.sort()
print((l[k-1]))
resolve() | import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n,k=list(map(int, input().split()))
l=[list(map(int,input().split())) for i in range(n)]
l.sort(key=lambda x:x[0])
kosu=0
for i in range(n):
kosu+=l[i][1]
if kosu>=k:
print((l[i][0]))
break
resolve() | p03721 |
n, k = list(map(int, input().split()))
array = []
for i in range(n):
a, b = list(map(int, input().split()))
for j in range(b):
array.append(a)
array.sort()
print((array[k-1]))
| n, k = list(map(int, input().split()))
number = [[0,0] for i in range(n)]
for i in range(n):
number[i] = list(map(int, input().split()))
number.sort(key=lambda x:(x[0],x[1]))
count = 0
result = 0
for el in number:
count += el[1]
if count >= k:
result = el[0]
break
print(result) | p03721 |
from bisect import bisect_left,bisect_right
N,K=list(map(int,input().split()))
table=[]
for i in range(N):
a,b=list(map(int,input().split()))
table.append([a,b])
table.sort()
cou=[0]*N
cou[0]=table[0][1]
for i in range(1,N):
cou[i]=cou[i-1]+table[i][1]
s = bisect_left(cou,K)
print((table[s][0])) | N,K=list(map(int,input().split()))
table=[]
for i in range(N):
a,b=list(map(int,input().split()))
table.append([a,b])
table.sort()
ans = 0
for x,y in table:
ans += y
if ans >=K:
print(x)
break | p03721 |
NK = list(map(int,input().split()))
AB = []
for _ in range(NK[0]):
I = list(map(int, input().split()))
for _ in range(I[1]):
AB.append(I[0])
print((sorted(AB)[NK[1]-1])) | from operator import itemgetter, attrgetter
NK = list(map(int,input().split()))
AB = sorted([tuple(map(int, input().split())) for _ in range(NK[0])],key = itemgetter(0))
for i,j in AB:
NK[1] = NK[1] - j
if NK[1]<=0:
print(i)
break | p03721 |
n,k=list(map(int, input().split()))
a=[list(map(int, input().split())) for i in range(n)]
a.sort()
#print(a)
b=[]
for i,j in a:
b=b+[i]*j
if len(b)>k:break
print((b[k-1])) | n,k=list(map(int, input().split()))
a=[list(map(int, input().split())) for i in range(n)]
a.sort()
#print(a)
b=[]
c=0
for i,j in a:
k-=j
c=i
if k<=0: break
print(c) | p03721 |
# ABC061C - Big Array
import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().rstrip().split()))
arr = sorted([list(map(int, input().rstrip().split())) for _ in range(n)])
cur, cnt, ans = 0, 0, 0
while cnt < k:
cnt += arr[cur][1]
ans = arr[cur][0]
cur += 1
print(ans)
if __name__ == "__main__":
main() | # ABC061C - Big Array
import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().rstrip().split()))
arr = sorted([list(map(int, input().rstrip().split())) for _ in range(n)])
cur, cnt, ans = 0, 0, 0
for i, j in arr:
ans = i
cnt += j
if cnt >= k:
break
print(ans)
if __name__ == "__main__":
main() | p03721 |
# ABC061C - Big Array
import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().rstrip().split()))
arr = [list(map(int, input().rstrip().split())) for _ in range(n)]
memo = [0] * (10 ** 5 + 1)
for i, j in arr:
memo[i] += j
cnt = 0
for i, j in enumerate(memo):
cnt += j
if cnt >= k:
print(i)
break
if __name__ == "__main__":
main() | # ABC061C - Big Array
import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().rstrip().split()))
memo = [0] * (10 ** 5 + 1)
for _ in range(n):
i, j = list(map(int, input().rstrip().split()))
memo[i] += j
cnt = 0
for i, j in enumerate(memo):
cnt += j
if cnt >= k:
print(i)
break
if __name__ == "__main__":
main() | p03721 |
n, k = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
l = []
for x in ab:
l += [x[0]] * x[1]
print((sorted(l)[k-1])) | n, k = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
length = 0
for x in sorted(ab, key=lambda x: x[0]):
length += x[1]
if length >= k:
print((x[0]))
break | p03721 |
n, k = list(map(int, input().split()))
lst = []
for i in range(n):
a, b = list(map(int, input().split()))
for j in range(b):
lst.extend([a])
lst.sort()
print((lst[k-1])) | n, k = list(map(int, input().split()))
dic = {}
lst = []
ans = 0
for i in range(n):
a, b = list(map(int, input().split()))
if (a in dic)==False:
dic[a] = b
lst.append(a)
else:
dic[a] += b
lst.sort()
for i in range(len(dic)):
if k > (dic[lst[i]] + ans):
ans += dic[lst[i]]
else:
ans = lst[i]
break
print(ans) | p03721 |
n, k = list(map(int, input().split()))
nums = []
for _ in range(n):
a, b = list(map(int, input().split()))
nums.extend([a]*b)
sn = sorted(nums)
print((sn[k-1]))
| n, k = list(map(int, input().split()))
nums = []
for _ in range(n):
ab = list(map(int, input().split()))
nums.append(ab)
sn = sorted(nums)
i = 0
while k > 0:
if sn[i][1] < k:
k -= sn[i][1]
else:
print((sn[i][0]))
break
i += 1
| p03721 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.