input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(m):
num=max(a)
a.remove(num)
a.append(num//2)
print((sum(a)))
| import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a=list([x*(-1) for x in a])
heapq.heapify(a)
for i in range(m):
heapq.heappush(a, -1*(-heapq.heappop(a)//2))
print((sum(a)*-1))
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse=True)
for i in range(0,M):
A[0]=int(A[0]/2)
A.sort(reverse=True)
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = list([int(x)*(-1) for x in input().split()])
heapq.heapify(A)
for i in range(0,M):
a=heapq.heappop(A)
heapq.heappush(A,(-1)*(-a//2))
print((-sum(A)))
# 優先度付きキューが難しい | p02912 |
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(m):
a[a.index(max(a))]//=2
print((sum(a)))
| import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a=[-1*i for i in a]
heapq.heapify(a)
for i in range(m):
ma=heapq.heappop(a)
ma*=-1
heapq.heappush(a,-1*(ma//2))
print((sum(a)*-1))
| p02912 |
import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a=[-1*i for i in a]
heapq.heapify(a)
for i in range(m):
ma=heapq.heappop(a)
ma*=-1
heapq.heappush(a,-1*(ma//2))
print((sum(a)*-1))
| import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a=[-1*i for i in a]#最大値をとるため＊－１
heapq.heapify(a)#二分木の形にする
for i in range(m):#ｍ回
ma=heapq.heappop(a)#listから最小（最大）を取り出しその値を記憶するためのma
ma*=-1#-のままだと-3//2=2になってしまうので計算が合わない
heapq.heappush(a,-1*(ma//2))#2で割った値に－１を懸けて戻す
print((sum(a)*-1))#https://qiita.com/T_Wakasugi/items/dac6eb77a3cace54f95e
| p02912 |
import bisect
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a = sorted(a)
for i in range(m):
p = a[n-1]//2
a.pop()
a.insert(bisect.bisect_left(a,p),p)
print((sum(a)))
| import heapq
n,m = list(map(int,input().split()))
a = list([int(x)*(-1) for x in input().split()])
heapq.heapify(a)
for _ in range(m):
p = heapq.heappop(a)
heapq.heappush(a,(-1)*(-p//2))
print((-sum(a)))
| p02912 |
import bisect
import sys
input = sys.stdin.readline
def main():
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
for _ in range(M):
ins = A.pop() // 2
A.insert(bisect.bisect_left(A, ins), ins)
print((sum(A)))
if __name__ == '__main__':
main()
| import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [-n for n in A]
heapq.heapify(A)
for _ in range(M):
high = -heapq.heappop(A)
heapq.heappush(A, -(high//2))
print((-sum(A))) | p02912 |
n,m=list(map(int,input().split()))
lst=list(map(int,input().split()))
for i in range(m):
x=lst.index(max(lst))
lst[x]=int(lst[x]/2)
print((sum(lst))) | import heapq
import math
n,m=list(map(int,input().split()))
a=list([int(x)*(-1) for x in input().split()])
heapq.heapify(a)
for i in range(m):
heapq.heappush(a,math.ceil(heapq.heappop(a)/2))
print((-1*sum(a))) | p02912 |
import heapq
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
k = len(A)
for i in range(k):
A[i] = A[i] * -1
heapq.heapify(A)
for i in range(m):
maxim = heapq.heappop(A)
maxim /= 2
heapq.heappush(A, maxim)
for i in range(k):
A[i] = int(A[i] * -1)
ans = sum(A)
print(ans)
| import heapq
n, m = list(map(int, (input().split())))
A = list(map(int, input().split()))
for i in range(n):
A[i] = A[i]*(-1)
heapq.heapify(A)
for i in range(m):
value = heapq.heappop(A)
value /= 2
heapq.heappush(A, value)
ans = 0
for a in A:
ans += int(-a)
print(ans)
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A, reverse=True)
for _ in range(M):
A[0] = A[0]//2
A = sorted(A, reverse=True)
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [-a for a in A]
A = sorted(A)
heapq.heapify(A)
for _ in range(M):
ma = heapq.heappop(A)
ma = -((-ma)//2)
heapq.heappush(A, ma)
# print(A, ma)
print((-sum(A))) | p02912 |
N ,M = list(map(int,input().split()))
A = [int(x) for x in input().split()]
for i in range(M):
A[A.index(max(A))] //= 2
print((sum(A))) | import heapq
N, M = list(map(int,input().split()))
h = []
for x in input().split():
heapq.heappush(h, -int(x))
for i in range(M):
x = -heapq.heappop(h)
x //= 2
heapq.heappush(h,-x)
print((-sum(h))) | p02912 |
import math
from copy import deepcopy
import sys
from itertools import combinations_with_replacement
def input():
return sys.stdin.readline()[:-1]
# input
N, M = list(map(int, input().split()))
As = list(map(int, input().split()))
ind = [i for i in range(N)]
min_val = None
for combo in combinations_with_replacement(ind, M):
price = deepcopy(As)
for i in combo:
price[i] = math.floor(price[i]/2)
if min_val is None:
min_val = sum(price)
else:
if sum(price) <= min_val:
min_val = sum(price)
print(min_val) | import heapq
import sys
def input():
return sys.stdin.readline()[:-1]
# input
N, M = list(map(int, input().split()))
a = []
for i in input().split():
heapq.heappush(a, -int(i))
for j in range(M):
highest = heapq.heappop(a)
heapq.heappush(a, -(- highest // 2))
print((-sum(a))) | p02912 |
from collections import deque
n,m=list(map(int,input().split()))
a=sorted(deque(list(map(int,input().split()))),reverse=True)
for i in range(m):
a[0]=a[0]//2
a.sort(reverse=True)
print((sum(a))) | import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a = list([x*(-1) for x in a])
heapq.heapify(a)
for i in range(m):
s=heapq.heappop(a)*(-1)
heapq.heappush(a, (s//2)*(-1))
print((sum(a)*(-1))) | p02912 |
import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = list([x * (-1) for x in a])
heapq.heapify(a)
while m != 0:
price = heapq.heappop(a)
price = price/2
m -= 1
heapq.heappush(a, price)
for i in range(len(a)):
a[i] = int(a[i])
print((sum(a) * (-1))) | import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(len(a)):
a[i] = a[i]*-1.0
heapq.heapify(a)
while m != 0:
price = heapq.heappop(a)
price = price/2
m -= 1
heapq.heappush(a, price)
for i in range(len(a)):
a[i] = int(a[i])
print((sum(a) * (-1))) | p02912 |
from sys import stdin, setrecursionlimit
from bisect import insort
def main():
input = stdin.buffer.readline
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
for _ in range(m):
tmp = a[n - 1] // 2
insort(a, tmp)
print((sum(a[:n])))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| from sys import stdin, setrecursionlimit
from heapq import heapify, heappop, heappush
def main():
input = stdin.buffer.readline
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [-ai for ai in a]
heapify(a)
for _ in range(m):
tmp = -heappop(a)
heappush(a, -(tmp // 2))
print((-sum(a)))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| p02912 |
# -*- coding: utf-8 -*-
"""
Created on Fri Sep 13 22:46:19 2019
"""
N,M=( int(x) for x in input().split())
A=[int(s) for s in input().split()]
for i in range(M):
Pmax=max(A)
Pmax_index=A.index(max(A))
A[Pmax_index]=int(A[Pmax_index]/2)
print((sum(A))) | import heapq
N,M=( int(x) for x in input().split())
A=[int(s)*-1 for s in input().split()]
heapq.heapify(A)
for i in range(M):
A_max=heapq.heappop(A)*-1
heapq.heappush(A,(A_max//2)*-1)
print((sum(A)*-1))
| p02912 |
import sys
import heapq
n, m = list(map(int, sys.stdin.readline().split()))
A = list([-int(x) for x in sys.stdin.readline().split()])
heapq.heapify(A)
for j in range(m):
heapq.heappush(A ,int(A[0]/2))
heapq.heappop(A)
print((-sum(A))) | #ABC141D
#heapq 効率的にリストの最小値を取り出す
def main():
import sys, heapq as h
N, M = list(map(int, sys.stdin.readline().split()))
A = list([-int(x) for x in sys.stdin.readline().split()])
#print(A)
h.heapify(A) #heap化
#print(A)
for m in range(M):
a = h.heappop(A)
#print(int(a/2))
h.heappush(A, int(a/2))
#print(A)
print((-sum(A)))
if __name__ =='__main__':
main()
| p02912 |
#141D bisect
def main():
import sys, bisect
#from collections import deque
N,M =list(map(int, sys.stdin.readline().split()))
A = list(map(int, sys.stdin.readline().split()))
A.sort()
#print(A)
while M:
tmp = A.pop()
bisect.insort(A, tmp//2)
M-=1
print((sum(A)))
if __name__=='__main__':
main()
| #ABC141D
def main():
import sys
import heapq as hp
N, M = list(map(int, sys.stdin.readline().split()))
A = list([-int(x) for x in sys.stdin.readline().split()])
A.sort()
hp.heapify(A)
#print(A)
while M>0:
tmp = hp.heappop(A) #左から取り出す
tmp = -((-tmp)//2)
hp.heappush(A, tmp)
M-=1
print((-sum(A)))
if __name__=='__main__':
main()
| p02912 |
n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
while m>0:
max_a_ind=a.index(max(a))
a[max_a_ind]=a[max_a_ind]//2
m-=1
print((sum(a)))
| from heapq import heappop,heappush,heapify
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n,m = list(map(int,input().split()))
a = [int(x) for x in input().split()]
a_minus = [-x for x in a]
heapify(a_minus)
pop = lambda: -heappop(a_minus)
push = lambda x: heappush(a_minus,-x)
for _ in range(m):
x = pop()
push(x//2)
print((-sum(a_minus))) | p02912 |
from heapq import heappop,heappush,heapify
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n,m = list(map(int,input().split()))
a = [int(x) for x in input().split()]
a_minus = [-x for x in a]
heapify(a_minus)
pop = lambda: -heappop(a_minus)
push = lambda x: heappush(a_minus,-x)
for _ in range(m):
x = pop()
push(x//2)
print((-sum(a_minus))) | import heapq
n, m = list(map(int, input().split()))
a = list([int(x)*(-1) for x in input().split()])
heapq.heapify(a)
for i in range(m):
tmp_min=heapq.heappop(a)
heapq.heappush(a,(-1)*(-1*tmp_min//2)) # 計算誤差の関係で-1を2回かけてます
print((-sum(a)))
| p02912 |
n,m = list(map(int,input().split()))
t = list(map(int,input().split()))
t.sort(reverse=True)
memo = []
for i in range(m):
if len(memo) == 0:
x=t.pop(0)
elif len(t) == 0:
x=memo.pop(0)
elif t[0] >= memo[0]:
x=t.pop(0)
else:
x=memo.pop(0)
x = int(x/2)
memo.append(x)
#print(t)
print((sum(t)+sum(memo))) | import heapq
n,m = list(map(int,input().split()))
t = list(map(int,input().split()))
for i in range(n):
t[i] = -t[i]
t.sort()
for i in range(m):
x=heapq.heappop(t)
x = -x
x = int(x/2)
heapq.heappush(t,-x)
#print(t)
print((-sum(t))) | p02912 |
import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [-1*i for i in a]
heapq.heapify(a)
count = 0
while count < m:
item = heapq.heappop(a)
item= abs(item)
discount_item = item//2
heapq.heappush(a,-1*discount_item)
count += 1
print((abs(sum(a)))) | import heapq
N,M = list(map(int,input().split()))
T = list(map(int,input().split()))
memo = []
for t in T:
memo.append(-t)
memo.sort()
for m in range(M):
tmp = heapq.heappop(memo)
tmp = int(tmp/2)
heapq.heappush(memo,tmp)
print((-1*sum(memo)))
| p02912 |
from bisect import bisect
#n:shinamono no kazu
#m:waribiki maisuu
n,m=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
indexMax=len(a)-1
for _ in range(m):
maxA=a[indexMax]
a.pop(indexMax)
a.insert(bisect(a, maxA/2.0), maxA/2.0)
#print(a)
result=0
for item in a:
result+=item//1
print((int(result))) | #n:shinamono no kazu
#m:waribiki maisuu
import heapq
n,m=list(map(int,input().split()))
a=list([int(x)*(-1) for x in input().split()])
#print(temp)
heapq.heapify(a)
for _ in range(m):
minA=heapq.heappop(a)
#print(minA)
heapq.heappush(a,minA/2.0)
#print(a)
#print(a)
result=0
for item in a:
result+=item*(-1)//1
print((int(result)))
| p02912 |
import math
#math.floor
n, m = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
for i in range(m):
a[a.index(max(a))] = a[a.index(max(a))]/2
result = 0
for i in a:
result += math.floor(i)
print(result) | from heapq import heapify, heappush, heappop
from math import floor
n, m = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
a = [x*(-1) for x in a]
heapify(a)
for _ in range(m):
x = floor(-heappop(a)/2)*(-1)
heappush(a, x)
print((-sum(a))) | p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for _ in range(M):
i = A.index(max(A))
A[i] = A[i]//2
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(N):
A[i] = -A[i]
heapq.heapify(A)
for _ in range(M):
a = -heapq.heappop(A)
a = (a//2) * -1
heapq.heappush(A, a)
print((sum(A)*-1)) | p02912 |
N, M = list(map(int, input().split()))
# print(N)
# print(M)
A = list(map(int, input().split()))
# print(A)
A = sorted(A, reverse=True)
# print(A)
for i in range(M):
# print(i)
A[0] = int(A[0] / 2)
A = sorted(A, reverse=True)
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
# print(N)
# print(M)
hq = []
A = list(map(int, input().split()))
for x in A:
heapq.heappush(hq, -x)
# print(hq)
for i in range(M):
x = heapq.heappop(hq)
x = int(x / 2)
# print(x)
heapq.heappush(hq, x)
# print(hq)
ans = 0
for x in hq:
ans += -x
print(ans) | p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(M):
idx=A.index(max(A))
A[idx]=A[idx]//2
print((sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list([int(x)*(-1) for x in input().split()])
heapq.heapify(A)
for i in range(M):
tmp_min = heapq.heappop(A)
heapq.heappush(A, (-1)*(-tmp_min//2))
print((-sum(A))) | p02912 |
def main():
[N, M] = [int(num) for num in input().split()]
A = [int(num) for num in input().split()]
for i in range(M):
expensive = max(A)
A[A.index(expensive)] = expensive / 2
A = [a//1 for a in A]
print((int(sum(A))))
if __name__ == '__main__':
main()
| import heapq
def main():
[N, M] = [int(num) for num in input().split()]
A = [int(num) for num in input().split()]
hp = []
for a in A:
heapq.heappush(hp, - a)
for i in range(M):
expensive = heapq.heappop(hp)
heapq.heappush(hp, expensive / 2)
hp = [int(- a // 1) for a in hp]
print((sum(hp)))
if __name__ == '__main__':
main()
| p02912 |
if __name__ == "__main__":
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(M):
A[A.index(max(A))] = A[A.index(max(A))] // 2
print((sum(A)))
| import heapq
if __name__ == "__main__":
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [(-x, x) for x in A]
heapq.heapify(A)
for i in range(M):
tmp = heapq.heappop(A)
v = tmp[1] // 2
heapq.heappush(A, (-v, v))
res = 0
for i in range(len(A)):
res += A[i][1]
print(res)
| p02912 |
n, m = list(map(int, input().split()))
a = [int(_) for _ in input().split()]
a.sort(reverse=True)
ans = 0
search_idx = 0
for i in range(m):
max_idx = 0
if search_idx+2 >= n:
search_idx = n - 2
for j in range(0, search_idx+2):
if a[max_idx] < a[j]:
max_idx = j
if search_idx < max_idx:
search_idx = max_idx
a[max_idx] //= 2
#print(a)
print((sum(a))) | import heapq
# 「優先度付きキュー」の練習問題
n, m = list(map(int, input().split()))
a = [int(_) for _ in input().split()]
# 各要素を-1倍する。最大値の取り出しができるように
a = list([x*(-1) for x in a])
# aの優先度付きキューに
heapq.heapify(a)
# 割引m回分ループ
for _ in range(m):
popNum = heapq.heappop(a)
heapq.heappush(a, (-1)*(-popNum//2))
# 負で出力されているので戻す
print((-sum(a))) | p02912 |
I = list(map(int,input().split()))
N = I[0]
M = I[1]
A = list(map(int,input().split()))
for i in range(M):
num = A.index(max(A))
A[num] = A[num] / 2
B = list(map(int,A))
ans = sum(B)
print(ans) | import heapq
import math
I = list(map(int,input().split()))
N = I[0]
M = I[1]
A = list([-x for x in list(map(int,input().split()))])
heapq.heapify(A)
for i in range(M):
num = heapq.heappop(A)
num = math.ceil(num / 2)
heapq.heappush(A,num)
print((-sum(A))) | p02912 |
from sys import stdin
import math
import fractions
n, m = [int(x) for x in stdin.readline().rstrip().split()]
a = [int(x) for x in stdin.readline().rstrip().split()]
a.sort(reverse=True)
for i in range(m):
a[0] = int(a[0]/2)
a.sort(reverse=True)
print((sum(a))) | from sys import stdin
import math
import fractions
import heapq
n, m = [int(x) for x in stdin.readline().rstrip().split()]
a = [int(x) for x in stdin.readline().rstrip().split()]
a = list([x*(-1) for x in a])
heapq.heapify(a)
for i in range(m):
t = heapq.heappop(a)
heapq.heappush(a, (-1)*(-t//2))
print((-sum(a))) | p02912 |
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
A = sorted(A, reverse=True)
#print(A)
for i in range(m):
if i == 0:
A[0] = A[0]//2
else:
list = A[0:i+1]
# print(list)
max_num = max(list)
max_id = list.index(max_num)
A[max_id] = max_num//2
#print(A)
print((sum(A)))
| import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
list = []
maximum = 0
for i in range(n):
num = a[i]*(-1)
heapq.heappush(list,num)
for i in range(m):
maximum = heapq.heappop(list)
if maximum%2 == 0:
maximum = maximum//2
else:
maximum = (maximum//2)+1
heapq.heappush(list,maximum)
# print(list)
ans = 0
minimum = 0
for i in range(n):
minimum = heapq.heappop(list)
minimum = minimum*(-1)
ans = ans + minimum
print(ans)
| p02912 |
N, M = list(map(int, input().split()))
As = list(map(int, input().split()))
for i in range(M):
tmp = max(As)
As.remove(tmp)
tmp = tmp // 2
As.append(tmp)
print((sum(As)))
| N, M = list(map(int, input().split()))
import heapq
As = list([-1 * int(x) for x in input().split()])
heapq.heapify(As)
for i in range(M):
tmp = heapq.heappop(As)
tmp = (-1 * tmp) // 2 * (-1)
heapq.heappush(As, tmp)
print((-1 * sum(As)))
| p02912 |
import bisect
import math
import sys
imput = sys.stdin
N, M = [int(item) for item in input().rstrip().split()]
As = sorted([float(item) for item in input().rstrip().split()])
for i in range(M):
_t = As.pop()
bisect.insort_right(As, _t/2)
_sum = sum([math.floor(item) for item in As])
print(_sum)
| import heapq
N, M = [int(item) for item in input().rstrip().split()]
hp = [-1 * int(item) for item in input().rstrip().split()]
heapq.heapify(hp)
for i in range(M):
_t = heapq.heappop(hp)
heapq.heappush(hp, -1 * (-1 * _t // 2))
_sum = sum([-1 * int(item) for item in hp])
print(_sum)
| p02912 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
import heapq
input=sys.stdin.readline
def resolve():
n,m=list(map(int,input().split()))
A=list([-(int(x)) for x in input().split()])
heapq.heapify(A)
for _ in range(m):
a=heapq.heappop(A)
a=-a
a=a>>1
heapq.heappush(A,-a)
print((-sum(A)))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
from heapq import heapify,heappop,heappush
n,m=list(map(int,input().split()))
A=[-a for a in map(int,input().split())]
heapify(A)
for _ in range(m):
x=-heappop(A)
heappush(A,-(x//2))
print((-sum(A)))
resolve() | p02912 |
from math import ceil
from heapq import heappop,heappush
from collections import deque
N,M = list(map(int,input().split()))
a = list(map(int,input().split()))
a = list([x*(-1) for x in a])
A = []
for a_ in a:
heappush(A,a_)
for _ in range(M):
maxA = ceil(heappop(A)/2)
A.append(maxA)
ans = sum(A)*-1
print(ans) | from math import ceil
from heapq import heappop,heappush
N,M = list(map(int,input().split()))
a = list(map(int,input().split()))
a = list([x*(-1) for x in a])
A = []
for a_ in a:
heappush(A,a_)
for _ in range(M):
maxA = ceil(heappop(A)/2)
A.append(maxA)
print((-sum(A))) | p02912 |
#!/usr/bin/python3
from fractions import Fraction
import heapq
import math
import sys
DEBUG = False
def inp():
return sys.stdin.readline().rstrip()
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def solve(N, M, A):
hq = [-a for a in A]
heapq.heapify(hq)
for _ in range(M):
v = -hq[0]
if v < 1:
break
v = Fraction(v, 2)
heapq.heapreplace(hq, -v)
return sum([math.floor(-v) for v in hq])
def main():
N, M = [int(e) for e in input().split()]
A = [int(e) for e in input().split()]
print(solve(N, M, A))
if __name__ == '__main__':
main()
| #!/usr/bin/python3
import heapq
import math
import sys
DEBUG = False
def inp():
return sys.stdin.readline().rstrip()
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def solve(N, M, A):
hq = [-a for a in A]
heapq.heapify(hq)
for _ in range(M):
v = -hq[0]
if v < 1:
break
v //= 2
heapq.heapreplace(hq, -v)
return sum([math.floor(-v) for v in hq])
def main():
N, M = [int(e) for e in input().split()]
A = [int(e) for e in input().split()]
print(solve(N, M, A))
if __name__ == '__main__':
main()
| p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort(reverse=True)
j=0
for i in range(M):
A[A.index(max(A[:j+1]))]=A[A.index(max(A[:j+1]))]//2
j=j+1
if j==1000:
A.sort(reverse=True)
j=0
print((sum(A))) | N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort(reverse=True)
j=0
for i in range(M):
A[A.index(max(A[:j+1]))]=A[A.index(max(A[:j+1]))]//2
j=j+1
if j==300:
A.sort(reverse=True)
j=0
print((sum(A))) | p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort(reverse=True)
j=0
for i in range(M):
A[A.index(max(A[:j+1]))]=A[A.index(max(A[:j+1]))]//2
j=j+1
if j==250:
A.sort(reverse=True)
j=0
print((sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list([x*(-1) for x in list(map(int,input().split()))])
A.sort()
B=[]
for i in range(N):
heapq.heappush(B,A[i])
for i in range(M):
heapq.heappush(B,(((heapq.heappop(B))*(-1))//2)*(-1))
print(((sum(B))*(-1))) | p02912 |
# 毎回ソートしても別にいいんじゃないの -> ダメでした
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
while m > 0:
arr = list(sorted(arr))
arr[-1] = arr[-1] // 2
m -= 1
print((sum(arr)))
| # 毎回ソートしても別にいいんじゃないの -> ダメでした
# 毎回最大のものがほしいならheapq使うか
import heapq
n, m = list(map(int, input().split()))
# heapは最小のものを取り出すので予め-1をかけて大小を見かけ上逆転しておく
arr = list([int(x) * -1 for x in input().split()])
heapq.heapify(arr)
for _ in range(m):
a = heapq.heappop(arr)
# 負数にしたときの誤差がめんどくさい
a *= -1
a //= 2
heapq.heappush(arr, a * -1)
print((sum(arr) * -1))
| p02912 |
l = list(map(int, input().split()))
prices = list(map(int, input().split()))
for i in range(l[1]):
x = prices.index(max(prices))
prices[x] = int(prices[x] / 2)
print((sum(prices)))
| import heapq
N, M = list(map(int, input().split()))
values = list(map(int, input().split()))
sortedValues = []
for v in values:
heapq.heappush(sortedValues, (-1)*v)
for i in range(M):
heapq.heappush(sortedValues, int((heapq.heappop(sortedValues) * 1/2)))
print(((-1) * sum([heapq.heappop(sortedValues) for i in range(len(sortedValues))])))
| p02912 |
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def main():
N,M = inputMap()
A = inputList()
if len(A) == 1:
print((A[0] // (2**M)))
sys.exit()
A.sort()
A = A[::-1]
ans = 0
A_new = []
mimi = -1
for i in range(1000000000000):
for i,val in enumerate(A):
if i == len(A)-1:
A_new.append(val)
break
if mimi < val and M > 0:
flg = False
for j in range(1,M+1):
if M - j != 0:
tmp = val // (2**j)
if tmp < A[i+1] or tmp < mimi:
M -= j
A_new.append(tmp)
flg = True
if mimi == -1:
mimi = tmp
break
if flg == False:
tmp = val // (2**M)
M = 0
A_new.append(tmp)
else:
A_new.append(val)
#print(A_new)
#A = copy.deepcopy(A_new)
A = A_new
A.sort()
A = A[::-1]
A_new = []
mimi = -1
if M == 0:
break
#print(A)
ans = 0
for i in A:
ans += i
print(ans)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def main():
N,M = inputMap()
A = inputList()
if len(A) == 1:
print((A[0] // (2**M)))
sys.exit()
A.sort()
A = A[::-1]
ans = 0
A_new = []
mimi = -1
for i in range(10000000000000000000):
for i,val in enumerate(A):
if i == len(A)-1:
A_new.append(val)
break
if mimi < val and M > 0:
flg = False
for j in range(1,M+1):
if M - j != 0:
tmp = val // (2**j)
if tmp < A[i+1] or tmp < mimi:
M -= j
A_new.append(tmp)
flg = True
if mimi == -1:
mimi = tmp
break
if flg == False:
tmp = val // (2**M)
M = 0
A_new.append(tmp)
else:
A_new.append(val)
#print(A_new)
#A = copy.deepcopy(A_new)
A = A_new
A.sort()
A = A[::-1]
A_new = []
mimi = -1
if M == 0:
break
#print(A)
ans = 0
for i in A:
ans += i
print(ans)
if __name__ == "__main__":
main()
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for x in range(0, M):
index = A.index(max(A))
A[index] = A[index] // 2
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = [-int(A) for A in input().split()]
heapq.heapify(A)
for x in range(M):
most = -heapq.heappop(A)
most //= 2
heapq.heappush(A, -most)
print((-sum(A))) | p02912 |
import heapq as hq
import math
def discount(price):
return math.ceil(price / 2)
N,M = list(map(int,input().split()))
A = list([int(x)* -1 for x in input().split()])
hq.heapify(A)
for _ in range(M):
a = discount(hq.heappop(A))
hq.heappush(A,a)
print((sum(A)* -1)) | import heapq as hq
import math
N,M = list(map(int,input().split()))
A = list([int(x)* -1 for x in input().split()])
hq.heapify(A)
for _ in range(M):
a = math.ceil(hq.heappop(A) / 2)
hq.heappush(A,a)
print((sum(A)* -1)) | p02912 |
from collections import deque
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
q = deque(a)
count_use = 0
while count_use < m:
max_a = a.pop()
max_a = max_a//2
a.append(max_a)
a.sort()
count_use += 1
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = list([x*(-1) for x in a])
heapq.heapify(a)
count_use = 0
while count_use < m:
max_a = heapq.heappop(a)
max_a = -1*((-1*max_a)//2)
#print(max_a)
heapq.heappush(a, max_a)
count_use += 1
print(((-1)*sum(a))) | p02912 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort(reverse=True)
if N == 1:
print((A[0]//(2**M)))
else:
for i in range(M):
A[0] = A[0]//2
j = 0
while(A[j]<A[j+1]):
t = A[j]
A[j] = A[j+1]
A[j+1] = t
j += 1
if j == N-1:
break
print((sum(A))) | import sys
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort(reverse=True)
m = A[0]
seg = [1]
t = 1
while(True):
t *= 2
if t > m:
break
seg.append(t)
c = 0
for i in range(-1,-len(seg)-1,-1):
for j in range(N):
if A[j] < seg[i]:
break
A[j] = A[j]//2
c += 1
if c == M:
print((sum(A)))
sys.exit()
A.sort(reverse=True)
print((sum(A))) | p02912 |
n, m = (int(x) for x in input().split())
a = [int(x) for x in input().split()]
for _ in range(m):
idx = a.index(max(a))
a[idx] //= 2
print((sum(a))) | import heapq as hp
n, m = (int(x) for x in input().split())
a = [int(x)*(-1) for x in input().split()]
hp.heapify(a)
for _ in range(m):
min = hp.heappop(a)
hp.heappush(a, (-1)*(-min//2))
print((-sum(a))) | p02912 |
import heapq
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n) :
a[i] *= -1
for i in range(m) :
heapq.heapify(a)
at = -1*(-1*heapq.heappop(a)//2)
heapq.heappush(a, at)
print((sum(a)*-1)) | import heapq
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n) :
a[i] *= -1
heapq.heapify(a)
for i in range(m) :
at = -1*(-1*heapq.heappop(a)//2)
heapq.heappush(a, at)
print((sum(a)*-1)) | p02912 |
# -*- coding: utf-8 -*-
import heapq
num_product, num_coupon = [int(s) for s in input().split()]
price_list = []
for s in input().split():
heapq.heappush(price_list, int(s))
for i in range(num_coupon):
max_price = max(price_list)
for j in range(len(price_list)):
if price_list[j] == max_price:
price_list[j] //= 2
break
sum = 0
for price in price_list:
sum += price
print(sum) | # -*- coding: utf-8 -*-
import heapq
num_product, num_coupon = [int(s) for s in input().split()]
price_list = []
for s in input().split():
heapq.heappush(price_list, int(s)*-1)
for i in range(num_coupon):
min = price_list[0]
heapq.heapreplace(price_list, (min*-1//2)*-1)
sum = 0
for price in price_list:
sum -= price
print(sum) | p02912 |
n,m=list(map(int, input().split()))
a=list(map(int, input().split()))
for i in range(m):
j=a.index(max(a))
a[j]=a[j]//2
print((sum(a))) | '''
標準入力
4 4
1 9 3 5
'''
n,m=list(map(int, input().split()))
a=list(map(int, input().split()))
b=[-a[i] for i in range(n)]
#print(b) => [-1, -9, -3, -5]
import heapq
heapq.heapify(b)
#print(b) => [-9, -5, -3, -1]
for i in range(m):
maximum=heapq.heappop(b)
#forなしでprint(maximum) => -9
maximum=-(-maximum//2)
heapq.heappush(b,maximum)
print(((sum(b))*(-1))) | p02912 |
import sys
input = sys.stdin.readline
n,m = list(map(int, input().split(' ')))
a_list = list(map(int, input().split(' ')))
for i in range(m):
p = max(a_list)
a_list.remove(p)
a_list.append(p // 2)
print((sum(a_list))) | import sys
import heapq
input = sys.stdin.readline
n,m = list(map(int, input().split(' ')))
a_list = [-1 * int(i) for i in input().split() ]
heapq.heapify(a_list)
for _ in range(m):
p = heapq.heappop(a_list)
q = (-1*p //2) * (-1)
heapq.heappush(a_list, q)
print((-sum(a_list))) | p02912 |
import sys
input = sys.stdin.readline
import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(n):
a[i]=-a[i]
for i in range(m):
heapq.heapify(a)
heapq.heappush(a,-(-heapq.heappop(a)//2))
print((-sum(a)))
| import sys
input = sys.stdin.readline
import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(n):
a[i]=-a[i]
heapq.heapify(a)
for i in range(m):
c=-(-heapq.heappop(a)//2)
heapq.heappush(a,c)
#print(a)
print((-sum(a)))
| p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(M):
A[A.index(max(A))]=A[A.index(max(A))]//2
print((sum(A)))
| import heapq
N, M = list(map(int, input().split()))
A = list([-int(x) for x in input().split()])
heapq.heapify(A)
ans = 0
for i in range(M):
most_expensive = -heapq.heappop(A)
most_expensive //= 2
heapq.heappush(A, -most_expensive)
print((-sum(A))) | p02912 |
import sys
from bisect import bisect_left,bisect
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
A=sorted(A)
if len(A)>10**5:
Al=A[-10**5:]
Af=A[:-10**5]
for i in range(m):
Al.insert(bisect_left(Al,max(Al)//2),max(Al)//2)
del Al[n]
print((sum(Al)+sum(Af)))
else:
for i in range(m):
A.insert(bisect_left(A,max(A)//2),max(A)//2)
del A[n]
print((sum(A)))
| import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a = list([x*(-1) for x in a]) # 各要素を-1倍
heapq.heapify(a)
for i in range(m):
minimum=heapq.heappop(a)
mini=((minimum*(-1))//2)*(-1)
heapq.heappush(a,mini)
print((-sum(a)))
| p02912 |
import bisect
N,M=list(map(int,input().split()))
la=list(map(int,input().split()))
la.sort()
for i in range(M):
#la.sort()
#la[N-1]/=2
ll=la[N-1]/2
la.pop()
#la.insert(nibutan(0,N-2,la,ll),ll)
bisect.insort_left(la,ll,0,N-1)
ans=0
for i in range(N):
ans+=int(la[i])
print(ans)
| import heapq
N,M=list(map(int,input().split()))
la=list([-int(x) for x in input().split()])
heapq.heapify(la)
#la.sort()
for i in range(M):
ll=heapq.heappop(la)/2
heapq.heappush(la,ll)
ans=0
for i in range(N):
ans+=int(-heapq.heappop(la))
print(ans)
| p02912 |
import sys
import heapq
def input():
return sys.stdin.readline().rstrip()
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
AA = []
for i in range(N):
heapq.heappush(AA, A[i] * (-1))
for i in range(M):
maxaa = -1 * heapq.heappop(AA)
if max(A) == 0:
print("0")
exit()
heapq.heappush(AA, maxaa // 2 * (-1))
print((sum(AA) * (-1)))
if __name__ == '__main__':
main()
| import sys
import heapq
def input():
return sys.stdin.readline().rstrip()
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(N):
A[i] *= -1
heapq.heapify(A)
for i in range(M):
maxa = -1 * heapq.heappop(A)
if maxa == 0:
print("0")
exit()
heapq.heappush(A, maxa // 2 * (-1))
print((sum(A) * (-1)))
if __name__ == '__main__':
main()
| p02912 |
N,M = list(map(int,input().split()))
lst = list(map(int,input().split()))
for i in range(M):
lst[lst.index(max(lst))] = max(lst) // 2
print((sum(lst)))
| import heapq
N,M = list(map(int,input().split()))
#lst = list(map(int,input().split()))
lst = [-int(x) for x in input().split()]
heapq.heapify(lst)
for i in range(M):
lstmin = heapq.heappop(lst)
b = (-(lstmin) // 2)
heapq.heappush(lst,-b)
print((-sum(lst))) | p02912 |
import heapq
n,m = list(map(int,input().split()))
prod = list(map(int,input().split()))
prod = list([x*(-1) for x in prod])
heapq.heapify(prod)
for _ in range(m):
a = heapq.heappop(prod)*(-1)
a = a//2
heapq.heappush(prod,(-1)*a)
ans = list([(-1)*x for x in prod])
print((sum(ans))) | n,m=list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(n):
a[i]*=-1
import heapq,math
heapq.heapify(a)
for _ in range(m):
b=heapq.heappop(a)*(-1)
b //=2
heapq.heappush(a,b*(-1))
print((sum(a)*(-1))) | p02912 |
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
for x in range(M):
A[0] = A[0] // 2
A = sorted(A, reverse=True)
print((sum(A)))
| import heapq
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
A = list([x * (-1) for x in A])
heapq.heapify(A)
for x in range(M):
maxA = heapq.heappop(A)
heapq.heappush(A, -1 * ((-1 * maxA) // 2))
A = list([x * (-1) for x in A])
print((sum(A)))
| p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(0,M):
m=max(A)
index=A.index(m)
A[index]=m//2
print((sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[-A[i] for i in range(0,N)]
heapq.heapify(A)
for i in range(0,M):
m=(-1)*heapq.heappop(A)
m=m//2
m=-m
heapq.heappush(A,m)
print(((-1)*sum(A))) | p02912 |
N, M = list(map(int, input().split()))
A = [int(x) for x in input().split()]
for i in range(M):
A[A.index(max(A))] = A[A.index(max(A))]//2
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = [-int(x) for x in input().split()]
heapq.heapify(A)
for i in range(M):
heapq.heappush(A,-(-heapq.heappop(A)//2))
print((-sum(A))) | p02912 |
import heapq
import math
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
q = []
heapq.heapify(q)
for i in range(n):
heapq.heappush(q, -a[i])
for _ in range(m):
b = heapq.heappop(q) / 2
heapq.heappush(q, math.ceil(b))
print((sum(q) * -1))
| import sys
from heapq import heapify, heappop, heappush
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
A = list([int(x) * (-1) for x in input().split()])
heapify(A)
for _ in range(m):
a = (heappop(A) * (-1)) // 2
heappush(A, a * (-1))
print((sum(A) * (-1)))
if __name__ == '__main__':
resolve()
| p02912 |
n,m = list(map(int,input().split()))
a =list(map(int,input().split()))
b = sorted(a,reverse=True)
for i in range(m):
max_b = b[0]
b.pop(0)
b.append(max_b//2)
b = sorted(b,reverse = True)
print((sum(b))) | # -*- coding: utf-8 -*-
import heapq
# input
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
# solve
ans = [-a for a in A]
heapq.heapify(ans)
for i in range(M):
tmp = heapq.heappop(ans) * (-1) // 2
heapq.heappush(ans, tmp * (-1))
ans = [-a for a in ans]
# output
print((sum(ans)))
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
while M > 0:
max_index = A.index(max(A))
A[max_index] = A[max_index] // 2
M -= 1
print((sum(A)))
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
while M > 0:
A.sort(reverse=True)
if A[0] == 0:
break
ham = A[0] // 2
for i, a in enumerate(A):
if ham < a and M > 0:
A[i] = A[i] // 2
M -= 1
else:
break
print((sum(A)))
| p02912 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
while M>0:
A[A.index(max(A))] /= 2
M -= 1
ans = 0
for i in A:
ans += int(i)
print(ans)
| import heapq
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
B = []
for i in A:
B.append(-i)
heapq.heapify(B)
for i in range(M):
tmp = heapq.heappop(B)
heapq.heappush(B,-1*(-tmp//2))
print((-sum(B)))
| p02912 |
from collections import deque
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = deque(sorted(A, reverse=True))
for _ in range(M):
x = A.popleft()//2
for i, a in enumerate(A):
if x >= a:
A.insert(i, x)
break
else:
A.append(x)
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = list([-int(x) for x in input().split()])
heapq.heapify(A)
for _ in range(M):
heapq.heappush(A, (-((-heapq.heappop(A))//2)))
print((-sum(A))) | p02912 |
import heapq as hq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
def heapSort(i):
h = []
for v in i:
hq.heappush(h, v)
return [hq.heappop(h) for i in range(len(h))]
for i in range(m):
a = heapSort(a)
a[n-1] //= 2
print((sum(a))) | import heapq as hq
n, m = list(map(int, input().split()))
a = [-int(i) for i in input().split()]
hq.heapify(a)
for i in range(m):
minprice = hq.heappop(a)
hq.heappush(a, (-minprice // 2) * -1)
print((-sum(a))) | p02912 |
N,M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
A.sort(reverse=True)
for i in range(M):
if i == 0:
A[0] = A[0]//2
else:
temp = A[0]
idx = 0
j = 0
while j < N and j <= i:
if temp < A[j]:
temp = A[j]
idx = j
j += 1
A[idx] = A[idx]//2
print((sum(A))) | N,M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
import heapq
h = []
for i in range(N):
heapq.heappush(h, A[i]*(-1))
for i in range(M):
temp = heapq.heappop(h)
temp *= (-1)
temp //= 2
temp *= (-1)
heapq.heappush(h, temp)
print((sum(h)*(-1))) | p02912 |
import heapq
N,M=list(map(int,input().split()))
A=list(map(int, input().split()))
for i in range (0,len(A)):
A[i]*=(-1)
heapq.heapify(A)
def chaep(n):
n=int(n/2)
return n
i=0
while(i<M):
tmp=heapq.heappop(A)
tmp=chaep(tmp)
heapq.heappush(A,tmp)
i+=1
ans=0
for i in range (0,N):
ans+=A[i]
print((ans*(-1))) | import heapq
N,M=list(map(int,input().split()))
A=list(map(int, input().split()))
for i in range (0,len(A)):
A[i]*=(-1)
heapq.heapify(A)
def chaep(n):
n=int(n/2)
return n
i=0
while(i<M):
tmp=heapq.heappop(A)
tmp=chaep(tmp)
heapq.heappush(A,tmp)
i+=1
print((-sum(A))) | p02912 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
for i in range(M):
A.sort()
A[len(A)-1] = A[len(A)-1] // 2
print((sum(A))) | import heapq
N,M = list(map(int, input().split()))
A = list([-int(x) for x in input().split()])
heapq.heapify(A)
ans = 0
for i in range(M):
most_expensive = -heapq.heappop(A)
most_expensive //= 2
heapq.heappush(A, -most_expensive)
print((-sum(A))) | p02912 |
#import numpy as np
import sys
input = sys.stdin.readline
N,M = [int(a) for a in input().split()]
A = [int(a) for a in input().split()]
for i in range(M):
m = max(A)
A[A.index(m)] //= 2
print((sum(A))) | import sys
import heapq
from math import ceil
input = sys.stdin.readline
N,M = [int(a) for a in input().split()]
A = [int(a) for a in input().split()]
hq = []
for i in range(N):
heapq.heappush(hq, -A[i])
for i in range(M):
m = heapq.heappop(hq)
heapq.heappush(hq, ceil(m / 2))
print((-sum(hq))) | p02912 |
n,m=list(map(int,input().split()))
l=list(map(int,input().split()))
for i in range(m):
max=l[0]
index=0
for j in range(n):
if max<l[j]:
max=l[j]
index=j
l[index]=max//2
sum=0
for i in range(n):
sum+=l[i]
print(sum) | n,m=list(map(int,input().split()))
l=list(map(int,input().split()))
import heapq
q=[]
for i in l:
heapq.heappush(q,-i)
for i in range(m):
num=heapq.heappop(q)
if num%2==0:
num=num//2
else:
num=num//2+1
heapq.heappush(q,num)
sum=0
for i in range(n):
sum+=-q[i]
print(sum) | p02912 |
import bisect
n, m = list(map(int,input().split()))
a = sorted(list(map(float, input().split())))
for i in range(m):
atop = a.pop()
bisect.insort_left(a,atop/2)
print((sum([int(i) for i in a]))) | import heapq
n, m = list(map(int,input().split()))
a = [-int(i) for i in input().split()]
heapq.heapify(a)
for i in range(m):
heapq.heappush(a,heapq.heappop(a)/2)
print((sum([int(i) for i in a])*-1)) | p02912 |
n,m = list(map(int,input().split()))
price = list(map(int,input().split()))
for i in range(m):
price[price.index(max(price))] //= 2
print((sum(price))) | import math # factorical（階乗) # hypot(距離)
import heapq
# from fractions import gcd # Python3.5以前 # lcm（最小公倍数） = (a*b)//gcd(a,b)
# from fractions import Fraction
# from math import gcd # Python3.6以降
# --------------------------------------------------------------
n,m = list(map(int,input().split()))
price = list(map(int,input().split()))
price = [-i for i in price]
heapq.heapify(price)
for i in range(m):
sm = heapq.heappop(price)
sm = -(-sm//2)
heapq.heappush(price,sm)
price = [-i for i in price]
print((sum(price))) | p02912 |
n, m = list(map(int, input().split()))
a = [int(_) for _ in input().split()]
for _ in range(m):
maxvalue = max(a)
maxindex = a.index(maxvalue)
a[maxindex] = maxvalue / 2
print((sum([int(_) for _ in a])))
| import heapq
n, m = list(map(int, input().split()))
a = [int(_) for _ in input().split()]
que = []
for _ in a:
heapq.heappush(que, -1*_)
for _ in range(m):
maxvalue = -1 * heapq.heappop(que)
maxvalue /= 2
heapq.heappush(que, -1*maxvalue)
print((sum([int(-1*_) for _ in que])))
| p02912 |
import bisect as b
import math
n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
for _ in range(m):
half = a.pop(-1) / 2
a.insert(b.bisect_left(a, half), half)
print((sum(list([math.floor(x) for x in a]))))
| import heapq
import math
n, m = list(map(int, input().split()))
a = list([int(x) * (-1) for x in input().split()])
heapq.heapify(a)
for _ in range(m):
heapq.heappush(a, math.ceil(heapq.heappop(a) / 2))
print((-sum(a)))
| p02912 |
n, m = list(map(int, input().split()))
list_A = list(map(int, input().split()))
for i in range(m):
list_A = sorted(list_A)
list_A[-1] = int(list_A[-1]/2)
# print(i, j, list_A[j])
print((sum(list_A))) | import heapq as hp
n, m = list(map(int, input().split()))
list_A = list(map(int, input().split()))
# list_A = sorted(list_A)
a_q = []
for i in list_A:
hp.heappush(a_q, -1*i)
for i in range(m):
tmp = hp.heappop(a_q)
tmp = hp.heappush(a_q, int(tmp/2))
print((-sum(a_q))) | p02912 |
# coding: utf-8
# Your code here!
import bisect
N, M = list(map(int, input().rstrip().split()))
A = list(map(int, input().rstrip().split()))
A = sorted(A)
for _ in range(M):
a = A.pop()
a = a / 2
bisect.insort_right(A, a)
print((sum([int(x) for x in A])))
| # coding: utf-8
# Your code here!
import heapq
N, M = list(map(int, input().rstrip().split()))
A = list([-int(x) for x in input().rstrip().split()])
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
a = a / 2
heapq.heappush(A, a)
print((sum([-int(x) for x in A])))
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(M):
temp = A.index((max(A)))
tempM = M
while temp == A.index((max(A))):
if tempM > M:
break
A[A.index((max(A)))] //= 2
M -= 1
print((sum(A)))
| import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = list([x * (-1) for x in a])
heapq.heapify(a)
while m != 0:
price = heapq.heappop(a) * (-1)
price //= 2
m -= 1
heapq.heappush(a, (-1) * price)
print((sum(a) * (-1)))
| p02912 |
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = list([-x for x in A])
heapq.heapify(A)
while M > 0:
heapq.heappush(A, -(-heapq.heappop(A) // 2))
M -= 1
print((-sum(A)))
| import heapq
def f(str):
return -int(str)
N, M = list(map(int, input().split()))
A = list(map(f, input().split()))
heapq.heapify(A)
while M > 0:
heapq.heappush(A, -(-heapq.heappop(A) // 2))
M -= 1
print((-sum(A)))
| p02912 |
import sys, bisect
def main():
_,M,*A = list(map(int, open(0).read().split()))
A.sort()
for _ in range(M):
a = int(A.pop() / 2)
bisect.insort_left(A,a)
print((sum(A)))
if __name__=='__main__':
main() | import sys
from heapq import heappush, heappop
def main():
_,M,*A = list(map(int, open(0).read().split()))
A = [-x for x in A] # reverse max to min
A.sort()
for _ in range(M):
a = int(heappop(A) / 2)
heappush(A, a)
print((-sum(A)))
if __name__=='__main__':
main() | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(m):
max_a = max(a)
a.append(max_a / 2)
a.remove(max_a)
res_list = [int(_) for _ in a]
print((sum(res_list))) | import heapq
n, m = list(map(int, input().split()))
a = [-int(_) for _ in input().split()]
heapq.heapify(a)
for i in range(m):
tmp = heapq.heappop(a)
a.append(tmp / 2)
res_list = [int(-_) for _ in a]
print((sum(res_list))) | p02912 |
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(m):
v = max(a)//2
a[a.index(max(a))] = v
print((sum(a))) | import heapq
n,m = list(map(int,input().split()))
a = list([int(x)*(-1) for x in input().split()])
heapq.heapify(a)
for i in range(m):
maxv = heapq.heappop(a)*(-1)
heapq.heappush(a,(maxv//2)*(-1))
print((sum(a)*(-1))) | p02912 |
import heapq as hq
n,m=list(map(int,input().split()))
a=list([-int(x) for x in input().split()])
hq.heapify(a)
for i in range(m):v=-hq.heappop(a);hq.heappush(a,-(v//2))
print((-sum(a))) | import heapq as hq
n,m=input().split()
hq.heapify(a:=[-int(x) for x in input().split()])
for i in range(int(m)):hq.heappush(a,-(v:=-hq.heappop(a)//2))
print((-sum(a))) | p02912 |
from math import floor
from bisect import insort_left
n, m = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
for i in range(m):
a = l.pop(-1)
a /= 2
insort_left(l, a)
ans = 0
for i in range(n):
ans += floor(l[i])
print(ans) | import heapq
n, m = list(map(int, input().split()))
l = list(map(int, input().split()))
l = [-x for x in l]
heapq.heapify(l)
for i in range(m):
a = heapq.heappop(l)
heapq.heappush(l, a / 2)
print((-sum(int(x) for x in l))) | p02912 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = [int(x) for x in input().split()]
m_idx = A.index(max(A))
for _ in range(M):
A[A.index(max(A))] //= 2
print((sum(A))) | import sys
import heapq
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = []
for x in input().split():
heapq.heappush(A, int(x) * (-1))
for _ in range(M):
max_n = heapq.heappop(A) * (-1)
heapq.heappush(A, (max_n // 2) * (-1))
print((sum(A) * (-1))) | p02912 |
# D - Powerful Discount Tickets
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
for i in range(M):
mx = A.index(max(A))
A[mx] = A[mx] // 2
print((sum(A)))
| # D - Powerful Discount Tickets
import heapq
N, M = list(map(int, input().split()))
A = [int(a) * -1 for a in input().split()]
heapq.heapify(A)
for i in range(M):
price = heapq.heappop(A)
price = -1 * ((-1 * price) // 2)
heapq.heappush(A, price)
print((sum(A) * -1))
| p02912 |
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(m):
a[a.index(max(a))]//=2
print((sum(a)))
| import heapq
n,m=list(map(int,input().split()))
a=[-int(x) for x in input().split()]
heapq.heapify(a)
for i in range(m):
t=heapq.heappop(a)
t=-t//2
heapq.heappush(a,-t)
print((-sum(a)))
| p02912 |
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())),reverse = True)
while M > 0:
A[0] //= 2
for i in range(1,M):
if i < N and A[i] >= A[0]:
A[i] //= 2
else:
M -= i
A.sort(reverse = True)
break
else:
break
print((sum(A)))
| import heapq
N,M = list(map(int,input().split()))
A = [-i for i in map(int,input().split())]
heapq.heapify(A)
for i in range(M):
a = (-(heapq.heappop(A)))//2
heapq.heappush(A,-a)
print((-sum(A))) | p02912 |
n,m = list(map(int,input().split()))
a = sorted(list(map(int,input().split())),reverse=True)
for i in range(m):
a[0] = a[0]/2
a = sorted(a,reverse=True)
print((sum(list(map(int,a))))) | def main():
import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
heap = []
for i in range(n):
heapq.heappush(heap,-1*a[i])
for i in range(m):
a = int(heapq.heappop(heap)/2)
heapq.heappush(heap,a)
print((-1*sum(heap)))
if __name__ == "__main__":
main() | p02912 |
def main():
import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
heap = []
for i in range(n):
heapq.heappush(heap,-1*a[i])
for i in range(m):
a = int(heapq.heappop(heap)/2)
heapq.heappush(heap,a)
print((-1*sum(heap)))
if __name__ == "__main__":
main() | def main():
import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
A = []
for i in range(n):
heapq.heappush(A,-1*a[i])
for i in range(m):
a = heapq.heappop(A)
a = (-1*a)//2
heapq.heappush(A,-1*a)
print((-1*sum(A)))
if __name__ == "__main__":
main()
| p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
sum=0
for m in range(M):
A[A.index(max(A))]//=2
for a in A:
sum+=a
print(sum) | import heapq
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
sum=0
A=[-1 * i for i in A]
heapq.heapify(A)
for m in range(M):
rep=-(-heapq.heappop(A)//2)
heapq.heappush(A,rep)
for a in A:
sum-=a
print(sum) | p02912 |
n=list(map(int,input().split()))
m=list(map(int,input().split()))
maxm=sum(m)
for i in range(n[1]):
m[m.index(max(m))]=m[m.index(max(m))]//2
print((sum(m))) | import heapq
n=list(map(int,input().split()))
m=list(map(int,input().split()))
m = [-x for x in m]
heapq.heapify(m)
for i in range(n[1]):
x=(-1*m[0])//2
heapq.heappop(m)
heapq.heappush(m, -x)
ans=0
for i in range(n[0]):
ans+=-m[i]
print(ans) | p02912 |
n,m = list(map(int,input().split()))
price_list = sorted(list(map(int,input().split())),reverse = True)
for i in range(m):
n = max(price_list)
price_list.remove(n)
price_list.append(n//2)
print((sum(price_list))) | import heapq
n,m = list(map(int,input().split()))
price_list =list([-int(x) for x in input().split()])
heapq.heapify(price_list)
for i in range(m):
dis = heapq.heappop(price_list)
heapq.heappush(price_list, -(-dis//2))
print((-1*sum(price_list))) | p02912 |
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
for i in range(m):
a = A[-1]//2
A = A[:-1]
A.append(a)
A = sorted(A)
print((sum(A))) | n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
import heapq
A = list([x*(-1) for x in A])
heapq.heapify(A)
for i in range(m):
val = heapq.heappop(A)
val = (-1 * val)//2 * (-1)
heapq.heappush(A, val)
print((sum(list([x*(-1) for x in A])))) | p02912 |
N, M = list(map(int, input().split()))
Am = list(map(int, input().split()))
A = sorted(Am, reverse=True)
A.append(0)
for m in range(M):
a = int(A[0] / 2)
n = 0
while A[n + 1] > a and n < N - 1:
n += 1
del A[0]
A.insert(n,a)
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
Am=[-a for a in A]
heapq.heapify(Am)
for m in range(M):
a = int(heapq.heappop(Am) / 2)
heapq.heappush(Am, a)
print((-sum(Am))) | p02912 |
import math
# 入力の取得(1行目。数値)
i = list(map(int, input().split()))
# 変数セット
# 1.購入する品物の数
itemCount = i[0]
# 2.割引券の数
discountTicketsCount = i[1]
# 入力の取得(2行目。数値)
priceList = list(map(int, input().split()))
# 割引件数分ループ
for i in range(discountTicketsCount):
# 全アイテムに対して、割引券を使った場合の試算を行う
discountPrice = 0
shouldUseItem = 0
for idx , price in enumerate(priceList):
# 割引券使用による割引金額を取得
workDiscountPrice = math.ceil(price - (price / 2))
# 最も割引金額が多い場合、候補として変数に格納
if workDiscountPrice > discountPrice:
discountPrice = workDiscountPrice
shouldUseItem = idx
# 割引金額が最大の品物に割引券を使用
priceList[shouldUseItem] -= discountPrice
# 合計金額を出力
print((sum(priceList)))
| import math
import heapq
# 入力の取得(1行目。数値)
i = list(map(int, input().split()))
# 変数セット
# 1.購入する品物の数
itemCount = i[0]
# 2.割引券の数
discountTicketsCount = i[1]
# 入力の取得(2行目。数値)
priceList = list(map(int, input().split()))
# 「符号反転した」リストを優先度付きキューに変換
# ★ポイント★
# heapqは最小値しか取り出せないため、
# 符号反転してからキューに変換=>最小値を取る、という手法を行う。
priceList = [ n * -1 for n in priceList]
heapq.heapify(priceList)
# 割引件数分ループ
for i in range(discountTicketsCount):
# キューから最小値の取り出し(ここで符号反転も行っておく)
target = abs(heapq.heappop(priceList))
# 2で割る。(小数点切り下げ)
target = math.floor(target / 2)
# 割引券利用後の金額をキューに格納(ここで符号反転する)
heapq.heappush(priceList, target * -1)
# 合計金額を出力
print((abs(sum(priceList)))) | p02912 |
import math
n, m = list(map(int, input().split(" ")))
aL = list(map(int, input().split(" ")))
d = {}
for i, a in enumerate(aL):
if a in d:
d[a].append(i)
else:
d[a] = [i]
cnt = 0
while True:
if len(d) == 0:
break
dMax = max(d)
while True:
if cnt == m:
ans = 0
for k, v in list(d.items()):
ans += k * len(v)
print(ans)
exit()
nxt = d[dMax].pop(0)
if (dMax // 2) in d:
d[dMax // 2].append(nxt)
else:
d[dMax // 2] = [nxt]
cnt += 1
if len(d[dMax]) == 0:
del d[dMax]
break
ans = 0
for k, v in list(d.items()):
ans += k * len(v)
print(ans) | import heapq
n, m = list(map(int, input().split()))
aL = list([int(x) * (-1) for x in input().split(" ")])
heapq.heapify(aL)
for i in range(m):
a = heapq.heappop(aL)
a = int(a / 2)
heapq.heappush(aL, a)
print((int(sum(aL) * -1)))
| p02912 |
import bisect
N, M = list(map(int, input().split()))
A = sorted(map(int, input().split()))
for _ in range(M):
x = A.pop()
y = x // 2
i = bisect.bisect_left(A, y)
A.insert(i, y)
ans = sum(A)
print(ans) | import heapq
N, M = list(map(int, input().split()))
A = [-a for a in map(int, input().split())]
heapq.heapify(A)
for _ in range(M):
x = -heapq.heappop(A)
heapq.heappush(A, -(x // 2))
ans = -sum(A)
print(ans) | p02912 |
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort(reverse=True)
for i in range(M):
# idx = A.index(max(A))
# A[idx] //= 2
idx = A.index(max(A[:i+1]))
A[idx] //= 2
print((sum(A))) | import heapq
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
A_minus = [-int(a) for a in A]
heapq.heapify(A_minus)
for _ in range(M):
tmp = -heapq.heappop(A_minus)
tmp //= 2
heapq.heappush(A_minus, -tmp)
print((-sum(A_minus))) | p02912 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.