input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
from operator import itemgetter
n,m = list(map(int,input().split()))
AB = []
sAB = []
s = 0
c = 0
for i in range(n):
AB.append(list(map(int,input().split())))
sAB = sorted(AB,key=itemgetter(0))
for i,(a,b) in enumerate(sAB):
if c + b < m:
c += b
s += a*b
elif c + b >= m:
for j in range(b):
if c < m:
c += 1
s += a
else:
break
print(s)
|
n,m=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])
ans=0
t=10**10
for a,b in ab:
t=min(b,m)
if t<=0:break
m-=t
ans+=a*t
print(ans)
|
p03103
|
n,m = list(map(int,input().split()))
d = [None]*n
for i in range(n):
a,b = list(map(int,input().split()))
d[i] = [a,b]
d.sort(key=lambda x: x[0])
ryoukin = 0
cnt = 0
for lst in d:
for i in range(lst[1]):
ryoukin += lst[0]
cnt += 1
if cnt == m:
break
if cnt == m:
break
print(ryoukin)
|
n,m = list(map(int,input().split()))
d = [None]*n
for i in range(n):
a,b = list(map(int,input().split()))
d[i] = [a,b]
d.sort(key=lambda x: x[0])
ryoukin = 0
cnt = 0
for lst in d:
for i in range(lst[1]):
ryoukin += lst[0]
cnt += 1
if cnt == m:
break
else:
continue
break
print(ryoukin)
|
p03103
|
n,m = list(map(int,input().split()))
d = [None]*n
for i in range(n):
a,b = list(map(int,input().split()))
d[i] = [a,b]
d.sort(key=lambda x: x[0])
ryoukin = 0
cnt = 0
for lst in d:
for i in range(lst[1]):
ryoukin += lst[0]
cnt += 1
if cnt == m:
print(ryoukin)
exit()
|
import sys
n,m = list(map(int,input().split()))
d = [None]*n
for i in range(n):
a,b = list(map(int,input().split()))
d[i] = [a,b]
d.sort(key=lambda x: x[0])
ryoukin = 0
cnt = 0
for lst in d:
for i in range(lst[1]):
ryoukin += lst[0]
cnt += 1
if cnt == m:
print(ryoukin)
sys.exit()
|
p03103
|
n, m = list(map(int, input().split()))
data = []
for i in range(n):
a, b = list(map(int, input().split()))
data.append([a, b])
data.sort(key=lambda x: x[0]) #値段でソート
prices = []
for p in data:
for i in range(p[1]):
prices.append(p[0])
print((sum(prices[:m])))
|
n, m = list(map(int, input().split()))
data = [] #値段、個数
for i in range(n):
a, b = list(map(int, input().split()))
data.append([a, b])
data.sort(key=lambda x: x[0]) #値段でソート
ans = 0
for p in data:
ans += p[0] * min(m, p[1])
m -= p[1]
if m <= 0:
break
print(ans)
|
p03103
|
N , M = list(map(int,input().split()))
drink = []
for _ in range(N):
a , b = list(map(int,input().split()))
drink.append([a,b])
drink.sort()
value = 0
hold = 0
while hold != M:
if drink[0][1] == 0:
drink.pop(0)
value += drink[0][0]
hold += 1
drink[0][1] -= 1
print(value)
|
N, M = list(map(int, input().split()))
shops = list(list(map(int, input().split())) for _ in range(N))
shops.sort()
ans = 0
for value, count in shops:
tmp_M = max(M - count , 0)
ans += (M - tmp_M) * value
M = tmp_M
if M == 0:
break
print(ans)
|
p03103
|
from sys import stdin
n,m = [int(x) for x in stdin.readline().rstrip().split()]
li = [list(map(int,stdin.readline().rstrip().split())) for _ in range(n)]
li.sort(key=lambda x:(x[0],x[1]))
cost = 0
while m > 0:
if li[0][1] > 0:
cost += li[0][0]
li[0][1] -= 1
m -= 1
else:
li.pop(0)
print(cost)
|
from sys import stdin
n,m = list(map(int,stdin.readline().rstrip().split()))
li = [list(map(int,stdin.readline().rstrip().split())) for _ in range(n)]
li.sort()
yen = 0
for i in li:
j,k = i
if k >= m:
yen += j*m
break
yen += j*k
m -= k
print(yen)
|
p03103
|
s = input().split()
N = int(s[0])
M = int(s[1])
AB = {}
for i in range(N):
data = input().split()
if int(data[0]) in list(AB.keys()):
AB[int(data[0])] += int(data[1])
else:
AB[int(data[0])] = int(data[1])
AB = sorted(AB.items())
money = 0
num = 0
for A,B in AB:
for b in range(B):
num += 1
money += A
if num == M:
break
if num == M:
break
print((int(money)))
|
s = input().split()
N = int(s[0])
M = int(s[1])
AB = {}
for i in range(N):
data = input().split()
if int(data[0]) in list(AB.keys()):
AB[int(data[0])] += int(data[1])
else:
AB[int(data[0])] = int(data[1])
AB = sorted(AB.items())
money = 0
num = 0
for A,B in AB:
if num+B < M:
money += A*B
num += B
elif num+B == M:
money += A*B
break
elif num+B > M:
money += A*(M-num)
break
print((int(money)))
|
p03103
|
def main():
n, m = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for i, j in ab:
if m < j:
ans += i*m
break
m -= j
ans += i*j
print(ans)
main()
|
import sys
input = sys.stdin.readline
def main():
n, m = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for i, j in ab:
if m < j:
ans += i*m
break
m -= j
ans += i*j
print(ans)
main()
|
p03103
|
N,M=list(map(int,input().split()))
yen=[]
hon=[]
for i in range(N):
a,b=list(map(int,input().split()))
yen.append(a)
hon.append(b)
loop=True
pay=0
while loop:
mise=yen.index(min(yen))
value=yen[mise]
stock=hon[mise]
if M>stock:
pay+=stock*value
else:
pay+=M*value
M-=stock
del yen[mise]
del hon[mise]
if M<=0:
loop=False
print(pay)
|
N,M=list(map(int,input().split()))
mises=[]
for i in range(N):
mises.append(list(map(int,input().split())))
mises.sort()
pay=0
for i in mises:
if i[1]<M:
pay+=i[0]*i[1]
M-=i[1]
else:
pay+=i[0]*M
break
print(pay)
|
p03103
|
def is_prime(x):
# Perform prime number discrimination for odd numbers of 3 or more.
return pow(2, x - 1, x) == 1
def solve():
n = int(input())
ans = []
print("{}: ".format(n), end='')
while n % 2 == 0:
n //= 2
ans.append(2)
d = 3
while n >= d:
if is_prime(d):
while n % d == 0:
n //= d
ans.append(d)
d += 2
print(*ans)
solve()
|
def is_prime(x):
if x == 1:
return False
elif x == 2:
return True
elif x % 2 == 0:
return False
l = x ** 0.5
n = 3
while n <= l:
if x % n == 0:
return False
n += 2
return True
def solve():
n = int(input())
print("{}: ".format(n), end='')
ans = []
while n % 2 == 0:
n //= 2
ans.append(2)
d = 3
while n >= d:
if is_prime(d):
while n % d == 0:
n //= d
ans.append(d)
if is_prime(n):
ans.append(n)
break
d += 2
print(*ans)
solve()
|
p02467
|
def is_prime(x):
if x == 1:
return False
elif x == 2:
return True
elif x % 2 == 0:
return False
l = x ** 0.5
n = 3
while n <= l:
if x % n == 0:
return False
n += 2
return True
def solve():
n = int(input())
print("{}: ".format(n), end='')
ans = []
while n % 2 == 0:
n //= 2
ans.append(2)
d = 3
while n >= d:
if is_prime(d):
while n % d == 0:
n //= d
ans.append(d)
if is_prime(n):
ans.append(n)
break
d += 2
print(*ans)
solve()
|
def is_prime(x):
# Perform prime number discrimination for odd numbers of 3 or more.
return pow(2, x - 1, x) == 1
def solve():
n = int(input())
print("{}: ".format(n), end='')
if is_prime(n):
print(n)
else:
ans = []
while n % 2 == 0:
n //= 2
ans.append(2)
d = 3
while d <= n ** 0.5:
if is_prime(d):
while n % d == 0:
n //= d
ans.append(d)
d += 2
if is_prime(n):
ans.append(n)
print(*ans)
solve()
|
p02467
|
N = int(input())
n = N
m = N ** 0.5
L = []
i = 3
print(str(N) + ': ', end = '')
while n%2 == 0:
n = n/2
L.append(2)
while i <= N:
while n%i == 0:
n = n/i
L.append(i)
i += 2
#if len(L) == 0:
# L.append(N)
print(' '.join(map(str, L)))
|
N = int(input())
n = N
m = N ** 0.5
L = []
i = 3
print(str(N) + ': ', end = '')
while n%2 == 0:
n = n/2
L.append(2)
while i <= m:
while n%i == 0:
n = n/i
L.append(i)
i += 2
if n not in L:
L.append(int(n))
if 1 in L:
L.remove(1)
if len(L) == 0:
L.append(N)
print(' '.join(map(str, L)))
|
p02467
|
# -*- coding:utf-8 -*-
n = int(input())
print(str(n)+':',end='')
array = []
count = 0
while True:
for i in range(2,n+1):
if n%i == 0 and i != n:
array.append(i)
n = int(n/i)
break
if i == n:
count += 1
break
if count == 5:
break
array.append(n)
for i in range(len(array)):
print(' ',array[i],sep = '',end='')
print('')
|
# -*- coding:utf-8 -*-
n = int(input())
print(str(n)+':',end='')
array = []
count = 0
while True:
if n == 999993031:
break
for i in range(2,n+1):
if n%i == 0 and i != n:
array.append(i)
n = int(n/i)
break
if i == n:
count += 1
break
if count == 24:
break
array.append(n)
for i in range(len(array)):
print(' ',array[i],sep = '',end='')
print('')
|
p02467
|
n = int(eval(input()))
orig_n = n
res=[]
i = 2
half_n = n // 2
root_n = int(n ** (1/2))
is_prime = True
while i <= (root_n):
if orig_n % i == 0:
is_prime = False
break
while i <= half_n and not(is_prime):
if n ==1:
break
if n % i == 0:
n = n // i
res.append(i)
i = 1
i += 1
print(("{0}: {1}".format(orig_n, " ".join(map(str, res)))))
|
n = int(eval(input()))
orig_n = n
res=[]
i = 2
half_n = n // 2
root_n = int(n ** (1/2))
is_prime = True
while i <= (root_n):
if orig_n % i == 0:
is_prime = False
break
i += 1
if is_prime: res.append(orig_n)
while i <= half_n and not(is_prime):
if n ==1:
break
if n % i == 0:
n = n // i
res.append(i)
i = 1
i += 1
print(("{0}: {1}".format(orig_n, " ".join(map(str, res)))))
|
p02467
|
#! -*- coding: utf-8-unix -*-
import sys
# if __name__=='__main__':
# lines = [int(x.strip()) for x in sys.stdin.readlines()]
# print lines
# n = lines[0]
# for i in xrange(n):
# # a, b = int(lines[i+1]), int(lines[i+2])
# a, b = lines[2*i+1], lines[2*i+2]
# if len(str(a+b)) > 80:
# print 'overflow'
# else:
# print a+b
if __name__=='__main__':
# lines = [int(x.strip()) for x in sys.stdin.readlines()]
# n = lines[0]
n = eval(input())
for i in range(n):
# a, b = int(lines[i+1]), int(lines[i+2])
# a, b = lines[2*i+1], lines[2*i+2]
a, b = eval(input()), eval(input())
if len(str(a+b)) > 80:
print('overflow')
else:
print(a+b)
|
import sys
if __name__=='__main__':
lines = [int(x.strip()) for x in sys.stdin.readlines() if x != '' and x != '\n']
n = lines[0]
for i in range(n):
a, b = lines[2*i+1], lines[2*i+2]
if len(str(a+b)) > 80:
print('overflow')
else:
print(a+b)
|
p00015
|
import math
n = int(eval(input()));
for i in range(n):
num1 = int(eval(input()));
num2 = int(eval(input()));
total = num1 + num2;
if len(str(total)) > 80:
print("overflow");
else:
print(total);
|
import math
n = int(eval(input()));
for i in range(0,n):
num1 = int(eval(input()));
num2 = int(eval(input()));
total = num1 + num2;
if len(str(total)) > 80:
print("overflow");
else:
print(total);
|
p00015
|
# AOJ 0015 National Budget
# Python3 2018.6.9 bal4u
n = int(eval(input()))
for i in range(n):
a = str(eval(input()))
b = str(eval(input()))
if len(a) > 80 or len(b) > 80:
print('overflow')
else:
s = str(int(a)+int(b))
if len(s) <= 80:
print(s)
else:
print('overflow')
|
# AOJ 0015 National Budget
# Python3 2018.6.9 bal4u
n = int(eval(input()))
for i in range(n):
s = int(eval(input())) + int(eval(input()))
if len(str(s)) <= 80:
print(s)
else:
print('overflow')
|
p00015
|
s="overflow"
n=eval(input())
for i in range(n):
a=input()
b=input()
if len(a)>80 or len(b)>80: print(s)
else:
tmp=int(a)+int(b)
if len(str(tmp))>80: print(s)
else: print(tmp)
|
m=10**80
n=eval(input())
for i in range(n):
s="overflow"
a=eval(input())
b=eval(input())
if a<m and b<m:
tmp=a+b
if tmp<m: s=tmp
print(s)
|
p00015
|
import sys;sys.setrecursionlimit(10**9)
class UnionFind:
def __init__(self,n):
self.n=[-1]*n
self.r=[0]*n
self.siz=n
def find_root(self,x):
if self.n[x]<0:
return x
else:
self.n[x]=self.find_root(self.n[x])
return self.n[x]
def unite(self,x,y):
x=self.find_root(x)
y=self.find_root(y)
if x==y:return
elif self.r[x]>self.r[y]:
self.n[x]+=self.n[y]
self.n[y]=x
else:
self.n[y]+=self.n[x]
self.n[x]=y
if self.r[x]==self.r[y]:
self.r[y]+=1
self.siz-=1
def root_same(self,x,y):
return self.find_root(x)==self.find_root(y)
def count(self,x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
from collections import defaultdict
n,x,y=map(int,input().split())
mod=10**9+7
f=[1]
for i in range(1,n+7):f.append(f[-1]*i%mod)
cw=[list(map(int,input().split()))for _ in range(n)]
if n==1:exit(print(1))
if len(set(c for c,w in cw))==1:exit(print(1))
for i in range(n):cw[i][0]-=1
miw=[10**10]*n
miwi=[0]*n
for i in range(n):
c,w=cw[i]
if miw[c]>w:
miw[c]=w
miwi[c]=i
mminc=miw.index(min(miw))
temp=10**10
for i in range(n):
if i!=mminc:temp=min(temp,miw[i])
sminc=miw.index(temp)
u=UnionFind(n)
for i in range(n):
c,w=cw[i]
if c==mminc:tc=sminc
else:tc=mminc
if miw[c]+w<=x:u.unite(miwi[c],i)
if miw[tc]+w<=y:u.unite(miwi[tc],i)
d=[0]*n
for i in range(n):
if i==u.find_root(i):d[i]=defaultdict(int)
for i in range(n):
c,w=cw[i]
d[u.find_root(i)][c]+=1
ans=1
for i in range(n):
if i==u.find_root(i):
anss=1
co=0
for j in d[i]:
anss*=pow(f[d[i][j]],mod-2,mod)
anss%=mod
co+=d[i][j]
anss*=f[co]
ans=(ans*anss)%mod
print(ans)
|
#-----UnionFind-----(0-indexed)
import sys;sys.setrecursionlimit(10**9)
class UnionFind:
def __init__(self,n):
self.n=[-1]*n
self.r=[0]*n
self.siz=n
def find_root(self,x):
if self.n[x]<0:
return x
else:
self.n[x]=self.find_root(self.n[x])
return self.n[x]
def unite(self,x,y):
x=self.find_root(x)
y=self.find_root(y)
if x==y:return
elif self.r[x]>self.r[y]:
self.n[x]+=self.n[y]
self.n[y]=x
else:
self.n[y]+=self.n[x]
self.n[x]=y
if self.r[x]==self.r[y]:
self.r[y]+=1
self.siz-=1
def root_same(self,x,y):
return self.find_root(x)==self.find_root(y)
def count(self,x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
from collections import defaultdict
n,x,y=map(int,input().split())
mod=10**9+7
f=[1]
for i in range(1,n+7):f.append(f[-1]*i%mod)
cw=[list(map(int,input().split()))for _ in range(n)]
if n==1:exit(print(1))
if len(set(c for c,w in cw))==1:exit(print(1))
for i in range(n):cw[i][0]-=1
miw=[10**10]*n
miwi=[0]*n
for i in range(n):
c,w=cw[i]
if miw[c]>w:
miw[c]=w
miwi[c]=i
mminc=miw.index(min(miw))
temp=10**10
for i in range(n):
if i!=mminc:temp=min(temp,miw[i])
sminc=miw.index(temp)
u=UnionFind(n)
for i in range(n):
c,w=cw[i]
if c==mminc:tc=sminc
else:tc=mminc
if miw[c]+w<=x:u.unite(miwi[c],i)
if miw[tc]+w<=y:u.unite(miwi[tc],i)
d=[0]*n
for i in range(n):
if i==u.find_root(i):d[i]=defaultdict(int)
for i in range(n):
c,w=cw[i]
d[u.find_root(i)][c]+=1
ans=1
for i in range(n):
if i==u.find_root(i):
anss=1
co=0
for j in d[i]:
anss*=pow(f[d[i][j]],mod-2,mod)
anss%=mod
co+=d[i][j]
anss*=f[co]
ans=(ans*anss)%mod
print(ans)
|
p03770
|
import heapq
from collections import defaultdict
from functools import lru_cache
from bisect import bisect_right
while True:
N, M, C, S, G = list(map(int, input().split()))
if N == M == C == S == G == 0: # 駅の数、路線の数10000、鉄道会社の数20、出発駅、目的地駅
break
E = [[[] for _ in range(N + 1)] for _ in range(C + 1)]
D = [[[float("inf")] * (N + 1) for _ in range(N + 1)] for _ in range(C + 1)]
for _ in range(M):
x, y, d, c = list(map(int, input().split())) # d<=200
D[c][x][y] = min(D[c][x][y], d)
D[c][y][x] = min(D[c][x][y], d)
P = list(map(int, input().split())) # <= 50
Q = []
R = []
for _ in range(C):
Q.append(list(map(int, input().split())) + [1 << 30])
R.append(list(map(int, input().split())))
cum_fare = []
for c_ in range(C):
fare_ = [0]
res = 0
q_p = 0
for q, r in zip(Q[c_][:-1], R[c_][:-1]):
res += (q - q_p) * r
q_p = q
fare_.append(res)
cum_fare.append(fare_)
@lru_cache(maxsize=None)
def fare(d_, c_):
if d_==float("inf"):
return float("inf")
c_ -= 1
idx = bisect_right(Q[c_], d_)
#print(c_, idx, cum_fare[c_], R[c_])
return cum_fare[c_][idx] + (R[c_][0] * d_ if idx==0 else (d_ - Q[c_][idx-1]) * R[c_][idx])
DD = [[float("inf")] * (N + 1) for _ in range(N + 1)]
for c in range(1, C + 1):
D_ = D[c]
for k in range(1, N + 1):
for i in range(1, N + 1):
for j in range(1, N + 1):
d_ = D_[i][k] + D_[k][j]
if D_[i][j] > d_:
D_[i][j] = d_
# print(D_)
for i in range(1, N + 1):
for j in range(1, N + 1):
DD[i][j] = min(DD[i][j], fare(D_[i][j], c))
# print(DD)
dist = defaultdict(lambda: float("inf"))
q = []
start = S
dist[start] = 0
heapq.heappush(q, (0, start))
while len(q) != 0:
prob_cost, v = heapq.heappop(q)
# print(prob_cost, v)
if dist[v] < prob_cost:
continue
if v == G:
print(prob_cost)
break
for u, c in enumerate(DD[v]):
if dist[u] > dist[v] + c:
dist[u] = dist[v] + c
heapq.heappush(q, (dist[u], u))
else:
print((-1))
|
import heapq
from collections import defaultdict
from functools import lru_cache
from bisect import bisect_right
while True:
N, M, C, S, G = list(map(int, input().split()))
if N == M == C == S == G == 0: # 駅の数、路線の数10000、鉄道会社の数20、出発駅、目的地駅
break
#E = [[[] for _ in range(N + 1)] for _ in range(C + 1)]
D = [[[float("inf")] * (N + 1) for _ in range(N + 1)] for _ in range(C + 1)]
CE = [set() for _ in range(C+1)]
for _ in range(M):
x, y, d, c = list(map(int, input().split())) # d<=200
D[c][x][y] = min(D[c][x][y], d)
D[c][y][x] = min(D[c][x][y], d)
CE[c].add(x)
CE[c].add(y)
P = list(map(int, input().split())) # <= 50
Q = []
R = []
for _ in range(C):
Q.append(list(map(int, input().split())) + [1 << 30])
R.append(list(map(int, input().split())))
cum_fare = []
for c_ in range(C):
fare_ = [0]
res = 0
q_p = 0
for q, r in zip(Q[c_][:-1], R[c_][:-1]):
res += (q - q_p) * r
q_p = q
fare_.append(res)
cum_fare.append(fare_)
@lru_cache(maxsize=None)
def fare(d_, c_):
if d_==float("inf"):
return float("inf")
c_ -= 1
idx = bisect_right(Q[c_], d_)
#print(c_, idx, cum_fare[c_], R[c_])
return cum_fare[c_][idx] + (R[c_][0] * d_ if idx==0 else (d_ - Q[c_][idx-1]) * R[c_][idx])
DD = [[float("inf")] * (N + 1) for _ in range(N + 1)]
for c in range(1, C + 1):
D_ = D[c]
l = list(CE[c])
for k in l:
for i in l:
for j in l:
d_ = D_[i][k] + D_[k][j]
if D_[i][j] > d_:
D_[i][j] = d_
# print(D_)
for i in l:
for j in l:
DD[i][j] = min(DD[i][j], fare(D_[i][j], c))
# print(DD)
dist = defaultdict(lambda: float("inf"))
q = []
start = S
dist[start] = 0
heapq.heappush(q, (0, start))
while len(q) != 0:
prob_cost, v = heapq.heappop(q)
# print(prob_cost, v)
if dist[v] < prob_cost:
continue
if v == G:
print(prob_cost)
break
for u, c in enumerate(DD[v]):
if dist[u] > dist[v] + c:
dist[u] = dist[v] + c
heapq.heappush(q, (dist[u], u))
else:
print((-1))
|
p00763
|
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 = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-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 S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,m,k = LI()
d = LI()
v = [LI() for _ in range(n)]
u = set()
ds = set(d)
u.add(tuple(d))
q = [(tuple(d), 1)]
while q:
qd, qk = q.pop(0)
for vi in range(k):
t = set()
for di in qd:
t.add(v[di-1][vi])
t &= ds
tt = tuple(t)
if tt in u:
continue
if len(tt) == 0:
return qk
u.add(tt)
q.append((tt,qk+1))
return -1
print(main())
|
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 = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-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 S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,m,k = LI()
d = LI_()
v = [LI_() for _ in range(n)]
dd = collections.defaultdict(lambda: None)
for i in range(m):
dd[d[i]] = i
vv = []
for c in d:
vv.append([dd[v[c][i]] for i in range(k)])
vvv = [[vv[i][j] for i in range(m)] for j in range(k)]
u = set()
m2 = 2**m
u.add(m2-1)
q = [(m2-1, 1)]
ii = [2**_ for _ in range(m)]
# print('vv',vv)
while q:
qd, qk = q.pop(0)
# print('q', qd,qk)
qdi = [di for di in range(m) if qd & ii[di]]
for vi in range(k):
t = 0
vvi = vvv[vi]
for di in qdi:
if not vvi[di] is None:
t |= ii[vvi[di]]
# print('vit',vi,t)
if t in u:
continue
if t == 0:
return qk
u.add(t)
q.append((t,qk+1))
return -1
print(main())
|
p01812
|
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 = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-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 S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,m,k = LI()
d = LI_()
v = [LI_() for _ in range(n)]
dd = collections.defaultdict(lambda: None)
for i in range(m):
dd[d[i]] = i
vv = []
for c in d:
vv.append([dd[v[c][i]] for i in range(k)])
vvv = [[vv[i][j] for i in range(m)] for j in range(k)]
u = set()
m2 = 2**m
u.add(m2-1)
q = [(m2-1, 1)]
ii = [2**_ for _ in range(m)]
# print('vv',vv)
while q:
qd, qk = q.pop(0)
# print('q', qd,qk)
qdi = [di for di in range(m) if qd & ii[di]]
for vi in range(k):
t = 0
vvi = vvv[vi]
for di in qdi:
if not vvi[di] is None:
t |= ii[vvi[di]]
# print('vit',vi,t)
if t in u:
continue
if t == 0:
return qk
u.add(t)
q.append((t,qk+1))
return -1
print(main())
|
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 = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-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 S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,m,k = LI()
d = LI_()
v = [LI_() for _ in range(n)]
dd = collections.defaultdict(lambda: None)
for i in range(m):
dd[d[i]] = i
ii = [2**_ for _ in range(m)]
vv = [[ii[dd[v[c][i]]] if not dd[v[c][i]] is None else 0 for c in d] for i in range(k)]
m2 = 2**m
u = [None] * m2
u[-1] = 1
q = [m2-1]
r = 0
while q:
r += 1
nq = []
for qd in q:
qdi = [di for di in range(m) if qd & ii[di]]
for vi in range(k):
t = 0
vvi = vv[vi]
for di in qdi:
t |= vvi[di]
if not u[t] is None:
continue
if t == 0:
return r
u[t] = 1
nq.append(t)
q = nq
return -1
print(main())
|
p01812
|
n=int(eval(input()))
a=list(map(int,input().split()))
k=0
b=[]
for i in range(0,n+1):
k+=a[i]*pow(2,n-i)
b.append(k)
if k>pow(2,n):
print((-1))
else:
current=0
ans=0
for i in range(0,n+1):
current+=a[n-i]
if i==n:
ans+=1
else:
s=(pow(2,n)-b[n-i-1])//pow(2,i)
if (s+1)*pow(2,i)<=pow(2,n)-b[n-i-1]:
s+=1
current=min(current,s)
current=min(current,pow(2,n-i))
ans+=current
print(ans)
|
n=int(eval(input()))
a=list(map(int,input().split()))
k=0
N=sum(a)
failflag=0
node=1
min1=[]
min2=[]
for i in range(0,n+1):
node=node*2-a[i]
if i==0:
node=1-a[0]
node=min(node,N)
min1.append(node+a[i])
if node<0:
failflag=1
if failflag==1:
print((-1))
else:
current=0
for i in range(0,n+1):
current+=a[n-i]
min2.append(current)
min2.reverse()
ans=0
for i in range(0,n+1):
ans+=min(min1[i],min2[i])
print(ans)
|
p02665
|
import sys
input = sys.stdin.readline
from collections import *
N = int(eval(input()))
A = list(map(int, input().split()))
low = [0]*(N+1)
high = [0]*(N+1)
low[N] = A[N]
high[N] = A[N]
if A[N]>2**N:
print((-1))
exit()
for i in range(N-1, -1, -1):
low[i] = (low[i+1]+1)//2+A[i]
high[i] = high[i+1]+A[i]
lim = 2**i
if low[i]>lim:
print((-1))
exit()
high[i] = min(high[i], lim)
now = 1
ans = now
#print(low)
#print(high)
for i in range(N):
now = min(high[i+1], 2*now)
ans += now
now -= A[i+1]
print(ans)
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
low = [0]*(N+1)
high = [0]*(N+1)
low[N] = A[N]
high[N] = A[N]
for i in range(N-1, -1, -1):
low[i] = (low[i+1]+1)//2+A[i]
high[i] = high[i+1]+A[i]
if not low[0]<=1<=high[0]:
print((-1))
exit()
ans = 1
now = 1
for i in range(N):
now = min(2*(now-A[i]), high[i+1])
ans += now
print(ans)
|
p02665
|
N, *A = list(map(int, open(0).read().split()))
cnt = [0] * (N + 1)
cnt[0] = 1
for i in range(N):
cnt[i + 1] = (cnt[i] - A[i]) * 2
ans = 0
cur = 0
for i in reversed(list(range(N + 1))):
cur += A[i]
ans += min(cnt[i], cur)
if all(cnt[i] >= A[i] for i in range(N + 1)):
print(ans)
else:
print((-1))
|
N = int(eval(input()))
X = list(map(int, input().split()))
cnt = [0] * (N + 1)
cnt[0] = 1
for i in range(N):
cnt[i + 1] = (cnt[i] - X[i]) * 2
ans = 0
cur = 0
for i in reversed(list(range(N + 1))):
cur += X[i]
ans += min(cnt[i], cur)
if all(cnt[i] >= X[i] for i in range(N + 1)):
print(ans)
else:
print((-1))
|
p02665
|
n=int(eval(input()))
a=list(map(int,input().split()))
tot=sum(a)
v=[1]
for q in a:
tot-=q
v.append(min(2*(v[-1]-q),tot))
if all([u>=0 for u in v]):
print((sum(v)))
else:
print((-1))
|
n,*a=list(map(int,open(0).read().split()))
tot=sum(a)
v=[1]
for q in a:
tot-=q
vt=min(2*(v[-1]-q),tot)
if vt<0:
print((-1))
exit()
v.append(vt)
print((sum(v)))
|
p02665
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
pos = [pow(2, i) - a[i] for i in range(n+1)]
for i in range(n):
pos[i+1] = pos[i] * 2 - a[i+1]
for i in range(n+1):
if pos[i] < 0:
print((-1))
exit()
cnt = a[-1]
memo = 0
for i in range(n-1, -1, -1):
cnt += min(pos[i], memo + a[i+1]) + a[i]
memo = min(pos[i], memo + a[i+1])
print(cnt)
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
pos = [0 for i in range(n+1)]
pos[0] = 1 - a[0]
for i in range(n):
pos[i+1] = pos[i] * 2 - a[i+1]
for i in range(n+1):
if pos[i] < 0:
print((-1))
exit()
cnt = a[-1]
memo = 0
for i in range(n-1, -1, -1):
cnt += min(pos[i], memo + a[i+1]) + a[i]
memo = min(pos[i], memo + a[i+1])
print(cnt)
|
p02665
|
N=int(eval(input()))
A=list(map(int,input().split()))[::-1]
def f(A):
nodes=[]
for i in list(range(len(A))):
t = len(A)-i-1
if i == 0:
if 2**t < A[i]:
return -1
nodes.append(A[i])
else:
tmp = min(nodes[-1] + A[i],2**t)
anchor = (tmp-A[i])*2
if anchor < nodes[-1]:
flag = True
for j in range(len(nodes))[::-1]:
if anchor < nodes[j]:
nodes[j] = anchor
anchor = (nodes[j]-A[j])*2
else:
flag = False
break
if flag : return -1
nodes.append(tmp)
return sum(nodes)
print((f(A)))
|
N = int(eval(input()))
A = list(map(int, input().split()))
def solve(A):
ans = 0
leaves = sum(A)
prev_node_capacity = 1
for ai in A:
if ai > prev_node_capacity:
return -1
ans += min(prev_node_capacity, leaves)
leaves -= ai
prev_node_capacity -= ai
prev_node_capacity *= 2
return ans
print((solve(A)))
|
p02665
|
# coding: utf-8
def solve(*args: str) -> str:
n = int(args[0])
A = list(map(int, args[1].split()))
if 0 < A[0]:
return '1' if n == 0 and A[0] == 1 else '-1'
R = [0]*(n+1)
R[0] = 1
for i in range(1, n+1):
R[i] = 2*(R[i-1]-A[i-1])
prev = 0
ret = 0
for i in range(n, -1, -1):
if R[i] < A[i]:
ret = -1
break
prev = min(R[i], A[i]+prev)
ret += prev
return str(ret)
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
|
# coding: utf-8
def solve(*args: str) -> str:
n = int(args[0])
A = list(map(int, args[1].split()))
rem = sum(A)
cur = 1
ret = 0
for a in A:
cur = min(rem, cur)
rem -= a
ret += cur
cur = 2*(cur-a)
if cur < 0:
ret = -1
break
return str(ret)
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
|
p02665
|
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
if N==0:
if A[0] == 1:
print((1))
else:
print((-1))
return
prev = 0
leafs = 0
ans = 0
for i, a in enumerate(A):
leafs = leafs*2 + a
rem = pow(2,i) - leafs
k = min(rem,sum(A[i+1:]))
# print(A[i+1:])
# print(k)
ans+=k
# print(leafs)
rem = pow(2,N) - leafs
if rem<0:
print((-1))
return
print((ans+sum(A)))
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N - 0 + 1)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
if N==0:
if A[0] == 1:
print((1))
else:
print((-1))
return
s = [0]*(N+1)
s[N] = A[N]
for i in range(N-1, -1, -1):
s[i] = s[i+1] + A[i]
leafs = 0
ans = 0
for i, a in enumerate(A):
leafs = leafs*2 + a
rem = pow(2,i) - leafs
if i<N:
# print(sum(A[i+1:]), s[i+1])
k = min(rem, s[i+1])
ans+=k
# print(leafs)
rem = pow(2,N) - leafs
if rem<0:
print((-1))
return
print((ans+sum(A)))
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N - 0 + 1)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
|
p02665
|
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n = int(ipt())
a = [int(i) for i in ipt().split()]
if n == 0 and a[0] == 0:
print((-1))
exit()
elif n == 0 and a[0] == 1:
print((1))
exit()
elif n == 0 and a[0] > 1:
print((-1))
exit()
suma = sum(a)
ans = a[0]
can = 1
for i,ai in enumerate(a):
if ai > can:
print((-1))
exit()
suma -= ai
ans += can
if (can-ai)*2 >= suma:
can = suma
else:
can = (can-ai)*2
print(ans)
return
if __name__ == '__main__':
main()
|
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n = int(ipt())
a = [int(i) for i in ipt().split()]
suma = sum(a)
ans = 0
can = 1
for i,ai in enumerate(a):
if ai > can:
print((-1))
exit()
suma -= ai
ans += can
if (can-ai)*2 >= suma:
can = suma
else:
can = (can-ai)*2
print(ans)
return
if __name__ == '__main__':
main()
|
p02665
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
if n == 0:
if a[0] == 1 or a[0] == 0:
print((1))
quit()
else:
print((-1))
quit()
for i in range(n):
if a[i] > 2**i - 1:
print((-1))
quit()
if a[-1] > 2**n:
print((-1))
quit()
lst = [1]
for i in range(1, n+1):
l = lst[-1] - a[i-1]
if l <= 0:
print((-1))
quit()
lst.append(2*l)
if lst[-1] - a[-1] < 0:
print((-1))
quit()
i = n-1
tmp = a[-1]
ans = 0
lst2 = [a[-1]]
while i >= 0:
tmp += a[i]
tmp = min(tmp, 2**i)
lst2.append(tmp)
i -= 1
lst2 = lst2[::-1]
for i in range(n+1):
ans += min(lst[i], lst2[i])
print(ans)
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
L = [1]
if a[-1] > 2**n:
print((-1))
quit()
if n == 0:
if a[0] == 0:
print((-1))
quit()
L2 = [a[-1]]
for i in range(n)[::-1]:
L2.append(min(L2[-1] + a[i], 2**i))
L2 = L2[::-1]
ans = 0
for i in range(n+1):
if i == 0:
tmp = 1
else:
tmp = (L[-1] - a[i-1]) * 2
if tmp <= 0:
print((-1))
quit()
ans += min(tmp, L2[i])
L.append(tmp)
if L[-1] - a[-1] < 0:
print((-1))
quit()
print(ans)
|
p02665
|
def main():
N = int( eval(input()))
A = list( map( int, input().split()))
root = 1
if A[0] == 1:
if N == 0:
print((1))
else:
print((-1))
return
B = A[::-1]
low = high = B[0]
# Low = []
Hight = [high]
Low = [low]
for b in B[1:]:
low = max(1, (low+1)//2) + b
high = high + b
Hight.append(high)
Low.append(low)
if low > 1:
print((-1))
return
ans = 1
now = 1
BHight = Hight[::-1]
BLow = Low[::-1]
for i in range(1,N+1):
high = BHight[i]
low = BLow[i]
if high < now or now*2 < low:
print((-1))
return
leaf = A[i]
now = min(high, now*2)
ans += now
now -= leaf
print(ans)
if __name__ == '__main__':
main()
|
#import sys
#input = sys.stdin.readline
def main():
N = int( eval(input()))
A = list( map( int, input().split()))
root = 1
if A[0] == 1:
if N == 0:
print((1))
else:
print((-1))
return
B = A[::-1]
low = high = B[0]
# Low = []
Hight = [high]
for b in B[1:]:
low = max(1, (low+1)//2) + b
high = high + b
Hight.append(high)
if low > 1:
print((-1))
return
ans = 1
now = 1
BHight = Hight[::-1]
for i in range(1,N+1):
h = BHight[i]
leaf = A[i]
# print("h",h)
now = min(h, now*2)
ans += now
now -= leaf
# print(now)
print(ans)
if __name__ == '__main__':
main()
|
p02665
|
n = int(eval(input()))
A = list(map(int, input().split()))
if n==0:
print((1 if A[0] == 1 else -1))
exit()
if A[0]!=0:
print((-1))
exit()
node1=[0]*(n+1)
node1[0]=1
node2=[0]*(n+1)
node2[0]=1
node2[-1]=A[-1]
for i in range(n):
x=(node1[i]-A[i])*2
node1[i+1]=x
for i in range(n,0,-1):
x=(node2[i]+A[i-1])
node2[i-1]=x
ans=[]
for i in range(n+1):
x=min(node1[i],node2[i])
if x<A[i]:
print((-1))
exit()
ans.append(x)
print((sum(ans)))
|
n = int(eval(input()))
A = list(map(int, input().split()))
if n==0:
print((1 if A[0] == 1 else -1))
exit()
if A[0]>0:
print((-1))
exit()
if A[-1]>2**n:
print((-1))
exit()
node1=[0]*(n+1)
node1[0]=1
node2=[0]*(n+1)
node2[-1]=A[-1]
for i in range(n):
x=(node1[i]-A[i])*2
if x<1:
print((-1))
exit()
node1[i+1]=x
#print(node1)
for i in range(n-1,-1,-1):
x=(node2[i+1]+A[i])
node2[i]=x
ans=[]
for i in range(n+1):
x=min(node1[i],node2[i])
if x<A[i]:
print((-1))
exit()
ans.append(x)
print((sum(ans)))
|
p02665
|
from math import ceil
def a():
N = int(eval(input()))
A = list(map(int,input().split()))
INF = 10**13
if N == 0:
if A[0] == 1:
return 1
else:
return -1
BMAX = [INF] * (N+1)
BMIN = [1] * (N+1)
a = 1
for i in range(N+1):
BMAX[i] = min(BMAX[i] , a - A[i])
a = BMAX[i] * 2
BMAX[N] = 0
BMIN[0] = 1
BMIN[N] = 0
for i in range(N-1,-1,-1):
BMAX[i] = min(BMAX[i],BMAX[i+1]+A[i+1])
BMIN[i] = max(BMIN[i],ceil((BMIN[i+1]+A[i+1])/2))
for i in range(1,N+1):
BMAX[i] = min(BMAX[i],BMAX[i-1]*2-A[i])
BMIN[i] = max(BMIN[i],BMIN[i-1]-A[i])
ans = 0
for i in range(0,N+1):
if BMIN[i] > BMAX[i]:
return -1
ans += (BMAX[i] + A[i])
return ans
print((a()))
|
from math import ceil
def a():
N = int(eval(input()))
A = list(map(int,input().split()))
INF = 10**13
if N == 0:
if A[0] == 1:
return 1
else:
return -1
BMAX = [INF] * (N+1)
BMIN = [1] * (N+1)
BMAX[0] = 1 - A[0]
BMAX[N] = 0
BMIN[0] = 1
BMIN[N] = 0
for i in range(N-1,-1,-1):
BMAX[i] = min(BMAX[i],BMAX[i+1]+A[i+1])
BMIN[i] = max(BMIN[i],ceil((BMIN[i+1]+A[i+1])/2))
if BMIN[0] > BMAX[0]:
return -1
for i in range(1,N+1):
BMAX[i] = min(BMAX[i],BMAX[i-1]*2-A[i])
BMIN[i] = max(BMIN[i],BMIN[i-1]-A[i])
if BMIN[i] > BMAX[i]:
return -1
return sum(BMAX)+sum(A)
print((a()))
|
p02665
|
from collections import defaultdict as dd
import bisect
from sys import exit
n = int(eval(input()))
A = list(map(int, input().split()))
coutner = 0
dp = dd(int)
dp[1] = 1
limit = [0] * (n + 1)
total = 0
for i in range(n, -1, -1):
total += A[i]
limit[i] = total
#print(limit)
for depth in range(n):
mov_dic = dd(lambda: 0)
for now_num, total in list(dp.items()):
if now_num - A[depth] > 0:
mov_dic[now_num - A[depth]] = total
#print("mov_dic", mov_dic)
dp = dd(int)
mov_dic_keys = set(mov_dic.keys())
for now_num, total in list(mov_dic.items()):
mov_dic_keys.remove(now_num)
for next_num in range(now_num, min(now_num*2 + 1, limit[depth] + 1)):
if now_num in mov_dic_keys:
break
dp[next_num] = max(total + next_num, dp[next_num])
#print(limit[depth], "dp", dp)
if dp[A[-1]] == 0:
print((-1))
else:
print((dp[A[-1]]))
|
from collections import defaultdict as dd
import bisect
from sys import exit
n = int(eval(input()))
A = list(map(int, input().split()))
coutner = 0
dp = dd(int)
dp[1] = 1
limit = [0] * (n + 1)
total = 0
for i in range(n, -1, -1):
total += A[i]
limit[i] = total
#print(limit)
"""
for depth in range(n):
mov_dic = dd(lambda: 0)
for now_num, total in dp.items():
if now_num - A[depth] > 0:
mov_dic[now_num - A[depth]] = total
#print("mov_dic", mov_dic)
dp = dd(int)
mov_dic_keys = set(mov_dic.keys())
for now_num, total in mov_dic.items():
mov_dic_keys.remove(now_num)
for next_num in range(now_num, min(now_num*2 + 1, limit[depth] + 1)):
if now_num in mov_dic_keys:
break
dp[next_num] = max(total + next_num, dp[next_num])
#print(limit[depth], "dp", dp)
if dp[A[-1]] == 0:
print(-1)
else:
print(dp[A[-1]])
"""
if n == 0:
if A[0] == 1:
print((1))
else:
print((-1))
exit()
now_num = 1
now_total = 1
for depth in range(n):
mov_num = now_num - A[depth]
#print(mov_num)
if mov_num > 0:
now_num = min(mov_num * 2, limit[depth+1])
now_total += now_num
else:
print((-1))
exit()
if now_num == A[n]:
print(now_total)
else:
print((-1))
|
p02665
|
N = int(eval(input()))
*A, = list(map(int, input().split()))
Asum = [a for a in A]
for i in range(N-1, -1, -1):
Asum[i] += Asum[i+1]
ans = 0
v = 1 # 子になれる頂点数
for i in range(N+1):
if v < A[i]:
ans = -1
break
ans += v
p = v-A[i]
if i < N:
if p > Asum[i+1]:
ans = -1
break
v = min(Asum[i+1], 2*p)
print(ans)
|
N = int(eval(input()))
*A, = list(map(int, input().split()))
Asum = [a for a in A]
for i in range(N-1, -1, -1):
Asum[i] += Asum[i+1]
ans = 0
v = 1 # 子になれる頂点数
for i in range(N+1):
if v < A[i]:
ans = -1
break
ans += v
p = v-A[i]
if i < N:
v = min(Asum[i+1], 2*p)
print(ans)
|
p02665
|
def main():
eval(input())
A = list(map(int, input().split()))
cusum = [0] * len(A)
cusum[-1] = A[-1]
if A[0] > 1:
print((-1))
return
for i in range(len(A)-2, -1, -1):
cusum[i] = cusum[i+1] + A[i]
pre_node = 1
ans = 1
for i in range(1, len(A)):
node = (pre_node - A[i-1]) * 2
if node < A[i]:
print((-1))
return
pre_node = min(node, cusum[i])
ans += pre_node
print(ans)
if __name__ == '__main__':
main()
|
def main():
eval(input())
in_a = list(map(int, input().split()))
leaves = [0] * len(in_a)
leaves[-1] = in_a[-1]
if in_a[0] > 1:
print((-1))
return
for i in range(len(in_a)-2, -1, -1):
leaves[i] = leaves[i+1] + in_a[i]
node = 1
total = 1
for i in range(1, len(in_a)):
n = (node - in_a[i-1]) * 2
if n < in_a[i]:
print((-1))
return
node = min(n, leaves[i])
total += node
print(total)
if __name__ == '__main__':
main()
|
p02665
|
n = int(eval(input()))
a = list(map(int, input().split()))
if n == 0 and a[0] == 0:
print((-1))
exit()
if n != 0 and a[0] >= 1:
print((-1))
exit()
if n == 0 and a[0] >= 2:
print((-1))
exit()
ar = list(reversed(a))
#print(ar)
com = [ar[0]]
for i in range(n):
com.append(com[i] + ar[i+1])
#print(com)
com.reverse()
ans = 1
val = 1
for i in range(1,n+1):
val *= 2
ans += min(val,com[i])
val -= a[i]
if (i < n and val <= 0) or (i == n and val < 0):
print((-1))
exit()
print(ans)
|
n = int(eval(input()))
a = list(map(int, input().split()))
ar = list(reversed(a))
#print(ar)
com = [ar[0]]
for i in range(n):
com.append(com[i] + ar[i+1])
#print(com)
com.reverse()
ans = 0
val = 1
for i in range(n+1):
ans += min(val,com[i])
val -= a[i]
if (i < n and val <= 0) or (i == n and val < 0) or (i == n and a[i] == 0):
print((-1))
exit()
val *= 2
print(ans)
|
p02665
|
def Csum(a):
b,c=[0],0
for i in range(len(a)):
c+=a[i]
b.append(c)
return b
n=int(eval(input()))
a=list(map(int,input().split()))
s=Csum(a)
su=sum(a)
b=1
c=0
for i in range(n+1):
c+=b
b-=a[i]
if b<=0:
if i==n and b==0:
break
print((-1))
exit()
b=min(b*2,su-s[i+1])
print(c)
|
#全体的な方針
#浅いほうから貪欲に頂点を倍化していく
#現在見ている段の頂点数がそれより深い段の葉の数を超えると余ってしまう
#よって、minで押さえつける必要がある(累積和で高速化が必要)
#累積和の定義
def Csum(a):
b,c=[],0
for i in range(len(a)):
c+=a[i]
b.append(c)
return b
#n:二分木の深さ
#a:それぞれの段数の葉の数
#s:aの累積和をとったもの(その深さよりも浅い葉の数)
#su:aの総和(全体の葉の数)
#b:現在の深さの頂点数
#c:現在までの頂点数
n=int(eval(input()))
a=list(map(int,input().split()))
s,su,b,c=Csum(a),sum(a),1,0
for i in range(n+1):
#頂点数カウントに現在の段を加算
#葉の数だけ親の候補を減らしておく
c+=b
b-=a[i]
#最後まで頂点を使い切ったならcを出力
#途中で頂点が足りなくなったら-1を出力
if b<=0:
if i==n and b==0:
print(c)
else:
print((-1))
break
#次の段の頂点数の更新
#iより深い葉の数(su-s[i])を超えないようにする
b=min(b*2,su-s[i])
|
p02665
|
n = int(eval(input()))
a = list(map(int,input().split()))
cumsum_a = a.copy()
for i in range(n-1, -1, -1):
cumsum_a[i] += cumsum_a[i+1]
ans = 0
childable_node = 1
for i in range(n + 1):
if a[i] > childable_node:
ans = -1
break
ans += childable_node
if i < n:
b_max1 = 2 * (childable_node - a[i])
b_max2 = cumsum_a[i + 1]
childable_node = min(b_max1, b_max2)
print(ans)
|
n = int(eval(input()))
a = list(map(int,input().split()))
cumsum_a = a.copy()
for i in range(n-1, -1, -1):
cumsum_a[i] += cumsum_a[i+1]
ans = 0
node = 1
for i in range(n + 1):
if a[i] > node:
ans = -1
break
ans += node
if i < n:
node = min(2 * (node - a[i]), cumsum_a[i + 1])
print(ans)
|
p02665
|
n = int(eval(input()))
leaves = list(map(int, input().split()))
ans = 0
nodes_min = [0] * (n + 1)
nodes_max = [0] * (n + 1)
nodes_min[n] = leaves[n]
nodes_max[n] = leaves[n]
for depth in range(n, 0, -1):
root_min = nodes_min[depth] // 2 + nodes_min[depth] % 2
nodes_min[depth - 1] = leaves[depth - 1] + root_min
root_max = nodes_max[depth]
nodes_max[depth - 1] = leaves[depth - 1] + root_max
nodes = [0] * (n + 1)
nodes[0] = 1
if nodes[0] < nodes_min[0]:
print((-1))
else:
for depth in range(n):
roots = nodes[depth]-leaves[depth]
nodes[depth + 1] = min(roots * 2, nodes_max[depth + 1])
if nodes[depth+1] < nodes_min[depth+1]:
print((-1))
break
else:
print((sum(nodes)))
|
n = int(eval(input()))
leaves = list(map(int, input().split()))
sum_leaves = [0]*(n+1)
sum_leaves[0] = leaves[0]
for depth in range(n):
sum_leaves[depth+1] = sum_leaves[depth] + leaves[depth+1]
ans = 0
root = [None] * (n + 1)
if n == 0:
root[0] = 0
else:
root[0] = 1
if root[0] + leaves[0] != 1:
print((-1))
else:
for depth in range(n):
root[depth+1] = min(2*root[depth]-leaves[depth+1],
sum_leaves[n]-sum_leaves[depth+1])
if root[depth + 1] < root[depth] - leaves[depth + 1] or root[depth+1] < 0:
print((-1))
break
else:
print((sum(root)+sum(leaves)))
|
p02665
|
(N,) = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
numLeafs = A
minNonLeafs = [None for i in range(N + 1)]
maxNonLeafs = [None for i in range(N + 1)]
maxNonLeafs[0] = 1
for i in range(1, N + 1):
maxNonLeafs[i] = 2 * maxNonLeafs[i - 1] - numLeafs[i]
minNonLeafs[N] = 0
maxNonLeafs[N] = 0
if minNonLeafs[N] + numLeafs[N] > 2 ** N:
print((-1))
exit()
for i in range(N - 1, -1, -1):
minNonLeafs[i] = (minNonLeafs[i + 1] + numLeafs[i + 1] + 1) // 2
if minNonLeafs[i] + numLeafs[i] > 2 ** i:
print((-1))
exit()
maxNonLeafs[i] = min(maxNonLeafs[i], maxNonLeafs[i + 1] + numLeafs[i + 1])
if minNonLeafs[i] > maxNonLeafs[i]:
print((-1))
exit()
count = 0
for i in range(N + 1):
count += maxNonLeafs[i] + numLeafs[i]
print(count)
|
(N,) = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
numLeafs = A
if not (0 <= numLeafs[0] <= 1):
print((-1))
exit()
# Bound max non-leaves by how many expansions the previous level can do
maxNonLeafs = [None for i in range(N + 1)]
maxNonLeafs[0] = 1 - numLeafs[0]
for i in range(1, N + 1):
maxNonLeafs[i] = 2 * maxNonLeafs[i - 1] - numLeafs[i]
if maxNonLeafs[i] < 0:
print((-1))
exit()
# Tighten max non-leaves by how many available children are on next level
maxNonLeafs[N] = 0
for i in range(N - 1, -1, -1):
maxNonLeafs[i] = min(maxNonLeafs[i], maxNonLeafs[i + 1] + numLeafs[i + 1])
count = 0
for i in range(N + 1):
count += maxNonLeafs[i] + numLeafs[i]
print(count)
|
p02665
|
import math
def main():
depth = int(eval(input()))
leaves = [int(x) for x in input().split()]
nodes_range = [None] * (depth + 1)
for i in range(depth, -1, -1):
if i == depth:
nodes_range[i] = (leaves[i], leaves[i])
continue
min_nodes = math.ceil(nodes_range[i + 1][0] / 2) + leaves[i]
max_nodes = nodes_range[i + 1][1] + leaves[i]
nodes_range[i] = (min_nodes, max_nodes)
if not (nodes_range[0][0] <= 1 <= nodes_range[0][1]):
# 根が1を取り得ない場合は実現不可能。
print((-1))
return
max_noded_tree = [0] * (depth + 1)
for i in range(depth + 1):
if i == 0:
max_noded_tree[i] = 1
continue
max_noded_tree[i] = min(
(max_noded_tree[i - 1] - leaves[i - 1]) * 2,
nodes_range[i][1])
print((sum(max_noded_tree)))
return
if __name__ == '__main__':
main()
|
import math
def main():
depth = int(eval(input()))
leaves = [int(x) for x in input().split()]
nodes_range = [None] * (depth + 1)
for i in range(depth, -1, -1):
if i == depth:
nodes_range[i] = (leaves[i], leaves[i])
continue
# 枝をなるべくまとめていく。
min_nodes = math.ceil(nodes_range[i + 1][0] / 2) + leaves[i]
# 枝が結合せず，平行に遡る感じ。
max_nodes = nodes_range[i + 1][1] + leaves[i]
nodes_range[i] = (min_nodes, max_nodes)
if nodes_range[0][0] != 1:
# 根が1を取り得ない場合は実現不可能。
print((-1))
return
max_noded_tree = [0] * (depth + 1)
for i in range(depth + 1):
if i == 0:
max_noded_tree[i] = 1
continue
max_noded_tree[i] = min(
(max_noded_tree[i - 1] - leaves[i - 1]) * 2,
nodes_range[i][1])
print((sum(max_noded_tree)))
return
if __name__ == '__main__':
main()
|
p02665
|
from functools import reduce
from math import ceil
n = int(eval(input()))
a = list(map(int, input().split()))
bottom_n_list = [(0, 0) for _ in range(n + 1)]
bottom_n_list[n] = (a[n], a[n])
for i in range(n-1, -1, -1):
leaf_num = a[i]
min_a_node_num = ceil(bottom_n_list[i + 1][0] / 2)
max_a_node_num = min(bottom_n_list[i + 1][1], 2 ** i - leaf_num)
if max_a_node_num < min_a_node_num:
print((-1))
exit()
bottom_n_list[i] = (min_a_node_num + leaf_num, max_a_node_num + leaf_num)
top_n_list = [0]*(n+1)
if 1 < bottom_n_list[0][0] or bottom_n_list[0][1] < 1:
print((-1))
exit()
top_n_list[0] = 1
for i in range(1, n+1):
top_n_list[i] = min(bottom_n_list[i][1], (top_n_list[i-1]-a[i-1])*2)
ans = reduce(lambda a, b: a+b, top_n_list)
print(ans)
|
from math import ceil
n = int(eval(input()))
a = list(map(int, input().split()))
bottom_n_list = [(0, 0) for _ in range(n + 1)]
bottom_n_list[n] = (a[n], a[n])
for i in range(n-1, -1, -1):
leaf_num = a[i]
min_a_node_num = ceil(bottom_n_list[i + 1][0] / 2)
max_a_node_num = min(bottom_n_list[i + 1][1], 2 ** i - leaf_num)
if max_a_node_num < min_a_node_num:
print((-1))
exit()
bottom_n_list[i] = (min_a_node_num + leaf_num, max_a_node_num + leaf_num)
top_n_list = [0]*(n+1)
if 1 < bottom_n_list[0][0] or bottom_n_list[0][1] < 1:
print((-1))
exit()
top_n_list[0] = 1
ans = 1
for i in range(1, n+1):
top_n_list[i] = min(bottom_n_list[i][1], (top_n_list[i-1]-a[i-1])*2)
ans += top_n_list[i]
print(ans)
|
p02665
|
N=int(eval(input()))
A=[int(i) for i in input().split()]
a=[1-A[0]]
if a[0]<0:
print((-1))
exit()
for k in range(N):
ak=a[-1]
a.append(2*ak-A[k+1])
if a[-1]<0:
print((-1))
exit()
if a[-1]>10**17:
break
M=len(a)
for k in range(N,0,-1):
if k-1<M:
A[k-1]=A[k-1]+min(A[k],a[k-1])
else:
A[k-1]=A[k-1]+A[k]
print((sum(A)))
|
N=int(eval(input()))
A=[int(i) for i in input().split()]
#len(A)=N+1
ak=1-A[0]
if ak<0:
print((-1))
exit()
a=[ak]
k=0
while(ak>=0 and k<N):
ak=2*ak-A[k+1]
a.append(ak)
if ak<0:
print((-1))
exit()
if ak>=10**14:
#以降に関わらず構成可能
break
k+=1
#print(a)
M=len(a)
for k in range(N,0,-1):
if k<=M:
A[k-1]+=min(A[k],a[k-1])
else:
A[k-1]+=A[k]
continue
print((sum(A)))
#print(A)
|
p02665
|
N = int(eval(input()))
A = list(map(int, input().split()))
rng = [[A[N], A[N]]]
for i in range(N - 1, -1, -1):
merged = (rng[-1][0] + 1) // 2 + A[i]
nonmerged = rng[-1][1] + A[i]
rng.append([merged, nonmerged])
if rng[-1][0] > 1:
print((-1))
exit()
rng.reverse()
prev_non_leaf = 1
ans = 1
for i in range(1, N + 1):
l, u = rng[i]
ans += min(prev_non_leaf * 2, u)
prev_non_leaf = prev_non_leaf * 2 - A[i]
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
rng = [[A[N], A[N]]]
for i in range(N - 1, -1, -1):
merged = (rng[-1][0] + 1) // 2 + A[i]
nonmerged = rng[-1][1] + A[i]
rng.append([merged, nonmerged])
if rng[-1][0] > 1:
print((-1))
exit()
rng.reverse()
prev_non_leaf = 1
ans = 1
for i in range(1, N + 1):
_, u = rng[i]
ans += min(prev_non_leaf * 2, u)
prev_non_leaf = prev_non_leaf * 2 - A[i]
print(ans)
|
p02665
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
nonleaf_nodes = []
current = 1
for depth in range(0, n+1):
c = current-a[depth]
if c < 0: # 目いっぱい頂点を増やしても葉が足りない
print((-1))
exit()
nonleaf_nodes.append(c)
current = c*2
nonleaf_nodes[-1]=0
ans = a[-1]
for depth in range(n-1, -1, -1):
nonleaf_nodes[depth] = min(nonleaf_nodes[depth], nonleaf_nodes[depth+1]+a[depth+1])
ans += nonleaf_nodes[depth] + a[depth]
print(ans)
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
nonleaf_nodes = []
current = 1
# とりあえず増やせるだけ頂点を増やしていく
for depth in range(0, n+1):
c = current-a[depth]
# 目いっぱい頂点を増やしても葉を賄えない場合、木を作れない
if c < 0:
print((-1))
exit()
nonleaf_nodes.append(c)
current = c*2
nonleaf_nodes[-1]=0
# 余計な頂点を最深層から削除していく
# 下位層の葉を含む頂点数を超えると上位層で葉が増えるのでNG
ans = a[-1]
for depth in range(n-1, -1, -1):
nonleaf_nodes[depth] = min(nonleaf_nodes[depth], nonleaf_nodes[depth+1]+a[depth+1])
ans += nonleaf_nodes[depth] + a[depth]
print(ans)
|
p02665
|
import os
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split(" ")))
pow2 = defaultdict(int)
ret = 0
lim = []
for i in range(N+1):
pow2[i] = 2**i
for i in range(N+1):
if i == 0:
r = 2**i - A[i]
else:
r = 2*lim[i-1] - A[i]
if r < 0:
print((-1))
exit(0)
lim.append(r)
for d in reversed(list(range(N+1))):
if A[d] > pow2[d]:
print((-1))
exit(0)
if d == N:
n = min(A[d], pow2[d])
else:
n = min(A[d] + min(n, lim[d]), pow2[d])
ret +=n
print(ret)
|
import os
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split(" ")))
pow2 = defaultdict(int)
ret = 0
lim = [0] * (N + 1)
# for i in range(N + 1):
# pow2[i] = 2 ** i
for i in range(N + 1):
if i == 0:
r = 1 - A[i]
else:
r = 2 * lim[i - 1] - A[i]
if r < 0:
print((-1))
exit(0)
lim[i] = r
for d in reversed(list(range(N + 1))):
# if A[d] > pow2[d]:
# print(-1)
# exit(0)
if d == N:
#n = min(A[d], pow2[d])
n = A[d]
else:
#n = min(A[d] + min(n, lim[d]), pow2[d])
n = A[d] + min(n, lim[d])
ret += n
print(ret)
|
p02665
|
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')
N = int(input())
A = list(map(int, input().split()))
lenA = len(A)
cnt = 1
node = [1]*N
# from functools import lru_cache
# @lru_cache(None)
def f(depth, leaf, nodec):
# print(depth, leaf, nodec)
if depth == N:
# print(' ', depth, leaf, nodec)
if leaf == A[depth]:
# OK!
print(nodec)
exit()
return
else:
# NG
return
# NG
if leaf < A[depth]:
return 0
# OK
not_leaf = leaf - A[depth]
for j in range(not_leaf*2, not_leaf-1, -1):
f(depth+1, j, nodec+j)
f(0, 1, 1)
print(-1)
|
# import numpy as np
import sys, math, heapq
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N = int(input())
A = list(map(int, input().split()))
if N == 0:
if A[0] == 1:
print(1)
exit()
else:
print(-1)
exit()
if N != 0 and A[0] > 0:
print(-1)
exit()
rcA = [0] * (N)
rcA[-1] = A[-1]
for i in range(1, N):
rcA[-i - 1] = rcA[-i] + A[-i - 1]
# print(rcA)
cnt = 1
node = 1
for a, rca in zip(A, rcA):
min_node = node - a
max_node = 2 * (node - a)
if rca < min_node or min_node < 0:
print(-1)
exit()
node = min(max_node, rca)
# print(node)
cnt += node
if node != A[-1]:
print(-1)
exit()
print(cnt)
|
p02665
|
N = int(eval(input()))
A = list(map(int, input().split()))
capacity = [1 for k in range(N+1)]
cut = 0
for k in range(N+1):
#print(capacity)
if A[k] >= capacity[k] and k!= N:
print((-1))
break
if A[k] > capacity[k] and k == N:
print((-1))
break
if k < N:
capacity[k+1] = 2*(capacity[k] - A[k])
if k == N:
ans = [0 for k in range(N+1)]
ans[0] =1
for m in range(N+1):
ans[m] = min(capacity[m], sum(A[m:N+1]))
print((sum(ans)))
|
N = int(eval(input()))
A = list(map(int, input().split()))
capacity = [1 for k in range(N+1)]
cut = 0
for k in range(N+1):
#print(capacity)
if A[k] >= capacity[k] and k!= N:
print((-1))
break
if A[k] > capacity[k] and k == N:
print((-1))
break
if k < N:
capacity[k+1] = 2*(capacity[k] - A[k])
if k == N:
ans = [0 for k in range(N+1)]
ans[0] =1
sumA = 0
for m in range(1, N+2):
sumA += A[-m]
ans[-m] = min(capacity[-m], sumA)
print((sum(ans)))
|
p02665
|
N = int(eval(input()))
A = list(map(int, input().split()))
if N == 0 and A[0] == 1:
print((1))
else:
nodes = [0]*(N+1)
s_d = 0 # 飽和してないノードが残ってる深さ
cap_d = 1 - A[0]
failed = False
for i, a in enumerate(A):
# a個の葉をなるべく浅いノードから取る
while a > 0:
# これ以上分岐することろがなければ失敗
if i < s_d or cap_d <= 0:
failed = True
break
# s_dから枝を取れるだけ取る
x = min(cap_d - nodes[s_d], a)
a -= x
nodes[s_d:i+1] = [node + x for node in nodes[s_d:i+1]]
# s_dがいっぱいになったら深さを一つ進める
if nodes[s_d] >= cap_d:
cap_d -= A[s_d]
cap_d *= 2
s_d += 1
if failed:
break
print((-1 if failed else sum(nodes)))
|
N = int(eval(input()))
A = list(map(int, input().split()))
cap = [[0, 0] for _ in range(N+1)]
cap[-1] = [A[-1], A[-1]]
for i in range(N-1,-1,-1):
cap[i][0] = (cap[i+1][0] + 2 - 1)//2
cap[i][1] = cap[i+1][1] + A[i]
ans = 1
nodes = 1
failed = nodes < cap[0][0]
for i in range(N):
nodes = min((nodes - A[i])*2, cap[i+1][1])
if nodes < cap[i+1][0]:
failed = True
break
ans += nodes
print((-1 if failed else ans))
|
p02665
|
import sys
import itertools
N = int(eval(input()))
A = list(input().split())
A = [int(A[i]) for i in range(N+1)]
MAX = [2**i for i in range(N+1)]
A_inter = list(reversed(list(itertools.accumulate(reversed(A)))))
for i in range(N+1):
if A[i] > MAX[i]:
print((-1))
sys.exit()
elif i != N:
MAX[i+1] = (MAX[i] - A[i]) * 2
print((sum([min(MAX[i], A_inter[i]) for i in range(N+1)])))
|
import sys
import itertools
N = int(eval(input()))
A = list(input().split())
A = [int(A[i]) for i in range(N+1)]
MAX = [1 for i in range(N+1)]
A_inter = list(reversed(list(itertools.accumulate(reversed(A)))))
for i in range(N+1):
if A[i] > MAX[i]:
print((-1))
sys.exit()
elif i != N:
MAX[i+1] = (MAX[i] - A[i]) * 2
print((sum([min(MAX[i], A_inter[i]) for i in range(N+1)])))
|
p02665
|
N = int(eval(input()))
A = list(map(int, input().split()))
d = [1] * (N+1)
d[0] -= A[0]
for i in range(N):
d[i+1] = d[i] * 2 - A[i+1]
if d[-1] < 0:
print((-1))
exit()
else:
d[-1] = A[-1]
for i in range(N, 0, -1):
x = d[i]
x += A[i-1]
if d[i-1] * 2 < x:
y = x - A[i-1]
if (y+1) // 2 + A[i-1] <= d[i-1] * 2:
x = d[i-1] * 2
d[i-1] = min(x, d[i-1]+A[i-1])
print((sum(d)))
|
N = int(eval(input()))
A = list(map(int, input().split()))
d = [1] * (N+1)
d[0] -= A[0]
for i in range(N):
d[i+1] = d[i] * 2 - A[i+1]
if d[-1] < 0:
print((-1))
exit()
else:
d[-1] = A[-1]
for i in range(N, 0, -1):
x = d[i]
x += A[i-1]
d[i-1] = min(x, d[i-1]+A[i-1])
print((sum(d)))
|
p02665
|
n=int(eval(input()))
a=list(map(int,input().split()))
s=sum(a)-1
ans,x=0,1
for i in range(n):
if a[i]>x-1:
print((-1))
exit()
ans+=x
x-=a[i]
if i<n-1 and x<=0:
print((-1))
exit()
if s>=0:
if s>=x:
s-=x
x=x*2
else:
x=(x-s)+s*2
s=0
if x!=a[-1] or x<=0:
print((-1))
exit()
ans+=x
print(ans)
|
#葉の総和-1=分岐の数
n=int(eval(input()))
a=list(map(int,input().split()))
s=sum(a)-1
ans,x=0,1
for i in range(n):
if a[i]>x-1:
print((-1))
exit()
ans+=x
x-=a[i]
if i<n-1 and x<=0:
print((-1))
exit()
if s>=0:
if s>=x:
s-=x
x=x*2
else:
x=(x-s)+s*2
s=0
if x!=a[-1] or x<=0:
print((-1))
exit()
ans+=x
print(ans)
|
p02665
|
N=int(eval(input()))
A=list(map(int,input().split()))
node=[1 for _ in range(N+1)]
Sn=sum(A)
S=[Sn]
for s in range(N):
S.append(S[s]-A[s+1])
ans=1
for i in range(1,N+1):
if node[i-1]*2<=S[i-1]:
ans+=node[i-1]*2
node[i]=node[i-1]*2
elif node[i-1]<=S[i-1]<node[i-1]*2:
node[i]=S[i-1]
ans+=S[i-1]
node[i]-=A[i]
if node[i]<0:
ans=-1
break
if A[0]>0:
ans=-1
if N==0 and A[0]==1:
ans=1
print(ans)
|
N=int(eval(input()))
A=list(map(int,input().split()))
node=[1 for _ in range(N+1)] #深さiで、葉にならない頂点の個数node[i]
S=sum(A) #生産しなければならない葉の枚数の合計
ans=1 #深さ0である根は最初にカウントする
#深さiの時点であと何枚の葉が必要か計算しつつ、必要な分だけノードを生産する
#ノードの個数がその時点でのSまで届いたら、あとは各頂点が1つずつノードを生産し、
#各層でA[i]個のノードが生産を止めて葉となる
for i in range(1,N+1):
if node[i-1]*2<=S: #葉の生産量はノードの2倍ずつ、ノルマを超えるまでは最速で生産する
ans+=node[i-1]*2
node[i]=node[i-1]*2
elif node[i-1]<=S<node[i-1]*2: #全てのノードが2倍になるとノルマを過ぎてしまう場合はノルマピッタリで止める
node[i]=S
ans+=S
node[i]-=A[i] #葉となるノード数を差し引き、生産に寄与するノード数にして次の層に引き継ぐ
S-=A[i] #葉になった枚数だけノルマも減らす
if node[i]<0: #生産が間に合わなかった場合(要求された葉＞生産可能なノード数)はループ停止
ans=-1
break
if A[0]>0: #深さ0に葉があったら基本的にアウトだが…
ans=-1
if N==0 and A[0]==1: #N=0の時だけ、深さ0に葉が1つという状況が許される
ans=1
print(ans)
|
p02665
|
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0]*(n+1)
b[0] = 1
for i in range(n):
b[i+1] = 2*(b[i] - a[i])
#根から計算した深さごとの要素数の最大値
c = [0]*(n+1)
c[n] = a[n]
for j in range(n):
c[n-1-j] = c[n-j] + a[n-1-j]
#葉から計算した最小値
#print(b)
#print(c)
d = [0]*(n+1)
flag = 0
for k in range(n+1):
if b[k] < c[k]:
d[k] = b[k]
if d[k] <= 0:
flag += 1
else:
d[k] = c[k]
if d[k] <= 0:
flag += 1
for l in range(n):
flag += 1 if d[l+1] < d[l] - a[l] or 2*d[l] - a[l] < d[l+1] else 0
flag += 1 if a[l] + (d[l+1]+1)//2 > d[l] or d[l] > d[l+1] + a[l] else 0
ans = sum(d) if flag == 0 else -1
ans = -1 if n == 0 and a[0] > 1 else ans
ans = -1 if a[n] != d[n] else ans
print(ans)
#print(d)
|
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0]*(n+1)
b[0] = 1
for i in range(n):
b[i+1] = 2*(b[i] - a[i])
c = [0]*(n+1)
c[n] = a[n]
for j in range(n):
c[n-1-j] = c[n-j] + a[n-1-j]
d = [0]*(n+1)
flag = 0
for k in range(n+1):
if b[k] < c[k]:
d[k] = b[k]
if d[k] <= 0:
flag += 1
else:
d[k] = c[k]
if d[k] <= 0:
flag += 1
ans = sum(d) if flag == 0 else -1
ans = -1 if n == 0 and a[0] > 1 else ans
ans = -1 if a[n] != d[n] else ans
print(ans)
|
p02665
|
*a,=list(map(int,[*open(0)][1].split()))
c=sum(a)
s=b=1
for a in a:c-=a;b=min(c,(b-a)*2);s+=b
print((max(-1,s)))
|
c=sum(a:=[*list(map(int,[*open(0)][1].split()))])
s=b=1
for a in a:b=min(c:=c-a,b-a<<1);s+=b
print((max(-1,s)))
|
p02665
|
*a,=list(map(int,[*open(0)][1].split()))
c=sum(a)
s=b=1
for a in a:c-=a;b=min(c,b-a<<1);s+=b
print((max(-1,s)))
|
c=sum(a:=[*list(map(int,[*open(0)][1].split()))])
b=1
print((max(-1,sum((b:=min(c:=c-a,b-a<<1))for a in a)+1)))
|
p02665
|
from itertools import accumulate
n, *A = list(map(int, open(0).read().split()))
if A[0] != 0:
if A[0] == 1 and n == 0:
print((1))
else:
print((-1))
else:
B = list(accumulate(A[::-1]))[::-1] + [0]
C = [0] * (n+1)
D = [0] * (n+1)
C[0] = 1
D[0] = 1
for i in range(1, n+1):
C[i] = min(B[i], 2*D[i-1])
D[i] = C[i] - A[i]
if D[i] < 0:
print((-1))
break
else:
print((sum(C)))
|
from itertools import accumulate
n, *A = list(map(int, open(0).read().split()))
if A[0] != 0:
if A[0] == 1 and n == 0:
print((1))
else:
print((-1))
else:
B = list(accumulate(A[::-1]))[::-1]
C = [1] * (n+1)
D = [1] * (n+1)
for i in range(1, n+1):
C[i] = min(B[i], 2*D[i-1])
D[i] = C[i] - A[i]
if D[i] < 0:
print((-1))
break
else:
print((sum(C)))
|
p02665
|
n = int(eval(input()))
a = list(map(int, input().split()))
b = a[::-1]
if n == 0 and a[0] == 1:
print((1))
exit()
if n == 0:
print((-1))
exit()
if a[0] >= 1:
print((-1))
exit()
ans = [0] * (n + 1)
for i in range(n):
ans[i + 1] = ans[i] + b[i]
ans = ans[::-1]
ans = ans[1::]
a = a[1::]
res = 1
prev_cnt = 1
for i in range(n):
cnt = min(prev_cnt * 2, ans[i] + a[i])
if cnt < a[i]:
print((-1))
exit()
res += cnt
prev_cnt = cnt - a[i]
print(res)
|
n = int(eval(input()))
a = list(map(int, input().split()))
b = a[::-1]
if n == 0 and a[0] == 1:
print((1))
exit()
if a[0] >= 1:
print((-1))
exit()
ans = [0] * (n + 1)
for i in range(n):
ans[i + 1] = ans[i] + b[i]
ans = ans[::-1]
ans = ans[1::]
a = a[1::]
res = 1
prev_cnt = 1
for i in range(n):
cnt = min(prev_cnt * 2, ans[i] + a[i])
if cnt < a[i]:
print((-1))
exit()
res += cnt
prev_cnt = cnt - a[i]
print(res)
|
p02665
|
def resolve():
N = int(eval(input()))
A = [int(x) for x in input().split(" ")]
if N == 0 and A[0] != 1:
print((-1))
return True
min_maxs = {}
min_maxs[len(A)-1] = [A[-1], A[-1]]
for index in reversed(list(range(len(A)-1))):
min_maxs[index] = [min_maxs[index+1][0] // 2 + A[index], min_maxs[index+1][1] + A[index]]
# print(min_maxs)
# min_maxs.insert(0, [min_maxs[0][0] // 2 + a, min_maxs[0][1] + a])
# print(min_maxs)
# max_node_in_depth = [sum(A[i:]) for i in range(len(A))]
# # 各 depth における最小値
# min_node_in_depth = [0] * (len(A))
# min_node_in_depth[-1] = max_node_in_depth[-1]
# index = -1
# for i in range(1, len(A)):
# min_node_in_depth[index] = -(-min_node_in_depth[index + 1] // 2) + A[index]
# index = index - 1
# for min_max in min_maxs:
# print(min_max)
result = 1
recent = 1
for index in range(1, len(A)):
num_of_node = (recent - A[index-1]) * 2
# print(min_max, num_of_node)
if num_of_node < min_maxs[index][0]:
print((-1))
return True
result += min(num_of_node, min_maxs[index][1])
recent = min(num_of_node, min_maxs[index][1])
print(result)
if __name__ == "__main__":
resolve()
|
def resolve():
N = int(eval(input()))
A = [int(x) for x in input().split(" ")]
if N == 0 and A[0] != 1:
print((-1))
return True
min_maxs = [0] * len(A)
min_maxs[len(A)-1] = [A[-1], A[-1]]
for index in reversed(list(range(len(A)-1))):
min_maxs[index] = [min_maxs[index+1][0] // 2 + A[index], min_maxs[index+1][1] + A[index]]
result = 1
recent = 1
for index in range(1, len(A)):
num_of_node = (recent - A[index-1]) * 2
if num_of_node < min_maxs[index][0]:
print((-1))
return True
result += min(num_of_node, min_maxs[index][1])
recent = min(num_of_node, min_maxs[index][1])
print(result)
if __name__ == "__main__":
resolve()
|
p02665
|
from itertools import accumulate
n=int(eval(input()))
a=list(map(int,input().split()))
c=list(accumulate(a))
b=[0]*(n+1)
#大きくしすぎてしまう場合がある
#いや上限を考えろや
def f():
global n,a,b
for i in range(n+1):
if i==0:
b[0]=min(c[n]-c[0],1)
else:
b[i]=min(2*(b[i-1]-a[i-1]),c[n]-c[i-1])
if n==0:
if a[0]!=1:
print((-1))
else:
print((1))
elif b[n]!=a[n]:
print((-1))
else:
print((sum(b)))
#print(b)
f()
|
n,*a=list(map(int,open(0).read().split()))
t,v=sum(a),[1]
for q in a:
v+=[min(2*(v[-1]-q),t:=t-q)]
if v[-1]<0:print((-1));exit()
print((sum(v)))
|
p02665
|
n,*a=list(map(int,open(0).read().split()))
t,v,w=sum(a),1,1
for q in a:
w=min(2*(w-q),t:=t-q);(v:=v+w)
if w<0:print((-1));exit()
print(v)
|
n,*a=list(map(int,open(0).read().split()))
t=sum(a);v=w=1
for q in a:
w=min(2*(w-q),t:=t-q);(v:=v+w)
if w<0:print((-1));exit()
print(v)
|
p02665
|
n,*a=list(map(int,open(0).read().split()))
t=sum(a);v=w=1
for q in a:
w=min(2*(w-q),t:=t-q);(v:=v+w)
if w<0:print((-1));exit()
print(v)
|
n,*a=list(map(int,open(0).read().split()))
t=sum(a);v=w=1
for q in a:
if(w:=min(2*(w-q),t:=t-q))<0:print((-1));exit()
v+=w
print(v)
|
p02665
|
n,*a=map(int,open(0).read().split());t=sum(a);v=w=1
for q in a:
if(w:=min(2*(w-q),t:=t-q))<0:exit(print(-1))
v+=w
print(v)
|
n,*a=map(int,open(0).read().split());t=sum(a);v=w=1
print(sum([1]+[exit(print(-1)) if(w:=min(2*(w-q),t:=t-q))<0 else w for q in a]))
|
p02665
|
p=print;n,*a=map(int,open(0).read().split());t=sum(a);p(sum([w:=1]+[exit(p(-1))if(w:=min(2*(w-q),t:=t-q))<0 else w for q in a]))
|
p,s=print,sum;n,*a=map(int,open(0).read().split());t=s(a);p(s([w:=1]+[exit(p(-1))if(w:=min(2*(w-q),t:=t-q))<0 else w for q in a]))
|
p02665
|
W, H, x, y= list(map(int, input().split()))
S = W*H/2
flg = 1 if (x==W/2 and y==H/2) else 0
print(('{:.6f}'.format(S)+" "+str(flg)))
|
W, H, x, y= list(map(int, input().split()))
print(('{:.6f}'.format(W*H/2)+" "+str(1 if (x==W/2 and y==H/2) else 0)))
|
p03001
|
# AOJ ITP2_3_C: Count
# Python3 2018.6.24 bal4u
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
for i in range(q):
b, e, k = list(map(int, input().split()))
s = a[b:e]
print((s.count(k)))
|
# AOJ ITP2_3_C: Count
# Python3 2018.6.24 bal4u
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
for i in range(q):
b, e, k = list(map(int, input().split()))
print((a[b:e].count(k)))
|
p02441
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
def max_heapify(index):
# global heap_length
left, right, largest = 2 * index, 2 * index + 1, None
if left <= heap_length and heap_array[left] > heap_array[index]:
largest = left
else:
largest = index
if right <= heap_length and heap_array[right] > heap_array[largest]:
largest = right
if largest != index:
heap_array[index], heap_array[largest] = heap_array[largest], heap_array[index]
max_heapify(largest)
return None
def extract():
global heap_length
if heap_length < 1:
raise SystemExit('Heap underflow!')
# the root of the heap is always the largest
heap_max = heap_array[1]
# move new data to heap root
heap_array[1] = heap_array[heap_length]
heap_length -= 1
# print
heap_array.pop()
print(heap_max)
max_heapify(1)
# assert len(heap_array) == heap_length + 1
return heap_max
def insert(data):
global heap_length
heap_length += 1
heap_array.append(-1)
# assert len(heap_array) == heap_length + 1
insert_data(heap_length, data)
def insert_data(index, data):
if data < heap_array[index]:
raise SystemExit('Not a max-heap!')
heap_array[index] = data
while index > 1:
parent = index // 2
if heap_array[parent] >= heap_array[index]:
break
heap_array[index], heap_array[parent] = heap_array[parent], heap_array[index]
index //= 2
return None
def action(_command):
if _command.startswith('in'):
insert(int(each[7:]))
elif _command.startswith('ex'):
extract()
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
# command_list = list(map(lambda x: x.split(), _input))
# allowed_commands = ('insert', 'extract', 'end')
heap_array, heap_length = [-1], 0
for each in _input:
# command, content = each[0], each[-1]
# if command not in allowed_commands:
# raise SystemExit('Illegal command!')
action(each)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
import heapq as hp
if __name__ == '__main__':
_input = sys.stdin.readlines()
heap_array = []
for each in _input:
if each.startswith('in'):
hp.heappush(heap_array, -1 * int(each[7:]))
elif each.startswith('ex'):
print((-1 * hp.heappop(heap_array)))
|
p02289
|
import sys
#@profile
def max_heapify(A, i):
j = i
largest = i
H = len(A) -1
while True:
l = j * 2
r = l + 1
if l <= H and A[l] > A[j]:
largest = l
if r <= H and A[r] > A[largest]:
largest = r
if largest != j:
A[j], A[largest] = A[largest], A[j]
#max_heapify(A, largest)
j = largest
else:
break
#@profile
def build_max_heap(A):
for i in range(len(A)-1 // 2, 0, -1):
max_heapify(A, i)
#@profile
def extract(A):
print(A[1])
A[1] = A[-1]
del A[-1]
max_heapify(A, 1)
A = [0]
#@profile
def main():
out = ""
for l in sys.stdin.readlines():
if l[0] == "i":
#insert k
A.append(int(l[7:]))
build_max_heap(A)
#print(A)
elif l[1] == "n":
#end
print(out, end = "")
return
else:
if len(A) <= 1:
pass
elif len(A) == 2:
out += str(A.pop()) + "\n"
#print(A.pop())
#extract(A)
else:
out += str(A[1]) + "\n"
A[1] = A.pop()
max_heapify(A, 1)
if __name__ == "__main__":
main()
|
import sys
#@profile
def max_heapify(A, i):
j = i
largest = i
H = len(A) -1
while True:
l = j * 2
r = l + 1
if l <= H and A[l] > A[j]:
largest = l
if r <= H and A[r] > A[largest]:
largest = r
if largest != j:
A[j], A[largest] = A[largest], A[j]
#max_heapify(A, largest)
j = largest
else:
break
#@profile
def build_max_heap(A):
i = len(A)-1
last = A[i]
parent = i//2
while parent > 0 and A[parent] < last:
A[i] = A[parent]
i = parent
parent = i //2
A[i] = last
#@profile
def extract(A):
print(A[1])
A[1] = A[-1]
del A[-1]
max_heapify(A, 1)
A = [0]
#@profile
def main():
out = ""
for l in sys.stdin.readlines():
if l[0] == "i":
#insert k
A.append(int(l[7:]))
build_max_heap(A)
#print(A)
elif l[1] == "n":
#end
print(out, end = "")
return
else:
if len(A) <= 1:
pass
elif len(A) == 2:
out += str(A.pop()) + "\n"
#print(A.pop())
#extract(A)
else:
out += str(A[1]) + "\n"
A[1] = A.pop()
max_heapify(A, 1)
if __name__ == "__main__":
main()
|
p02289
|
class PQueue:
def __init__(self):
self.keys = []
def maxHeapify(self, i):
l = i * 2 + 1
r = i * 2 + 2
if l < len(self.keys) and self.keys[l] > self.keys[i]:
largest = l
else:
largest = i
if r < len(self.keys) and self.keys[r] > self.keys[largest]:
largest = r
if largest != i:
self.keys[i], self.keys[largest] = self.keys[largest], self.keys[i]
self.maxHeapify(largest)
def insert(self, key):
i = len(self.keys)
self.keys.append(key)
parent = (i - 1) // 2
while i > 0 and self.keys[parent] < self.keys[i]:
self.keys[i], self.keys[parent] = self.keys[parent], self.keys[i]
i = parent
parent = (parent - 1) // 2
def heapExtraMax(self):
max_key = self.keys[0]
if len(self.keys) > 1:
self.keys[0] = self.keys.pop()
else:
del self.keys[0]
self.maxHeapify(0)
print(max_key)
S = PQueue()
ans = []
import sys
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
S.insert(k)
elif x[1] == 'x':
S.heapExtraMax()
else:
pass
|
class PQueue:
def __init__(self):
self.keys = []
def maxHeapify(self, i):
l = i * 2 + 1
r = i * 2 + 2
if l < len(self.keys) and self.keys[l] > self.keys[i]:
largest = l
else:
largest = i
if r < len(self.keys) and self.keys[r] > self.keys[largest]:
largest = r
if largest != i:
self.keys[i], self.keys[largest] = self.keys[largest], self.keys[i]
self.maxHeapify(largest)
def insert(self, key):
i = len(self.keys)
self.keys.append(key)
parent = (i - 1) // 2
while i > 0 and self.keys[parent] < self.keys[i]:
self.keys[i], self.keys[parent] = self.keys[parent], self.keys[i]
i = parent
parent = (parent - 1) // 2
def heapExtraMax(self):
max_key = self.keys[0]
if len(self.keys) > 1:
self.keys[0] = self.keys.pop()
else:
del self.keys[0]
self.maxHeapify(0)
return max_key
S = PQueue()
ans = []
import sys
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
S.insert(k)
elif x[1] == 'x':
ans.append(S.heapExtraMax())
else:
pass
print(*ans, sep = '\n')
|
p02289
|
class PQueue:
def __init__(self):
self.keys = []
def maxHeapify(self, i):
l = i * 2 + 1
r = i * 2 + 2
if l < len(self.keys) and self.keys[l] > self.keys[i]:
largest = l
else:
largest = i
if r < len(self.keys) and self.keys[r] > self.keys[largest]:
largest = r
if largest != i:
self.keys[i], self.keys[largest] = self.keys[largest], self.keys[i]
self.maxHeapify(largest)
def insert(self, key):
i = len(self.keys)
self.keys.append(key)
parent = (i - 1) // 2
while i > 0 and self.keys[parent] < self.keys[i]:
self.keys[i], self.keys[parent] = self.keys[parent], self.keys[i]
i = parent
parent = (parent - 1) // 2
def heapExtraMax(self):
max_key = self.keys[0]
if len(self.keys) > 1:
self.keys[0] = self.keys.pop()
else:
del self.keys[0]
self.maxHeapify(0)
return max_key
S = PQueue()
ans = []
import sys
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
S.insert(k)
elif x[1] == 'x':
ans.append(S.heapExtraMax())
else:
pass
print(*ans, sep = '\n')
|
def maxHeapify(keys, i):
l = i * 2 + 1
r = i * 2 + 2
if l < len(keys) and keys[l] > keys[i]:
largest = l
else:
largest = i
if r < len(keys) and keys[r] > keys[largest]:
largest = r
if largest != i:
keys[i], keys[largest] = keys[largest], keys[i]
maxHeapify(keys, largest)
def heapInsert(keys, key):
i = len(keys)
keys.append(key)
parent = (i - 1) // 2
while i > 0 and keys[parent] < keys[i]:
keys[i], keys[parent] = keys[parent], keys[i]
i = parent
parent = (parent - 1) // 2
def heapMaxPop(keys):
max_key = keys[0]
if len(keys) > 1:
keys[0] = keys.pop()
else:
del keys[0]
maxHeapify(keys, 0)
print(max_key)
S = []
import sys
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
heapInsert(S, k)
elif x[1] == 'x':
heapMaxPop(S)
else:
pass
|
p02289
|
def maxHeapify(i):
l = i * 2 + 1
r = i * 2 + 2
if l < len(A) and A[l] > A[i]:
largest = l
else:
largest = i
if r < len(A) and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(largest)
def heapInsert(key):
i = len(A)
A.append(key)
parent = (i - 1) // 2
while i > 0 and A[parent] < A[i]:
A[i], A[parent] = A[parent], A[i]
i = parent
parent = (parent - 1) // 2
def heapMaxPop():
max_key = A[0]
if len(A) > 1:
A[0] = A.pop()
else:
del A[0]
maxHeapify(0)
print(max_key)
A = []
import sys
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
heapInsert(k)
elif x[1] == 'x':
heapMaxPop()
else:
pass
|
def setHeapDown_max(heap, pos):
targetkey = heap[pos]
while pos > 0:
parentpos = (pos - 1) >> 1
parent = heap[parentpos]
if parent < targetkey:
heap[pos] = parent
pos = parentpos
continue
break
heap[pos] = targetkey
def setHeapUp_max(heap, pos):
endpos = len(heap)
targetkey = heap[pos]
childpos = 2*pos + 1
while childpos < endpos:
rightpos = childpos + 1
if rightpos < endpos and not heap[rightpos] < heap[childpos]:
childpos = rightpos
heap[pos] = heap[childpos]
pos = childpos
childpos = 2*pos + 1
heap[pos] = targetkey
setHeapDown_max(heap, pos)
def heapPush_max(heap, key):
heap.append(key)
setHeapDown_max(heap, len(heap) - 1)
def heapPop_max(heap):
lastkey = heap.pop()
if heap:
returnkey = heap[0]
heap[0] = lastkey
setHeapUp_max(heap, 0)
return returnkey
return lastkey
import sys
S = []
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
heapPush_max(S, k)
elif x[1] == 'x':
print((heapPop_max(S)))
else:
pass
|
p02289
|
def setHeapDown_max(heap, pos):
targetkey = heap[pos]
while pos > 0:
parentpos = (pos - 1) >> 1
parent = heap[parentpos]
if parent < targetkey:
heap[pos] = parent
pos = parentpos
continue
break
heap[pos] = targetkey
def setHeapUp_max(heap, pos):
endpos = len(heap)
targetkey = heap[pos]
childpos = 2*pos + 1
while childpos < endpos:
rightpos = childpos + 1
if rightpos < endpos and not heap[rightpos] < heap[childpos]:
childpos = rightpos
childkey = heap[childpos]
if targetkey > childkey:
break
heap[pos] = childkey
pos = childpos
childpos = 2*pos + 1
heap[pos] = targetkey
def heapPush_max(heap, key):
heap.append(key)
setHeapDown_max(heap, len(heap) - 1)
def heapPop_max(heap):
lastkey = heap.pop()
if heap:
returnkey = heap[0]
heap[0] = lastkey
setHeapUp_max(heap, 0)
return returnkey
return lastkey
import sys
S = []
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
heapPush_max(S, k)
elif x[1] == 'x':
print((heapPop_max(S)))
else:
pass
|
def setHeapDown_max(heap, pos):
targetkey = heap[pos]
while pos > 0:
parentpos = (pos - 1) >> 1
parent = heap[parentpos]
if parent < targetkey:
heap[pos] = parent
pos = parentpos
continue
break
heap[pos] = targetkey
def setHeapUp_max(heap, pos):
endpos = len(heap)
targetkey = heap[pos]
childpos = 2*pos + 1
while childpos < endpos:
rightpos = childpos + 1
if rightpos < endpos and not heap[rightpos] < heap[childpos]:
childpos = rightpos
childkey = heap[childpos]
if targetkey > childkey:
break
heap[pos] = childkey
pos = childpos
childpos = 2*pos + 1
heap[pos] = targetkey
def heapPush_max(heap, key):
heap.append(key)
setHeapDown_max(heap, len(heap) - 1)
def heapPop_max(heap):
lastkey = heap.pop()
if heap:
returnkey = heap[0]
heap[0] = lastkey
setHeapUp_max(heap, 0)
return returnkey
return lastkey
import sys
S = []
ans = []
for x in sys.stdin.readlines():
if x[0] == 'i':
k = int(x[7:])
heapPush_max(S, k)
elif x[1] == 'x':
ans.append(heapPop_max(S))
else:
pass
print(*ans, sep = '\n')
|
p02289
|
import sys
def max_heapify(A, i):
H = len(A) - 1
l, r, m = i*2, i*2+1, i
if l <= H and A[l] > A[i]: m = l
if r <= H and A[r] > A[m]: m = r
if m != i:
A[i], A[m] = A[m], A[i]
max_heapify(A, m)
def build_max_heap(A):
H = len(A) - 1
for i in range(H // 2, 0, -1):
max_heapify(A, i)
A = [0]
for line in sys.stdin.readlines():
if line[0] == 'i':
A.append(int(line[7:]))
build_max_heap(A)
elif line[1] == 'x':
if len(A) <= 2:
print((A.pop()))
else:
print((A[1]))
A[1] = A.pop()
max_heapify(A, 1)
else:
exit()
|
import sys
def max_heapify(A, H, i):
target = A[i]
m = i
l = i * 2
while l <= H:
largest = target
if A[l] > target:
m = l
largest = A[m]
r = l + 1
if r <= H and A[r] > largest:
m = r
largest = A[m]
if m != i:
A[i] = largest
i = m
l = i * 2
else:
break
A[m] = target
def build_max_heap(A, i):
if i < 2: return
last = A[i]
p = i // 2
while p > 0 and A[p] < last:
A[i] = A[p]
i = p
p = i // 2
A[i] = last
A = [0]
for line in sys.stdin.readlines():
if line[0] == 'i':
A.append(int(line[7:]))
build_max_heap(A, len(A) - 1)
elif line[1] == 'x':
if len(A) <= 1:
pass
elif len(A) <= 2:
print((A.pop()))
else:
print((A[1]))
A[1] = A.pop()
max_heapify(A, len(A) -1, 1)
else:
exit()
|
p02289
|
import sys
class PriorityQueue:
def __init__(self):
self.nodes = []
self.num = 0
def max_heapify(self, i):
if i >= self.num: return
left, right = (i+1)*2-1, (i+1)*2
largest = i
if left < self.num and self.nodes[i] < self.nodes[left]: largest = left
if right < self.num and self.nodes[largest] < self.nodes[right]: largest = right
if largest != i:
self.nodes[i], self.nodes[largest] = self.nodes[largest], self.nodes[i]
self.max_heapify(largest)
def extract_max(self):
if self.num < 1: return
max = self.nodes[0]
self.nodes[0] = self.nodes[-1]
self.nodes.pop(-1)
self.num -= 1
self.max_heapify(0)
return max
def insert(self, key):
self.nodes.append(key)
self.num += 1
i = self.num-1
par = lambda i: (i-1)//2
while i > 0 and self.nodes[par(i)] < self.nodes[i]:
self.nodes[i], self.nodes[par(i)] = self.nodes[par(i)], self.nodes[i]
i = par(i)
def print_element(self):
for node in self.nodes:
print('', node, end='')
print('')
pq = PriorityQueue()
lines = sys.stdin.readlines()
for line in lines:
op = line.strip().split(' ')
if op[0] == 'insert':
pq.insert(int(op[1]))
elif op[0] == 'extract':
print(pq.extract_max())
else:
break
|
import sys
from heapq import heappush, heappop
# わからん
pq = []
lines = sys.stdin.readlines()
for line in lines:
op = line.strip().split(' ')
if op[0] == 'insert':
heappush(pq, -int(op[1]))
elif op[0] == 'extract':
print((-heappop(pq)))
else:
break
# import sys, time
#
# class PriorityQueue:
# __slots__ = ['nodes', 'num']
#
# def __init__(self):
# self.nodes = []
# self.num = 0
#
# def max_heapify(self, i):
# if i >= self.num: return
# left, right = (i+1)*2-1, (i+1)*2
#
# largest = i
# if left < self.num and self.nodes[i] < self.nodes[left]: largest = left
# if right < self.num and self.nodes[largest] < self.nodes[right]: largest = right
#
# if largest != i:
# self.nodes[i], self.nodes[largest] = self.nodes[largest], self.nodes[i]
# self.max_heapify(largest)
#
# def extract_max(self):
# if self.num < 1: return
# max = self.nodes[0]
# self.nodes[0] = self.nodes[-1]
# self.nodes.pop()
# self.num -= 1
# self.max_heapify(0)
# return max
#
# def insert(self, key):
# self.nodes.append(key)
# self.num += 1
# i = self.num-1
# par = lambda i: (i-1)//2
# while i > 0 and self.nodes[par(i)] < self.nodes[i]:
# self.nodes[i], self.nodes[par(i)] = self.nodes[par(i)], self.nodes[i]
# i = par(i)
#
# def print_element(self):
# for node in self.nodes:
# print('', node, end='')
# print('')
#
# pq = PriorityQueue()
#
# start = time.time()
# lines = sys.stdin.readlines()
# for line in lines:
# op = line.strip().split(' ')
# if op[0] == 'insert':
# pq.insert(int(op[1]))
# elif op[0] == 'extract':
# # print(pq.extract_max())
# pq.extract_max()
# else:
# break
# print('elapsed:', time.time()-start)
|
p02289
|
import sys
class QueueEmptyError(Exception):
pass
class PriorityQueue:
def __init__(self):
self._nodes = []
def add(self, v):
self._nodes.append(v)
i = len(self._nodes) - 1
while i > 0:
parent = (i-1) // 2
vp, vi = self._nodes[parent], self._nodes[i]
if vp < vi:
self._nodes[parent], self._nodes[i] = vi, vp
i = parent
else:
break
def extract(self):
size = len(self._nodes) - 1
if size < 0:
raise QueueEmptyError()
node = self._nodes[0]
last = self._nodes.pop()
if size > 0:
self._nodes[0] = last
i = 0
while i < size // 2:
top = i
left = (i+1) * 2 - 1
right = (i+1) * 2
vi = self._nodes[top]
vt = vi
if left < size:
vl = self._nodes[left]
if vl > vt:
top = left
vt = vl
if right < size:
vr = self._nodes[right]
if vr > vt:
top = right
vt = vr
if top > i:
self._nodes[top], self._nodes[i] = vi, vt
i = top
else:
break
return node
def run():
q = PriorityQueue()
for line in sys.stdin:
if line.startswith("i"):
q.add(int(line[7:]))
elif line.startswith("ex"):
print((q.extract()))
elif line.startswith("end"):
break
else:
ValueError("invalid command")
if __name__ == '__main__':
run()
|
import sys
def run():
q = []
for line in sys.stdin:
if line.startswith("i"):
v = int(line[7:])
q.append(v)
i = len(q) - 1
while i > 0:
p = (i-1) // 2
vp = q[p]
if vp < v:
q[p], q[i] = v, vp
i = p
else:
break
elif line.startswith("ex"):
size = len(q) - 1
if size < 0:
raise ValueError('get from empty queue')
v = q[0]
last = q.pop()
if size > 0:
q[0] = last
i = 0
while i < size // 2:
top, vt = i, last
left = (i+1) * 2 - 1
right = (i+1) * 2
if left < size:
vl = q[left]
if vl > vt:
top, vt = left, vl
if right < size:
vr = q[right]
if vr > vt:
top, vt = right, vr
if top > i:
q[top], q[i] = last, vt
i = top
else:
break
print(v)
elif line.startswith("end"):
break
else:
ValueError("invalid command")
if __name__ == '__main__':
run()
|
p02289
|
import sys
def h(i):
l=2*i;r=l+1
if r<=H:
if A[i]<A[l]:
if A[l]<A[r]:A[i],A[r]=A[r],A[i];h(r)
else:A[i],A[l]=A[l],A[i];h(l)
elif A[i]<A[r]:A[i],A[r]=A[r],A[i];h(r)
elif l<=H and A[i]<A[l]:A[i],A[l]=A[l],A[i];h(l)
H=0
A=[0]*2000001
o=''
for e in sys.stdin:
if'i'==e[0]:
H+=1;A[H]=int(e[7:]);k=H
while k>1 and A[k//2]<A[k]:A[k],A[k//2]=A[k//2],A[k];k//=2
elif'x'==e[1]:
o+=f'{A[1]}\n';H-=1
if H:A[1]=A[H+1];h(1)
print((o[:-1]))
|
import sys
from heapq import *
H=[]
O=[]
for e in sys.stdin:
if'i'==e[0]:heappush(H,-int(e[7:]))
elif't'==e[2]:O+=[-heappop(H)]
print(("\n".join(map(str,O))))
|
p02289
|
import sys
from heapq import *
H=[]
O=''
for e in sys.stdin:
if'i'==e[0]:heappush(H,-int(e[7:]))
elif'x'==e[1]:O+=f'{-heappop(H)}\n'
print((O[:-1]))
|
import sys
from heapq import *
H,O=[],[]
for e in sys.stdin:
if'i'==e[0]:heappush(H,-int(e[7:]))
elif'x'==e[1]:O+=[-heappop(H)]
print(('\n'.join(map(str,O))))
|
p02289
|
import sys
from heapq import *
H=[]
O=[]
for e in sys.stdin:
if'end'==e:break
if'i'==e[0]:heappush(H,-int(e[7:]))
elif't'==e[2]:O+=[-heappop(H)]
print(('\n'.join(map(str,O))))
|
import sys
from heapq import *
H=[]
O=[]
for e in sys.stdin:
if'i'==e[0]:heappush(H,-int(e[7:]))
elif't'==e[2]:O+=[-heappop(H)]
else:print(('\n'.join(map(str,O))))
|
p02289
|
import sys
INFTY = 1<<30
class MaxHeap():
def __init__(self, a, h):
self.a = a
self.h = h
def parent(self, i):
return i//2
def left(self, i):
return 2 * i
def right(self, i):
return 2 * i + 1
def maxHeapify(self, i):
l = self.left(i)
r = self.right(i)
if l <= self.h and self.a[l] > self.a[i]:
largest = l
else:
largest = i
if r <= self.h and self.a[r] > self.a[largest]:
largest = r
if largest != i:
self.a[i], self.a[largest] = self.a[largest], self.a[i]
self.maxHeapify(largest)
def extract(self):
if self.h < 1:
return -INFTY
maxv = self.a[1]
self.a[1] = self.a[self.h]
self.h -= 1
self.maxHeapify(1)
return maxv
def increaseKey(self, i, k):
if k < self.a[i]:
return
self.a[i] = k
while i > 1 and self.a[i//2] < self.a[i]:
self.a[i], self.a[i//2] = self.a[i//2], self.a[i]
i = i // 2
def insert(self, k):
self.h += 1
self.a[self.h] = -INFTY
self.increaseKey(self.h, k)
if __name__ == '__main__':
a = [None] * (2000000 + 1)
x = MaxHeap(a, 0)
ret = [None] * (2000000 + 1)
i = 0
coms = sys.stdin.readlines()
for com in coms:
if com[0] == "i":
k = int(com.split()[1])
x.insert(k)
elif com[0:2] == "ex":
ret[i] = x.extract()
i += 1
else:
sys.stdout.write("\n".join([str(s) for s in ret[:i]]))
print()
|
import sys
INFTY = 1<<30
a = [None] * (2000000 + 1)
h = 0
ret = [None] * (2000000 + 1)
i = 0
def left(i):
return 2 * i
def right(i):
return 2 * i + 1
def maxHeapify(i):
global a, h
l = left(i)
r = right(i)
if l <= h and a[l] > a[i]:
largest = l
else:
largest = i
if r <= h and a[r] > a[largest]:
largest = r
if largest != i:
a[i], a[largest] = a[largest], a[i]
maxHeapify(largest)
def extract():
global a, h
if h < 1:
return -INFTY
maxv = a[1]
a[1] = a[h]
h -= 1
maxHeapify(1)
return maxv
def increaseKey(i, k):
global a
if k < a[i]:
return
a[i] = k
while i > 1 and a[i//2] < a[i]:
a[i], a[i//2] = a[i//2], a[i]
i = i // 2
def insert(k):
global a, h
h += 1
a[h] = -INFTY
increaseKey(h, k)
coms = sys.stdin.readlines()
for com in coms:
if com[0] == "i":
k = int(com.split()[1])
insert(k)
elif com[0:2] == "ex":
ret[i] = extract()
i += 1
else:
sys.stdout.write("\n".join([str(s) for s in ret[:i]]))
print()
|
p02289
|
import sys
INFTY = 1<<30
a = [None] * (2000000 + 1)
h = 0
ret = [None] * (2000000 + 1)
i = 0
def left(i):
return 2 * i
def right(i):
return 2 * i + 1
def maxHeapify(i):
global a, h
l = left(i)
r = right(i)
if l <= h and a[l] > a[i]:
largest = l
else:
largest = i
if r <= h and a[r] > a[largest]:
largest = r
if largest != i:
a[i], a[largest] = a[largest], a[i]
maxHeapify(largest)
def extract():
global a, h
if h < 1:
return -INFTY
maxv = a[1]
a[1] = a[h]
h -= 1
maxHeapify(1)
return maxv
def increaseKey(i, k):
global a
if k < a[i]:
return
a[i] = k
while i > 1 and a[i//2] < a[i]:
a[i], a[i//2] = a[i//2], a[i]
i = i // 2
def insert(k):
global a, h
h += 1
a[h] = -INFTY
increaseKey(h, k)
coms = sys.stdin.readlines()
for com in coms:
if com[0] == "i":
k = int(com.split()[1])
insert(k)
elif com[0:2] == "ex":
ret[i] = extract()
i += 1
else:
sys.stdout.write("\n".join([str(s) for s in ret[:i]]))
print()
|
import sys
INFTY = 1<<30
a = [None] * 2000001
h = 0
ret = []
def maxHeapify(i):
global a, h
l = 2 * i
r = 2 * i + 1
if l <= h and a[l] > a[i]:
largest = l
else:
largest = i
if r <= h and a[r] > a[largest]:
largest = r
if largest != i:
a[i], a[largest] = a[largest], a[i]
maxHeapify(largest)
def extract():
global a, h
if h < 1:
return -INFTY
maxv = a[1]
a[1] = a[h]
h -= 1
maxHeapify(1)
return maxv
def increaseKey(i, k):
global a
if k < a[i]:
return
a[i] = k
while i > 1 and a[i//2] < a[i]:
a[i], a[i//2] = a[i//2], a[i]
i = i // 2
def insert(k):
global a, h
h += 1
a[h] = -INFTY
increaseKey(h, k)
for com in sys.stdin.readlines():
if com[0] == "i":
insert(int(com[7:]))
elif com[1] == "x":
ret.append(extract())
else:
print(("\n".join([str(s) for s in ret])))
# print()
|
p02289
|
import sys
from collections import deque
INFTY = 1<<30
a = [None] * 2000001
h = 0
ret = deque([])
def maxHeapify(i):
global a, h
l = 2 * i
r = 2 * i + 1
if l <= h and a[l] > a[i]:
largest = l
else:
largest = i
if r <= h and a[r] > a[largest]:
largest = r
if largest != i:
a[i], a[largest] = a[largest], a[i]
maxHeapify(largest)
def extract():
global a, h
if h < 1:
return -INFTY
maxv = a[1]
a[1] = a[h]
h -= 1
maxHeapify(1)
return maxv
def increaseKey(i, k):
global a
if k < a[i]:
return
a[i] = k
while i > 1 and a[i//2] < a[i]:
a[i], a[i//2] = a[i//2], a[i]
i = i // 2
def insert(k):
global a, h
h += 1
a[h] = -INFTY
increaseKey(h, k)
i = 0
for com in sys.stdin.readlines():
if com[0] == "i":
insert(int(com[7:]))
elif com[1] == "x":
ret.append(extract())
else:
sys.stdout.writelines("\n".join([str(s) for s in ret]))
print()
|
from sys import stdin, exit
def max_heapify(a, i):
heap_size = a[0]
L = 2*i
R = 2*i + 1
if L <= heap_size and a[L] > a[i]:
largest = L
else:
largest = i
if R <= heap_size and a[R] > a[largest]:
largest = R
if largest != i:
a[i], a[largest] = a[largest], a[i]
max_heapify(a, largest)
def main():
heap = [-1] * 2000001
heap[0] = 1
for cmd in stdin:
if cmd[0] == 'i':
heap[0] += 1
i = heap[0]
heap[i] = int(cmd[7:])
half = i // 2
while i > 1 and heap[half] < heap[i]:
heap[i], heap[half] = heap[half], heap[i]
i //= 2
half = i // 2
elif cmd[1] == 'x':
print((heap[1]))
heap[1] = heap[heap[0]]
heap[0] -= 1
max_heapify(heap, 1)
elif cmd[1] == 'n':
exit(0)
main()
|
p02289
|
from sys import stdin, exit
def max_heapify(a, i):
heap_size = a[0]
L = 2*i
R = 2*i + 1
if L <= heap_size and a[L] > a[i]:
largest = L
else:
largest = i
if R <= heap_size and a[R] > a[largest]:
largest = R
if largest != i:
a[i], a[largest] = a[largest], a[i]
max_heapify(a, largest)
def main():
heap = [-1] * 2000001
heap[0] = 1
for cmd in stdin:
if cmd[0] == 'i':
heap[0] += 1
i = heap[0]
heap[i] = int(cmd[7:])
half = i // 2
while i > 1 and heap[half] < heap[i]:
heap[i], heap[half] = heap[half], heap[i]
i //= 2
half = i // 2
elif cmd[1] == 'x':
print((heap[1]))
heap[1] = heap[heap[0]]
heap[0] -= 1
max_heapify(heap, 1)
elif cmd[1] == 'n':
exit(0)
main()
|
from sys import stdin, stdout, exit
def max_heapify(a, i):
heap_size = a[0]
L = 2*i
R = 2*i + 1
if L <= heap_size and a[L] > a[i]:
largest = L
else:
largest = i
if R <= heap_size and a[R] > a[largest]:
largest = R
if largest != i:
a[i], a[largest] = a[largest], a[i]
max_heapify(a, largest)
def main():
ret = []
heap = [-1] * 2000001
heap[0] = 1
for cmd in stdin:
if cmd[0] == 'i':
heap[0] += 1
i = heap[0]
heap[i] = int(cmd[7:])
half = i // 2
while i > 1 and heap[half] < heap[i]:
heap[i], heap[half] = heap[half], heap[i]
i //= 2
half = i // 2
elif cmd[1] == 'x':
ret.append(heap[1])
heap[1] = heap[heap[0]]
heap[0] -= 1
max_heapify(heap, 1)
elif cmd[1] == 'n':
stdout.writelines("\n".join([str(s) for s in ret]))
print()
exit(0)
main()
|
p02289
|
from sys import stdin, stdout, exit
def max_heapify(a, i):
heap_size = a[0]
L = 2*i
R = 2*i + 1
if L <= heap_size and a[L] > a[i]:
largest = L
else:
largest = i
if R <= heap_size and a[R] > a[largest]:
largest = R
if largest != i:
a[i], a[largest] = a[largest], a[i]
max_heapify(a, largest)
def main():
ret = []
heap = [-1] * 2000001
heap[0] = 1
for cmd in stdin:
if cmd[0] == 'i':
heap[0] += 1
i = heap[0]
heap[i] = int(cmd[7:])
half = i // 2
while i > 1 and heap[half] < heap[i]:
heap[i], heap[half] = heap[half], heap[i]
i //= 2
half = i // 2
elif cmd[1] == 'x':
ret.append(heap[1])
heap[1] = heap[heap[0]]
heap[0] -= 1
max_heapify(heap, 1)
elif cmd[1] == 'n':
stdout.writelines("\n".join([str(s) for s in ret]))
print()
exit(0)
main()
|
import heapq
import sys
h = []
for com in sys.stdin.readlines():
if com[0] == "i":
heapq.heappush(h, -int(com[7:]))
elif com[1] == "x":
print((-heapq.heappop(h)))
|
p02289
|
import sys
def max_heapify(a, i):
h = len(a)
l = 2 * i + 1
r = 2 * i + 2
if l < h and a[l] > a[i]:
largest = l
else:
largest = i
if r < h and a[r] > a[largest]:
largest = r
if largest != i:
tmp = a[i]
a[i] = a[largest]
a[largest] = tmp
max_heapify(a, largest)
def build_max_heap(a):
h = len(a)
for i in range(h // 2 - 1, -1, -1):
max_heapify(a, i)
def extract_max(a):
max = a[0]
a[0] = a[-1]
a.pop()
build_max_heap(a)
return max
def insert(a, n):
i = len(a)
a.append(n)
while i > 0:
p = int((i + 1) / 2) - 1
v = a[i]
pv = a[p]
if pv < v:
a[p] = v
a[i] = pv
i = p
else:
break
heap = []
while True:
cmd = input().split()
if cmd[0] == "end":
break
elif cmd[0] == "extract":
print((extract_max(heap)))
elif cmd[0] == "insert":
insert(heap, int(cmd[1]))
|
def extract_max(A):
x = A[0]
A[0] = A[-1]
A.pop()
H = len(A)
i = 0
while i < H: # ???????????????
v = A[i]
rv = 0
lv = 0
r = (i + 1) * 2
l = r - 1
if l < H:
lv = A[l]
if r < H:
rv = A[r]
if v < lv and lv > rv:
A[l] = v
A[i] = lv
i = l
elif v < rv:
A[r] = v
A[i] = rv
i = r
else:
break
return x
def insert(a, n):
i = len(a)
a.append(n)
while i > 0:
p = int((i + 1) / 2) - 1
v = a[i]
pv = a[p]
if pv < v:
a[p] = v
a[i] = pv
i = p
else:
break
heap = []
while True:
cmd = input().split()
if cmd[0] == "end":
break
elif cmd[0] == "extract":
print((extract_max(heap)))
elif cmd[0] == "insert":
insert(heap, int(cmd[1]))
|
p02289
|
def extract_max(A):
x = A[0]
A[0] = A[-1]
A.pop()
H = len(A)
i = 0
while i < H: # ???????????????
v = A[i]
rv = 0
lv = 0
r = (i + 1) * 2
l = r - 1
if l < H:
lv = A[l]
if r < H:
rv = A[r]
if v < lv and lv > rv:
A[l] = v
A[i] = lv
i = l
elif v < rv:
A[r] = v
A[i] = rv
i = r
else:
break
return x
def insert(a, n):
i = len(a)
a.append(n)
while i > 0:
p = int((i + 1) / 2) - 1
v = a[i]
pv = a[p]
if pv < v:
a[p] = v
a[i] = pv
i = p
else:
break
heap = []
while True:
cmd = input().split()
if cmd[0] == "end":
break
elif cmd[0] == "extract":
print((extract_max(heap)))
elif cmd[0] == "insert":
insert(heap, int(cmd[1]))
|
import sys
def extract_max(A):
x = A[0]
A[0] = A[-1]
A.pop()
H = len(A)
i = 0
while i < H:
v = A[i]
rv = 0
lv = 0
r = (i + 1) * 2
l = r - 1
if l < H:
lv = A[l]
if r < H:
rv = A[r]
if v < lv and lv > rv:
A[l] = v
A[i] = lv
i = l
elif v < rv:
A[r] = v
A[i] = rv
i = r
else:
break
return x
def insert(a, n):
i = len(a)
a.append(n)
while i > 0:
p = int((i + 1) / 2) - 1
v = a[i]
pv = a[p]
if pv < v:
a[p] = v
a[i] = pv
i = p
else:
break
def main():
istr = sys.stdin.read()
cmds = list(istr.splitlines())
S = []
for cmd in cmds: # input()
if cmd[0] == "i":
insert(S, int(cmd[7:]))
elif cmd == "extract":
a = extract_max(S)
print(a)
elif cmd == "end":
break
if __name__ == '__main__':
main()
|
p02289
|
def max_heapify(A, i):
l = i * 2
r = i * 2 + 1
largest = i
if l < len(A):
if A[l] > A[largest]:
largest = l
if r < len(A):
if A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
max_heapify(A, largest)
def build_max_heap(A):
for i in range(int(len(A) / 2), 0, -1):
max_heapify(A, i)
def insert(A, k):
A.append(k)
def extract_max(A):
build_max_heap(A)
k = A.pop(1)
return k
A = [None]
while True:
o = list(map(str, input().split()))
if o[0] == "insert":
insert(A, int(o[1]))
elif o[0] == "extract":
print((extract_max(A)))
else:
break
|
def insert(A, k):
i = len(A)
A.append(k)
while i != 0:
j = int((i - 1) / 2)
if A[j] < A[i]:
A[i], A[j] = A[j], A[i]
i = j
def extract_max(A):
k = A[0]
A[0] = A[-1]
A.pop()
n = len(A)
p = 0
while True:
c = 2 * p + 1
if c >= n:
break
if c < n - 1 and A[c] < A[c + 1]:
c += 1
if A[p] < A[c]:
A[p], A[c] = A[c], A[p]
p = c
return k
A = []
while True:
o = list(map(str, input().split()))
if o[0] == "insert":
insert(A, int(o[1]))
elif o[0] == "extract":
print((extract_max(A)))
else:
break
|
p02289
|
import heapq
def main():
q = []
heapq.heapify(q)
while True:
s = input().split()
if s[0] == 'end':
break
elif s[0] == 'insert':
heapq.heappush(q, (-int(s[1]), int(s[1])))
else:
p = heapq.heappop(q)
print((p[1]))
if __name__ == '__main__':
main()
|
import heapq
def main():
q = []
heapq.heapify(q)
while True:
s = input().split()
if s[0] == 'end':
break
elif s[0] == 'insert':
heapq.heappush(q, -int(s[1]))
else:
p = heapq.heappop(q)
print((-p))
if __name__ == '__main__':
main()
|
p02289
|
def maxHeapify(i, node_list):
n = len(node_list)
if 2*i+1 < n and node_list[2*i+1] > node_list[i]:
i_largest = 2*i+1
# node_list[i], node_list[2*i+1] = node_list[2*i+1], node_list[i]
else:
i_largest = i
if 2*i+2 < n and node_list[2*i+2] > node_list[i_largest]:
i_largest = 2*i+2
# node_list[i], node_list[2*i+2] = node_list[2*i+2], node_list[i]
if i_largest != i:
node_list[i], node_list[i_largest] = node_list[i_largest], node_list[i]
maxHeapify(i_largest, node_list)
def insert_heap(i, node_list):
node_list.append(i)
n = len(node_list)
for i in range(n//2, -1, -1):
maxHeapify(i, node_list)
def extract_heap(node_list):
print((node_list[0]))
pop = node_list.pop()
n = len(node_list)
if n != 0:
node_list[0] = pop
for i in range(n//2, -1, -1):
maxHeapify(i, node_list)
import sys
input_list = sys.stdin.readlines()
node_list = []
for line in input_list:
line = line.split()
if line[0] == 'end':
break
elif line[0] == 'extract':
extract_heap(node_list)
else:
insert_heap(int(line[1]), node_list)
|
def maxHeapify(i, node_list):
n = len(node_list)
if 2*i+1 < n and node_list[2*i+1] > node_list[i]:
i_largest = 2*i+1
else:
i_largest = i
if 2*i+2 < n and node_list[2*i+2] > node_list[i_largest]:
i_largest = 2*i+2
if i_largest != i:
node_list[i], node_list[i_largest] = node_list[i_largest], node_list[i]
maxHeapify(i_largest, node_list)
def insert_heap(i, node_list):
node_list.append(i)
k = len(node_list) - 1
while(node_list[k] > node_list[(k-1)//2] and k > 0):
node_list[k], node_list[(k-1)//2] = node_list[(k-1)//2], node_list[k]
k = (k-1)//2
def extract_heap(node_list):
print((node_list[0]))
pop = node_list.pop()
n = len(node_list)
if n != 0:
node_list[0] = pop
maxHeapify(0, node_list)
import sys
input_list = sys.stdin.readlines()
node_list = []
for line in input_list:
line = line.split()
if line[0] == 'end':
break
elif line[0] == 'extract':
extract_heap(node_list)
else:
insert_heap(int(line[1]), node_list)
|
p02289
|
import sys
readline = sys.stdin.readline
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < n and A[l] > A[i]:
largest = l
else:
largest = i
if r < n and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def insert(S, k):
S.append(k)
i = n - 1
while i > 0 and S[i] > S[(i - 1) // 2]:
S[i], S[(i - 1) // 2] = S[(i - 1) // 2], S[i]
i = (i - 1) // 2
def extractMax(S):
if len(S) == 1:
return S.pop()
ans = S[0]
S[0] = S.pop()
maxHeapify(S, 0)
return ans
A = []
n = 0
while True:
s = readline()
if s[2] == "d":
break
elif s[2] == "t":
n -= 1
print((extractMax(A)))
else:
n += 1
insert(A, int(s[7:]))
|
import sys
readline = sys.stdin.readline
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < n and A[l] > A[i]:
largest = l
else:
largest = i
if r < n and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def insert(S, k):
S.append(k)
i = n - 1
p = (i - 1) // 2
while i > 0 and S[i] > S[p]:
S[i], S[p] = S[p], S[i]
i = p
p = (i - 1) // 2
def extractMax(S):
if len(S) == 1:
return S.pop()
ans = S[0]
S[0] = S.pop()
maxHeapify(S, 0)
return ans
A = []
n = 0
while True:
s = readline()
if s[2] == "d":
break
elif s[2] == "t":
n -= 1
print((extractMax(A)))
else:
n += 1
insert(A, int(s[7:]))
|
p02289
|
import sys
readline = sys.stdin.readline
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < n:
largest = l
if r < n and A[r] > A[l]:
largest = r
if A[largest] > A[i]:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def insert(S, k):
global n
S[n] = k
n += 1
i = n - 1
p = (i - 1) // 2
while i > 0 and S[i] > S[p]:
S[i], S[p] = S[p], S[i]
i = p
p = (i - 1) // 2
def extractMax(S):
global n
if n == 1:
n -= 1
return S[0]
ans = S[0]
n -= 1
S[0] = S[n]
maxHeapify(S, 0)
return ans
A = [0] * 2000000
n = 0
for s in sys.stdin:
if s[2] == "s":
insert(A, int(s[7:]))
elif s[2] == "t":
print((extractMax(A)))
else:
break
|
import sys
readline = sys.stdin.readline
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < n:
largest = l
if r < n and A[r] > A[l]:
largest = r
if A[largest] > A[i]:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def insert(S, k):
global n
S[n] = k
n += 1
i = n - 1
p = (i - 1) // 2
while i > 0 and S[i] > S[p]:
S[i], S[p] = S[p], S[i]
i = p
p = (i - 1) // 2
def extractMax(S):
global n
if n == 1:
n -= 1
return S[0]
ans = S[0]
n -= 1
S[0] = S[n]
i = 0
while True:
l = i * 2 + 1
r = i * 2 + 2
if l >= n:
break
largest = l
if r < n and A[r] > A[l]:
largest = r
if A[largest] > A[i]:
A[i], A[largest] = A[largest], A[i]
i = largest
else:
break
return ans
A = [0] * 2000000
n = 0
for s in sys.stdin:
if s[2] == "s":
insert(A, int(s[7:]))
elif s[2] == "t":
print((extractMax(A)))
else:
break
|
p02289
|
import sys
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < n:
largest = l
if r < n and A[r] > A[l]:
largest = r
if A[largest] > A[i]:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def insert(S, k):
global n
S[n] = k
n += 1
i = n - 1
p = (i - 1) // 2
while i > 0 and S[i] > S[p]:
S[i], S[p] = S[p], S[i]
i = p
p = (i - 1) // 2
def extractMax(S):
global n
if n == 1:
n -= 1
return S[0]
ans = S[0]
n -= 1
S[0] = S[n]
i = 0
while True:
l = i * 2 + 1
r = i * 2 + 2
if l >= n:
break
largest = l
if r < n and A[r] > A[l]:
largest = r
if A[largest] > A[i]:
A[i], A[largest] = A[largest], A[i]
i = largest
else:
break
return ans
A = [0] * 2000000
S = []
n = 0
for s in sys.stdin:
if s[2] == "s":
insert(A, int(s[7:]))
elif s[2] == "t":
S.append(extractMax(A))
else:
break
print(("\n".join(map(str, S))))
|
import sys
from heapq import heapify, heappush, heappop
hq = []
S = []
for s in sys.stdin:
if s[2] == "s":
heappush(hq, -int(s[7:]))
elif s[2] == "t":
S.append(-heappop(hq))
else:
break
print(("\n".join(map(str, S))))
|
p02289
|
from sys import stdin
readline = stdin.readline
import heapq
def main():
heap = []
while True:
line = readline()
if line[2] == 't':
print((heapq.heappop(heap)[1]))
elif line[2] == 's':
n = int(line.split()[1])
heapq.heappush(heap, (-n, n))
else:
break
main()
|
from sys import stdin
from heapq import heappop, heappush
readline = stdin.readline
heap = []
while True:
line = readline()
if line[1] == 'x':print((-heappop(heap)))
elif line[0] == 'i':heappush(heap, -int(line.split()[1]))
else:break
|
p02289
|
def dw_heap(A,i,length):
l = i*2
r = i*2 + 1
largest = i
if l < length and A[l] > A[largest]: largest = l
if r < length and A[r] > A[largest]: largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
dw_heap(A, largest, length)
def up_heap(A,i):
if i==1: return
p = i//2
if A[i] > A[p]:
A[i], A[p] = A[p], A[i]
up_heap(A,p)
def extract(A,last):
max_item = A[1]
A[1],A[last] = A[last],A[1]
dw_heap(A,1,last)
return max_item
def build_heap(A,length):
for i in range(length//2,0,-1): dw_heap(A,i,length)
if __name__=='__main__':
hp = [None]*2*10**6
i = 1
while True:
op = input().split()
if op[0] != 'insert': break
hp[i] = int(op[1])
i += 1
if op[0] != 'end': build_heap(hp,i)
while True:
if op[0] == 'end': break
if op[0] == 'insert':
hp[i] = int(op[1])
up_heap(hp,i)
i += 1
else:
print((extract(hp,i-1)))
i -= 1
op = input().split()
|
def dw_heap(A,i,length):
l = i*2
r = i*2 + 1
largest = i
if l < length and A[l] > A[largest]: largest = l
if r < length and A[r] > A[largest]: largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
dw_heap(A, largest, length)
def up_heap(A,i):
if i==1: return
p = i//2
if A[i] > A[p]:
A[i], A[p] = A[p], A[i]
up_heap(A,p)
def extract(A,last):
max_item = A[1]
A[1],A[last] = A[last],A[1]
dw_heap(A,1,last)
return max_item
def build_heap(A,length):
for i in range(length//2,0,-1): dw_heap(A,i,length)
if __name__=='__main__':
hp = [None]*(2*10**6)
i = 1
j = -1
while True:
op = input()
if op[0] != 'i': break
hp[i] = int(op[7:])
i += 1
if op[2] != 'd': build_heap(hp,i)
while True:
if op[2] == 'd': break
if op[0] == 'i':
hp[i] = int(op[7:])
up_heap(hp,i)
i += 1
else:
hp[j] = extract(hp,i-1)
i -= 1
j -= 1
op = input()
print(*hp[:j:-1],sep='\n')
|
p02289
|
#!/usr/bin/python3
import sys
import queue
# main
q = queue.PriorityQueue()
m = 2 * (10 ** 9)
while True:
s = sys.stdin.readline().split()
if s[0].startswith('i'):
q.put(m - int(s[1]))
elif s[0].startswith('ex'):
print((m - q.get()))
if s[0] == 'end':
exit()
|
#!/usr/bin/python3
import sys
import queue
# main
q = queue.PriorityQueue()
m = 2 * (10 ** 9)
S = sys.stdin.readlines()
for line in S:
s = line.split()
if s[0].startswith('i'):
q.put(m - int(s[1]))
elif s[0].startswith('ex'):
print((m - q.get()))
if s[0] == 'end':
exit()
|
p02289
|
#!/usr/bin/python3
import sys
import queue
# main
q = queue.PriorityQueue()
m = 2 * (10 ** 9)
S = sys.stdin.readlines()
for line in S:
s = line.split()
if s[0].startswith('i'):
q.put(m - int(s[1]))
elif s[0].startswith('ex'):
print((m - q.get()))
if s[0] == 'end':
exit()
|
#!/usr/bin/python3
import sys
import heapq
# main
q = []
S = sys.stdin.readlines()
for line in S:
if line[0].startswith('i'):
heapq.heappush(q, -int(line.split()[1]))
elif line[1] == 'x':
print((-heapq.heappop(q)))
else:
exit()
|
p02289
|
import sys
import heapq
heap = []
while True:
input_line = sys.stdin.readline()
input_line = input_line.strip().split(' ')
if input_line[0][0] == 'i' :
heapq.heappush(heap,-int(input_line[1]))
heapq.heapify(heap)
elif input_line[0][1] == 'x' :
print((-int(heapq.heappop(heap))))
else :
break
|
import sys
import heapq
heap = []
while True:
input_line = sys.stdin.readline()
input_line = input_line.strip().split(' ')
if input_line[0][0] == 'i' :
heapq.heappush(heap,-int(input_line[1]))
elif input_line[0][1] == 'x' :
print((-int(heapq.heappop(heap))))
else :
break
|
p02289
|
# -*- coding: utf-8 -*-
from heapq import heappush, heappop
A = []
inp = [None]
while inp[0] != "end":
inp = [n for n in input().split()]
if inp[0] == "insert":
heappush(A, -int(inp[1]))
elif inp[0] == "extract":
print((-heappop(A)))
|
# -*- coding: utf-8 -*-
from heapq import heappush, heappop
A = []
inp = [None]
while inp[0] != "end":
inp = input().split()
if inp[0] == "insert":
heappush(A, -int(inp[1]))
elif inp[0] == "extract":
print((-heappop(A)))
|
p02289
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.