input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,m=list(map(int,input().split()))#n:num m:ticket
a=[int(_) for _ in input().split()]
for i in range(m):
a[a.index(max(a))]=max(a)//2
print((sum(a))) | from heapq import heapify,heappop,heappush
n,m=list(map(int,input().split()))#n:num m:ticket
a=[-int(_) for _ in input().split()]
heapify(a)
for i in range(m):
num=heappop(a)*-1
heappush(a,(num//2)*-1)
print((sum(a)*-1)) | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
while m > 0:
M = max(a)
tmp = a.index(M)
a[tmp] = a[tmp] // 2
m -= 1
print((sum(a)))
| import heapq
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
pq = []
for a in A:
heapq.heappush(pq, -a)#'-'にすることで最大値を考えることができる！
#print(pq)
for _ in range(m):
a = (-heapq.heappop(pq)) // 2
heapq.heappush(pq, -a)
print((-sum(pq))) | p02912 |
import math
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
for i in range(len(a)):
a[i] = math.floor(a[i])
print((sum(a))) | from heapq import heappop, heappush, heapify
N, M = list(map(int,input().split()))
A = list(map(int, input().split()))
A = list([x*(-1) for x in A])
heapify(A)
for i in range(M):
temp = int(heappop(A)/2)
heappush(A, temp)
print((-sum(A))) | p02912 |
import sys
n,m = list(map(int,input().split()))
lst_a = list(map(int,input().split()))
lst_a.sort(reverse=True)
temp = 0
ans = 0
if n == 1:
for i in range(m):
lst_a[0] //= 2
print((lst_a[0]))
sys.exit()
for i in range(m):
if lst_a[0] >= lst_a[1]:
lst_a[0] //= 2
else:
lst_a[1] //= 2
lst_a.sort(reverse=True)
print((sum(lst_a)))
| import sys
n,m = list(map(int,input().split()))
lst_a = list(map(int,input().split()))
temp = 0
cnt = 0
fin = 0
loop = 0
debug = 0
temp2 = 0
if n == 1:
for i in range(m):
lst_a[0] //= 2
print((lst_a[0]))
sys.exit()
while debug < 10:
loop = 0
#temp2 = temp
temp = 0
lst_a.sort(reverse=True)
while loop < n-1:
lst_a[loop] //= 2
cnt += 1
temp = max(temp,lst_a[loop])
if cnt == m:
#print(lst_a)
print((sum(lst_a)))
sys.exit()
if temp > max(lst_a[loop],lst_a[loop + 1]):
break
if lst_a[loop + 1] > lst_a[loop]:
loop += 1
""" if lst_a[loop] >= max(lst_a[loop + 1],temp):
lst_a[loop] //= 2
temp = max(lst_a[loop],lst_a[loop+1])
cnt += 1
if cnt == m:
print(sum(lst_a))
sys.exit()
if temp > lst_a[loop + 1]:
break
loop += 1
#debug += 1
print(lst_a[99999])
# print(temp)
# print(cnt)
# print(lst_a)
# print(sum(lst_a))
""" | p02912 |
import math
import copy
from queue import Queue
#n = int(input())
n, m = [int(i) for i in input().split()]
#table = [[int(i) for i in input().split()] for j in range(n)]
#table = [list(input()) for n in range(h)]
s = [int(i) for i in input().split()]
#s = [int(i) for i in range(n)]
#s = [int(input()) for i in range(n)]
#s = input()
#list = list(s)
# dp = [[0 for _ in range(2)] for _ in range(13)]
#a = [[0 for _ in range(n+1)] for _ in range(n+1)]
#b = [[0 for _ in range(n+1)] for _ in range(n+1)]
for i in range(m) :
s[s.index(max(s))] = math.floor(max(s)/2)
print((sum(s))) | import math
import copy
from queue import Queue
import heapq
#n = int(input())
n, m = [int(i) for i in input().split()]
#table = [[int(i) for i in input().split()] for j in range(n)]
#table = [list(input()) for n in range(h)]
s = [int(i) for i in input().split()]
#s = [int(i) for i in range(n)]
#s = [int(input()) for i in range(n)]
#s = input()
#list = list(s)
# dp = [[0 for _ in range(2)] for _ in range(13)]
#a = [[0 for _ in range(n+1)] for _ in range(n+1)]
#b = [[0 for _ in range(n+1)] for _ in range(n+1)]
s = list([x*(-1) for x in s])
heapq.heapify(s)
for i in range(m) :
heapq.heappush(s, math.ceil(heapq.heappop(s)/2))
print((sum(s)*(-1))) | p02912 |
def insertion_sort(array):
n = array[0]
for i in range(1, len(array)):
tmp = array[i]
if array[i] <= n :
break
else:
array[i-1] = tmp
array[i] = n
return array
n,m = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
a.sort(reverse=True)
for i in range(m):
down = a[0]
a.remove(down)
a.insert(0,down//2)
a = insertion_sort(a)
print((sum(a)))
| n,m = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = []
a.sort(reverse=True)
for i in range(m):
if i == 0:
down = a[0]
a.remove(down)
b.append(down//2)
else:
if a != [] and a[0] >= b[0]:
down = a[0]
a.remove(down)
else:
down = b[0]
b.remove(down)
b.append(down//2)
print((sum(a)+sum(b))) | p02912 |
n, m = list(map(int, input().split()))
*a, = sorted(map(int, input().split()), key=lambda x: -x)
for i in range(m):
tmp = a.pop(0)
tmp //= 2
if not a:
a.append(tmp)
for j in range(min(len(a), m-i)):
if tmp > a[j]:
a.insert(j, tmp)
break
else:
a.append(tmp)
print((sum(a))) | import heapq, math
n, m = list(map(int, input().split()))
*a, = [-int(x) for x in input().split()]
heapq.heapify(a)
for i in range(m):
tmp = heapq.heappop(a)
tmp = math.ceil(tmp / 2)
heapq.heappush(a, tmp)
print((-sum(a))) | p02912 |
import bisect
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
for i in range(M):
tmp = A.pop(-1) // 2
index = bisect.bisect_left(A, tmp)
A.insert(index, tmp)
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 = int(heapq.heappop(A) / 2)
heapq.heappush(A, tmp)
print((sum(A) * -1)) | p02912 |
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 = int(heapq.heappop(A) / 2)
heapq.heappush(A, tmp)
print((sum(A) * -1)) | 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, (heapq.heappop(A) + 1) // 2)
print((sum(A) * -1)) | p02912 |
import bisect
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
while M != 0:
x = bisect.bisect_left(A,A[-1]/2)
if N-x <= M:
M -= N-x
for i in range(x,N):
A[i] = A[i]/2
A.sort()
else:
for i in range(N-M,N):
A[i] = A[i]/2
M = 0
A.sort()
print((sum(map(int,A))))
| #二分探索を使った解法
import bisect
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
while M != 0:
x = bisect.bisect_left(A,A[-1]//2)
if N-x <= M:
M -= N-x
for i in range(x,N):
A[i] = A[i]//2
A.sort()
else:
for i in range(N-M,N):
A[i] = A[i]//2
M = 0
A.sort()
print((sum(A))) | p02912 |
#Priority Queueを使った解法
import heapq
N,M = list(map(int,input().split()))
A = list([(-1)*int(x) for x in input().split()])
heapq.heapify(A)
for i in range(M):
a = heapq.heappop(A)
heapq.heappush(A,(-1)*(-a//2))
print((-sum(A))) | 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)
#print(a)
for i in range(m):
x = heapq.heappop(a)
x = (-x)//2
heapq.heappush(a,-x)
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([int(a) for a in A]))) | import heapq
n, m = list(map(int, input().split()))
A = list([-x for x in list(map(int, input().split()))])
heapq.heapify(A)
for i in range(m):
mx = heapq.heappop(A)
heapq.heappush(A,mx/2)
print((sum([int(-a) for a in A]))) | p02912 |
import math
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
for i in range(M):
max_A = max(A)
A[A.index(max_A)] = math.floor((max_A) / 2)
print((sum(A)))
|
#優先度付きキュー
#値の追加 O(log|Q|)
#値の削除 O(log|Q|)
#最大値の取得 O(1)
#pythonでは 最小値のみしか取得できないため事前に全要素に-1をかけておき最後のまた-1かける
import math
import heapq
N,M = list(map(int,input().split()))
#各要素を-1倍
A = list(map(int,input().split()))
A = list([x*-1 for x in A])
heapq.heapify(A)
for i in range(M):
max_A = heapq.heappop(A)
max_A = max_A * -1
heapq.heappush(A,-1* (math.floor((max_A) / 2)) )
print((-1 * sum(A)))
| p02912 |
#coding:utf-8
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for m in range(M):
A[A.index(max(A))] = max(A)/2
total = sum(map(int, A))
print(total)
| #coding:utf-8
import heapq
N, M = list(map(int, input().split()))
invA = []
for a in map(int, input().split()):
heapq.heappush(invA, -1*a)
for m in range(M):
heapq.heappush(invA, heapq.heappop(invA)/2)
total = -1*sum(map(int, invA))
print(total)
| p02912 |
def slove():
import sys
import heapq
input = sys.stdin.readline
n, m = list(map(int, input().rstrip('\n').split()))
a = list(map(int, input().rstrip('\n').split()))
for i in range(len(a)):
a[i] = a[i] * - 1
heapq.heapify(a)
for i in range(m):
p = heapq.heappop(a)
p /= 2
heapq.heappush(a, p)
t = 0
for i in range(len(a)):
t += int(a[i])
print((-t))
if __name__ == '__main__':
slove()
| def slove():
import sys
import heapq
input = sys.stdin.readline
n, m = list(map(int, input().rstrip('\n').split()))
a = [- i for i in list(map(int, input().rstrip('\n').split()))]
heapq.heapify(a)
for i in range(m):
heapq.heappush(a, -(-heapq.heappop(a) // 2))
print((-sum(a)))
if __name__ == '__main__':
slove()
| p02912 |
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)) # 計算誤差の関係で-1を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 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
Asorted = sorted(A)
MM = 0
if M+1 >= N:
MM = N
else:
MM = M+1
Atop = [Asorted[N-i-1] for i in range(MM)]
for i in range(M):
Atopmax = Atop.index(max(Atop))
Atop[Atopmax] = Atop[Atopmax]//2
count = 0
for i in range(N-MM):
count += Asorted[i]
count += sum(Atop)
print(count) | #標準入力
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
#heapqをimportして、Aの要素をすべてマイナスにしてheapify
import heapq
def minus(n):
return -n
A = list(map(minus, A))
heapq.heapify(A)
#その最小値を出力して削除し、その半分を追加することをM回やる
for i in range(M):
heapq.heappush(A, -(-heapq.heappop(A)//2))
#Aの要素を合計してminusして出力する
print((minus(sum(A))))
| p02912 |
import heapq
def calc_minus(n):
return n * (-1)
N, M = list(map(int, input().split()))
values = list(map(int, input().split()))
tmp = 0
values_minus = []
for val1 in values:
values_minus.append(calc_minus(val1))
for i in range(M):
heapq.heapify(values_minus)
tmp = heapq.heappop(values_minus)
tmp_push = ((tmp * (-1)) // 2) * (-1)
heapq.heappush(values_minus, tmp_push)
values_plus = []
for val2 in values_minus:
values_plus.append(calc_minus(val2))
result = 0
for val3 in values_plus:
result += val3
print(result) | import heapq
def calc_minus(n):
return n * (-1)
N, M = list(map(int, input().split()))
values = list(map(int, input().split()))
tmp = 0
values_minus = []
for val1 in values:
values_minus.append(calc_minus(val1))
heapq.heapify(values_minus)
for i in range(M):
tmp = heapq.heappop(values_minus)
tmp_push = ((tmp * (-1)) // 2) * (-1)
heapq.heappush(values_minus, tmp_push)
values_plus = []
for val2 in values_minus:
values_plus.append(calc_minus(val2))
result = 0
for val3 in values_plus:
result += val3
print(result) | p02912 |
from bisect import bisect_left
from math import floor
def p_d():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
for _ in range(M):
x = A.pop() / 2
i = bisect_left(A, x)
A.insert(i, x)
ans = 0
for a in A:
ans += floor(a)
print(ans)
if __name__ == '__main__':
p_d()
| from heapq import heappop, heappush
from math import ceil, floor
def p_d():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
H = []
for a in A:
heappush(H, a * -1)
for _ in range(M):
x = heappop(H)
heappush(H, ceil(x / 2))
ans = 0
for a in H:
ans -= a
print(ans)
if __name__ == '__main__':
p_d()
| p02912 |
from bisect import *
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
for m in range(M):
A[-1]//=2
A.insert(bisect_left(A,A[-1]),A[-1])
A.pop()
print((sum(A))) | from heapq import *
N,M = list(map(int,input().split()))
A = list([-int(x) for x in input().split()])
heapify(A)
for m in range(M):
heappush(A,int(heappop(A)/2))
print((-sum(A))) | p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(M):
index = A.index(max(A))
A[index] = A[index] // 2
print((sum(A))) | import heapq
import math
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [i*-1 for i in A]
heapq.heapify(A)
for i in range(M):
kk = math.ceil(heapq.heappop(A) / 2)
heapq.heappush(A, kk)
A = [i*-1 for i in A]
print((sum(A))) | p02912 |
class max_heap():
def __init__(self,arr):
self.array = arr
self.build_heap()
def heapify(self,i):
left = 2 * i + 1
right = 2 * i + 2
length = len(self.array) - 1
biggest = i
if left <= length and self.array[i] < self.array[left]:
biggest = left
if right <= length and self.array[biggest] < self.array[right]:
biggest = right
if biggest != i:
self.array[i], self.array[biggest] = self.array[biggest], self.array[i]
self.heapify(biggest)
def build_heap(self):
for i in reversed(list(range(len(self.array)//2))):
self.heapify(i)
def heappop(self):
self.array[0], self.array[-1] = self.array[-1], self.array[0]
res = self.array.pop()
self.heapify(0)
return res
def heappush(self,n):
self.array.append(n)
self.build_heap()
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
heap = max_heap(A)
for i in range(M):
num = heap.heappop()//2
heap.heappush(num)
print((sum(heap.array))) | from heapq import (
heapify, # 優先度付きキューの生成
heappop,
heappush,
heappushpop,
heapreplace
)
N, M = list(map(int, input().split()))
# 最小値が返ってくるので-1倍する
A = [-i for i in map(int,input().split())]
heapify(A)
for _ in range(M):
s = -heappop(A)
s //= 2
heappush(A, -s)
print((-sum(A))) | p02912 |
n, m = list(map(int,input().split()))
List = list(map(int,input().split()))
List.sort(reverse=True)
halves = [0]
max_halves = 0
for i in range(m):
x = List.pop(0)
if x >= max_halves:
x = int(x/2)
if len(List) == 0:
List = [x]
else:
halves.append(x)
if x >= max_halves:
max_halves = x
else:
halves.remove(max_halves)
halves.append(int(max_halves/2))
max_halves = max(halves)
List = [x]+ List
print((sum(List)+sum(halves)))
| import heapq
n, m = list(map(int,input().split()))
List = list(map(int,input().split()))
List = list([x*(-1) for x in List]) # 各要素を-1倍
heapq.heapify(List)
for i in range(m):
max = heapq.heappop(List)
heapq.heappush(List, int(max/2)) # 要素の挿入
print((sum(List)*(-1))) | p02912 |
import heapq
N, M = [int(n) for n in input().split()]
hq = []
[heapq.heappush(hq, v) for v in [-1*int(n) for n in input().split()]]
for _ in range(M):
heapq.heappush(hq, -1*(-1*heapq.heappop(hq)//2))
print((-1*sum(hq)))
| import heapq
N, M = [int(n) for n in input().split()]
hq = []
[heapq.heappush(hq, v) for v in [-1*int(n) for n in input().split()]]
[heapq.heappush(hq, -1*(-1*heapq.heappop(hq)//2)) for _ in range(M)]
print((-1*sum(hq)))
| p02912 |
import heapq
N, M = [int(n) for n in input().split()]
A = [-1*int(n) for n in input().split()]
heapq.heapify(A)
[heapq.heappush(A, -1*(-1*heapq.heappop(A)//2)) for _ in range(M)]
print((-1*sum(A))) | import heapq
N, M = [int(n) for n in input().split()]
A = [-int(n) for n in input().split()]
heapq.heapify(A)
[heapq.heappush(A, -(-heapq.heappop(A)//2)) for _ in range(M)]
print((-sum(A))) | p02912 |
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
sort_A = sorted(A, reverse=True)
for _ in range(M):
sort_A[sort_A.index(max(sort_A))] = max(sort_A) // 2
print((sum(sort_A)))
main() | import heapq
def func(n):
return -n
def main():
N, M = list(map(int, input().split()))
A = list(map(func, list(map(int, input().split()))))
heapq.heapify(A)
for _ in range(M):
tmp = -heapq.heappop(A) // 2
heapq.heappush(A,-tmp)
print((-sum(A)))
main() | p02912 |
# -*- coding: utf-8 -*-
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A, reverse=True)
for i in range(M):
ans = int(A[0] / 2)
A[0] = ans
A = sorted(A, reverse=True)
sum = 0
for a in A:
sum += a
print(sum)
| # -*- coding: utf-8 -*-
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
sum = 0
l = []
for i in A:
heapq.heappush(l, i*-1)
for i in range(M):
c = int(heapq.heappop(l)*-1/2)
heapq.heappush(l, c*-1)
for a in l:
sum += a*-1
print(sum) | p02912 |
import bisect
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
for i in range(M):
a = A.pop(-1)//2
bisect.insort_left(A,a)
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 _ in range(M):
A_max = heapq.heappop(A)*(-1)
heapq.heappush(A, (A_max//2)*(-1))
print((sum(A)*(-1))) | p02912 |
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort(reverse=True)
for i in range(K):
A[0] = int(A[0]/2)
A.sort(reverse=True)
print((sum(A))) | N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
import heapq
a = list([x*(-1) for x in A]) # 各要素を-1倍
heapq.heapify(a)
for i in range(K):
num = heapq.heappop(a)*(-1)
heapq.heappush(a, -1*(int(num/2)))
#print(num,a)
if num == 0:
break
print((-sum(a)))
| p02912 |
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
for i in range(M):
A[-1] //= 2
A = sorted(A)
print((sum(A)))
| import heapq
N, M = list(map(int, input().split()))
A = [-i for i in list(map(int, input().split()))]
heapq.heapify(A)
for m in range(M):
A_max = -heapq.heappop(A) # Aの最大値を削除して取り出す
heapq.heappush(A, -(A_max // 2))
print((-sum(A)))
| p02912 |
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
for m in range(M):
index = A.index(max(A))
A[index] //= 2
ans = 0
for i in range(N):
ans += A[i]
print(ans)
| 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):
tmp = -heapq.heappop(A) // 2
heapq.heappush(A, -tmp)
print((-sum(A)))
| p02912 |
#D
import bisect
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
for i in range(m):
a[-1] //= 2
tmp = a.pop(-1)
k = bisect.bisect_left(a,tmp)
a.insert(k,tmp)
print((sum(a))) | #優先度付きキュー -> 最小値をO(logN)で取り出す
import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [-x for x in a]
#aを優先度付きキューに変更
heapq.heapify(a)
for _ in range(m):
tmp = heapq.heappop(a)
tmp = (-tmp // 2) * -1
heapq.heappush(a,tmp)
print((sum(a) * -1)) | p02912 |
N, M = list(map(int, input().split()))
prices = list(map(int, input().split(' ')))
for i in range(M):
prices[prices.index(max(prices))] //= 2
print((sum(prices))) | import heapq
N, M = list(map(int, input().split(' ')))
prices = list([x * (-1) for x in list(map(int, input().split(' ')))])
# 優先度付きキューに変換
heapq.heapify(prices)
for i in range(M):
# 最大のものを半額にしてまたキューに突っ込む
heapq.heappush(prices, ((heapq.heappop(prices) * (-1)) // 2) * -1)
print((sum(prices) * -1))
| p02912 |
import heapq
import math
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [-1*num for num in a]
heapq.heapify(a)
for i in range(m):
maximum = heapq.heappop(a)
add = math.trunc(maximum/2)
heapq.heappush(a,add)
print((-1 * 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):
max_a = -1 * heapq.heappop(a)
heapq.heappush(a,-1 *(max_a // 2))
print((-1 * sum(a)))
| p02912 |
import heapq
N,M = list(map(int,input().split()))
Price_List = list([x*(-1) for x in list(map(int,input().split()))])
heapq.heapify(Price_List)
for i in range(M):
heapq.heapify(Price_List)
val = heapq.heappop(Price_List)* -1 // 2 * -1
heapq.heappush(Price_List,val)
print((-sum(Price_List))) | import heapq
N,M = list(map(int,input().split()))
Price_List = list([x*(-1) for x in list(map(int,input().split()))])
heapq.heapify(Price_List)
for i in range(M):
val = heapq.heappop(Price_List)* -1 // 2 * -1
heapq.heappush(Price_List,val)
print((-sum(Price_List))) | p02912 |
n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
for _ in range(m):
a[-1] //= 2
a = sorted(a)
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
a = [-int(i) for i in input().split()]
heapq.heapify(a)
for _ in range(m):
temp = heapq.heappop(a)
temp = -(-temp//2)
heapq.heappush(a, temp)
print((-sum(a))) | p02912 |
# -*- coding: utf-8 -*-
from heapq import heappop, heappush, heapify
import sys
#input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
N, M = inpl()
A = inpl()
Q = [[-A[i], A[i], 0] for i in range(N)]
F = 2
heapify(Q)
for _ in range(M):
b, a, x = heappop(Q)
if b:
b = a//(2**(x+1))
heappush(Q, [-b, a, x+1])
ans = 0
for i in range(N):
ans -= Q[i][0]
print(ans) | from heapq import heappop, heappush
def inpl(): return list(map(int, input().split()))
N, M = inpl()
A = inpl()
Q = []
for a in A:
heappush(Q, [-a, a, 0])
for i in range(M):
x, a, d = heappop(Q)
if x == 0:
break
heappush(Q, [-(a//pow(2, d+1)), a, d+1])
print((sum([-q[0] for q in Q]))) | p02912 |
N,M=list(map(int,input().split()))
A=sorted(list(map(int,input().split())),reverse=True)
idx=1
for i in range(M):
value=0
for m in range(idx):
if A[m]>value:
value=A[m]
nidx=m
if nidx+1==idx:
idx+=1
idx=min(idx,N)
A[nidx]/=2
A=list(map(int,A))
print((sum(A)))
| import heapq
N,M=list(map(int,input().split()))
A=list([x*-(1) for x in list(map(int,input().split()))])
heapq.heapify(A)
for i in range(M):
num=(heapq.heappop(A)*(-1)/2)
heapq.heappush(A, num*-1)
A=list(map(int,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))] = max(a)//2
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [i*-1 for i in a]
heapq.heapify(a)
for i in range(m):
x = ((-1) * heapq.heappop(a)) //2
heapq.heappush(a, -x)
print((-sum(a))) | p02912 |
from bisect import bisect_right
n,m=list(map(int,input().split()))
lis=list(map(int,input().split()))
lists=sorted(lis)
cnt=0
while cnt<m:
y=lists[-1]//2
del lists[-1]
indexes=bisect_right(lists,y)
#indexesというところに新しいyの値を代入しておきたい
lists.insert(indexes,y)
cnt+=1
print((sum(lists))) | from bisect import bisect_right
import heapq
n,m=list(map(int,input().split()))
lists=list(map(int,input().split()))
uselists=[]
for _ in lists:
uselists.append(-_)
heapq.heapify(uselists)
cnt=0
while cnt<m:
y=heapq.heappop(uselists)
z=(-y)//2
heapq.heappush(uselists,-z)
cnt+=1
anslist=[]
for j in uselists:
anslist.append(-j)
print((sum(anslist))) | p02912 |
#powerful discount tickets
import bisect
n,m=list(map(int,input().split()))
lists=list(map(int,input().split()))
lists=sorted(lists)
for _ in range(m):
#m回この作業を繰り返す
maxi=lists[-1]
lists.remove(maxi)
bisect.insort(lists,maxi/2)
ans=0
import math
for some in lists:
ans+=math.floor(some)
print(ans) | #powerful discount tickets
n,m=list(map(int,input().split()))
lists=list(map(int,input().split()))
uselist=[0 for i in range(n)]
for j in range(n):
uselist[j]=lists[j]*(-1)
import heapq
heapq.heapify(uselist)
for _ in range(m):
#m回この作業を繰り返す
mini=heapq.heappop(uselist)
heapq.heappush(uselist,mini/2)
#バイナリツリーと同じ方法で保管していると考えられる
ans=0
import math
for some in uselist:
ans+=math.floor(-some)
print(ans)
| p02912 |
import sys
import bisect
inputs = sys.stdin.readlines()
N, M = list(map(int, inputs[0].split()))
A = sorted(list(map(int, inputs[1].split())))
for _ in range(M):
tmp = A.pop() // 2
A.insert(bisect.bisect_left(A, tmp), tmp)
print((sum(A))) | import sys
inputs = sys.stdin.readlines()
from heapq import heappush, heappop
N, M = list(map(int, inputs[0].split()))
A = list(map(int, inputs[1].split()))
queue = []
for a in A:
heappush(queue, -a)
for _ in range(M):
heappush(queue, -(-heappop(queue) // 2))
print((-sum(queue))) | p02912 |
from bisect import insort
def main():
(_, M) = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
for i in range(M):
b = A[-1] // 2
insort(A, b)
A = A[:-1]
print((sum(A)))
main() | from heapq import heappush, heappop
def main():
(N, M) = list(map(int, input().split()))
hq = list([-x for x in list(map(int, input().split()))])
hq.sort()
for i in range(M):
b = - heappop(hq) // 2
heappush(hq, -b)
print((-sum(hq)))
main() | p02912 |
n,m = list(map(int,input().split()))
A = [int(i) for i in input().split()]
A.sort(reverse=True)
def bisect(A,x):
lo = -1
hi = len(A)
while lo+1 < hi:
idx = (lo+hi)//2
if A[idx] > x:
lo = idx
else:
hi = idx
return lo
for i in range(m):
v = A.pop(0)//2
idx = bisect(A,v)+1
A = A[:idx] + [v] + A[idx:]
print((sum(A))) | from heapq import heappop, heappush, heapify
n, m = list(map(int, input().split()))
a = [-int(i) for i in input().split()]
heapify(a)
for _ in range(m):
l = heappop(a)
heappush(a, -((-l)//2))
print((-sum(a))) | p02912 |
n, m = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
for i in range(m):
a[a.index(max(a))] = max(a)//2
print((sum(a))) | import heapq
n, m = (int(i) for i in input().split())
a = [int(i) * (-1) for i in input().split()]
heapq.heapify(a)
for i in range(m):
tmp_min = ((a[0] * (-1)) //2) * (-1)
heapq.heappushpop(a,tmp_min)
print((abs(sum(a)))) | p02912 |
import math
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 math
from heapq import heappush, heappop
n, m = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
h = []
for i in a:
heappush(h, -i)
for i in range(m):
v = heappop(h)
heappush(h, -(-v // 2))
print((-sum(h))) | p02912 |
def resolve():
from collections import deque
n, m = list(map(int, input().split()))
a = deque(list(map(int, input().split())))
for i in range(m):
a = deque(sorted(a))
maxa = a.pop()
maxa //= 2
a.appendleft(maxa)
print((sum(a)))
resolve() | def resolve():
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):
maxa = heapq.heappop(a) * -1
maxa //= 2
heapq.heappush(a, -maxa)
print((sum(a)*-1))
resolve() | p02912 |
n,m=list(map(int,input().split()))
a = sorted([int(i) for i in input().split()])[::-1]
ans = 0
while m > 0:
a[0] = a[0]//2
m-=1
for i in range(n-1):
if a[i] < a[i+1]: a[i],a[i+1] = a[i+1],a[i]
else: break
print((sum(a))) | import heapq
n,m=list(map(int,input().split()))
a = sorted([int(i) for i in input().split()])
a = list([x*(-1) for x in a])
heapq.heapify(a)
while m > 0:
t = heapq.heappop(a)*(-1)//2
heapq.heappush(a,-t)
m-=1
print((-sum(a))) | p02912 |
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
A = sorted(A, reverse=True)
for _ in range(M):
A[0] = A[0] / 2
A = sorted(A, reverse=True)
ans = 0
for a in A:
ans += int(a)
print(ans)
| import heapq
N, M = list(map(int, input().split()))
A = [-int(i) for i in input().split()]
heapq.heapify(A)
for _ in range(M):
x = heapq.heappop(A) / 2
heapq.heappush(A, x)
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()))
for i in range(m):
target = max(a)
a[a.index(target)] = target // 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):
target = heapq.heappop(a)
heapq.heappush(a, (-1)*(-target//2))
print((-sum(a))) | p02912 |
import bisect
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
for _ 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()))
hq=[]
for i in A:
heapq.heappush(hq,-i)
for _ in range(m):
m=-((-heapq.heappop(hq))//2)
heapq.heappush(hq,m)
print((-sum(hq))) | p02912 |
def bin_tree( pri , li_pri , len_li ):
#pri: どこに入れていいかわからない値段
#li_pri: 値段のリスト(昇順)
#len_li: リストの長さ
lo = 0
hi = len_li - 1
while hi - lo > 1:
mid = lo + (hi - lo) // 2
guess = li_pri[mid]
if guess >= pri:
hi = mid
else:
lo = mid
return lo
I = input().split()
N = int(I[0])
M = int(I[1])
# N: 品物の数
# M: 割引券の数
# A: 品物の値段行列
A = list(map(int , input().split()))
A.sort()
while M > 0:
M -= 1
pri = A.pop( N - 1 )
pri = pri // 2
if len(A) == 0:
ans = 0
elif (pri < A[0] ):
ans = 0
else:
ans = bin_tree( pri , A , N - 1 ) + 1
# ans: pri以上となる値段のうち最小のインデックス
A[ans:ans] = [pri]
F_pri = 0
for i in range(N):
F_pri += A[i]
print(F_pri) | import heapq
I = input().split()
N = int(I[0])
M = int(I[1])
# N: 品物の数
# M: 割引券の数
# A: 品物の値段行列
A = list(map(int , input().split()))
A = list([x*(-1) for x in A])
heapq.heapify(A)
for i in range(M):
M -= 1
pri = heapq.heappop(A)
pri *= -1
pri //= 2
pri *= -1
heapq.heappush( A , pri )
Fi_pri = 0
for i in range(N):
Fi_pri += A[i]
print(( -1 * Fi_pri )) | p02912 |
import math
import queue
mod = 1e9+7
def swap(a,b):
return (b,a)
def gcd(a,b):
if (a<b):
a,b = swap(a,b)
if (b==0):
return a
else:
return gcd(b,a%b)
def divisors(a):
divisors = []
for i in range(1,int(a**0.5)+1):
if a%i==0:
divisors.append(i)
if i!=a//i:
divisors.append(a//i)
return divisors
def main():
n,m = list(map(int,input().split()))
a = [x for x in map(int,input().split())]
for i in range(m):
id = a.index(max(a))
a[id] //= 2
print((sum(a)))
return
if __name__ == '__main__':
main() | import math
import queue
import bisect
import heapq
mod = 1e9+7
def swap(a,b):
return (b,a)
def gcd(a,b):
if (a<b):
a,b = swap(a,b)
if (b==0):
return a
else:
return gcd(b,a%b)
def divisors(a):
divisors = []
for i in range(1,int(a**0.5)+1):
if a%i==0:
divisors.append(i)
if i!=a//i:
divisors.append(a//i)
return divisors
def main():
n,m = list(map(int,input().split()))
a = [-x for x in map(int,input().split())]
heapq.heapify(a)
for i in range(m):
x = heapq.heappop(a)
if x%2==0:
heapq.heappush(a,x//2)
else:
heapq.heappush(a,x//2+1)
ans = 0
for i in range(n):
ans += heapq.heappop(a)*(-1)
print(ans)
return
if __name__ == '__main__':
main() | p02912 |
from heapq import heapify,heappush,heappop
def main():
N,M = list(map(int,input().split()))
A = [ -x for x in map(int,input().split()) ]
for i in range(M):
heapify(A)
#print(A)
tmp = -heappop(A)
#print(tmp)
tmp = tmp//2
#print(tmp)
heappush(A,-tmp)
ans = 0
for i in range(N):
ans += A[i]
ans = abs(ans)
return ans
print((main()))
| from heapq import heapify,heappush,heappop
def main():
N,M = list(map(int,input().split()))
A = [ -x for x in map(int,input().split()) ]
heapify(A)
for i in range(M):
#print(A)
tmp = -heappop(A)
#print(tmp)
tmp = tmp//2
#print(tmp)
heappush(A,-tmp)
ans = 0
for i in range(N):
ans += A[i]
ans = abs(ans)
return ans
print((main()))
| p02912 |
#!/usr/bin/env python3
import sys
def sort(A):
for i in range(1, len(A)):
insert(A, i)
def insert(A, i):
temp = A[i]
for j in range(i - 1, -1, -1):
if temp < A[j]:
A[j + 1] = A[j]
else:
A[j + 1] = temp
break
else:
A[0] = temp
def solve(N: int, M: int, A: "List[int]"):
sort(A)
for i in range(M):
MD = A[-1]
A[-1] = MD // 2
sort(A)
if A[-1] == 0:
break
print((sum(A)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, M, A)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, M: int, A: "List[int]"):
while M > 0:
A = sorted(A, reverse=True)
MD = A[0] // 2
for i, ai in enumerate(A):
if ai > MD and M > 0:
A[i] = ai//2
M -= 1
else:
break
if A[i] == 0:
break
print((sum(A)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, M, A)
if __name__ == '__main__':
main()
| p02912 |
# -*- coding: utf-8 -*-
# from collections import deque
import bisect
N, M = list(map(int, input().split()))
A_list = list(map(int, input().split()))
A_list.sort()
# A_list = deque(A_list)
ans = 0
ans += sum(A_list[0:N - M])
del(A_list[0:N - M])
for i in range(M):
max_price = A_list.pop()
bisect.insort(A_list, max_price // 2)
ans += sum(A_list)
print(ans) | # D 終了後再チャレンジ
# -*- coding: utf-8 -*-
import heapq
N, M = list(map(int, input().split()))
A_list = list(map(int, input().split()))
A_list = [-a for a in A_list]
heapq.heapify(A_list)
for i in range(M):
max_price = heapq.heappop(A_list) * (-1)
heapq.heappush(A_list, max_price // 2 * (-1))
ans = sum(A_list) * (-1)
print(ans) | p02912 |
n,m=list(map(int, input().split()))
a=[int(x) for x in input().split()]
while m>0:
max_value = max(a)
max_index = a.index(max_value)
a[max_index]=max_value/2
m-=1
a=[int(x) for x in a]
print((sum(a))) | n,m=list(map(int, input().split()))
a=[int(x) for x in input().split()]
a=[-1*x for x in a]
import heapq
heapq.heapify(a)
for i in range(m):
max_value = heapq.heappop(a) #最大値の取得
heapq.heappush(a, (max_value/2)) #半額にして-1倍してからキューに戻す
a=[-1*x for x in a]
a=[int(x) for x in a]
print((sum(a))) | p02912 |
from bisect import insort_left
n, m = [int(x) for x in input().split()]
a_list = [int(x) for x in input().split()]
a_list.sort()
for _ in range(m):
a_list[-1] //= 2
insort_left(a_list, a_list.pop())
print((sum(a_list))) | import heapq
from math import ceil
n, m = [int(x) for x in input().split()]
a_list = [-int(x) for x in input().split()]
heapq.heapify(a_list)
for _ in range(m):
temp = ceil(heapq.heappop(a_list) / 2)
heapq.heappush(a_list, temp)
print((-sum(a_list))) | p02912 |
n,m=list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(1,m+1):
l = a.index(max(a))
a[l] = a[l] // 2
print((sum(a)))
| import heapq
import math
n,m=list(map(int,input().split()))
a = list(map(int,input().split()))
h = []
for _a in a:
heapq.heappush(h,-_a)
for i in range(m):
heapq.heappush(h,math.ceil(heapq.heappop(h) / 2))
print((sum(h)*(-1)))
| p02912 |
n, m = list(map(int, input().split()))
lisA = [int(i) for i in input().split()]
#print(n, m)
#print(lisA)
lisA.sort(reverse=True)
half0 = lisA[0] / 2
count = 0
for i in range(m):
if (count > n - 1):
count = 0
if (lisA[count] < half0):
lisA.sort(reverse=True)
half0 = lisA[0]
count = 0
lisA[count] //= 2
count += 1
print((sum(lisA))) | n, m = list(map(int, input().split()))
lisA = [int(i) for i in input().split()]
#print(n, m)
#print(lisA)
lisA.sort(reverse=True)
half0 = lisA[0] // 2
count = 0
for i in range(m):
if (count > n - 1):
count = 0
if (lisA[count] < half0):
lisA.sort(reverse=True)
half0 = lisA[0] // 2
count = 0
lisA[count] //= 2
count += 1
print((sum(lisA))) | p02912 |
m = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(m[1]):
a[a.index(max(a))] = a[a.index(max(a))]//2
print((sum(a))) | import heapq
m = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(len(a)):
a[i] = a[i]*-1
heapq.heapify(a)
for i in range(m[1]):
k= heapq.heappop(a)
heapq.heappush(a, -(-k//2))
print((sum(a)*-1)) | p02912 |
import bisect
def main():
n, m = list(map(int, input().split(' ')))
a_s = list(sorted(map(int, input().split(' '))))
for _ in range(m):
value = int(a_s[n-1]/2)
i = bisect.bisect_left(a_s[:n-1], value)
a_s[i+1:n] = a_s[i:n-1]
a_s[i] = value
print((sum(a_s)))
if __name__ == '__main__':
main()
| import heapq
def main():
n, m = list(map(int, input().split(' ')))
a_s = list(sorted([-1 * int(x) for x in input().split(' ')]))
heapq.heapify(a_s)
for _ in range(m):
e = heapq.heappop(a_s)
heapq.heappush(a_s, int(e/2))
print((-1*sum(a_s)))
if __name__ == '__main__':
main()
| p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
"""
high = float('inf')
low = -1
while low + 1 < high:
mid = (low + high) // 2
if min(sum(a), mid :
high = mid
else:
low = mid
print(high)
"""
for i in range(m):
a[a.index(max(a))] = int(a[a.index(max(a))] / 2)
print((sum(a))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
import heapq
a = [-i for i in a]
heapq.heapify(a)
for i in range(m):
b = heapq.heappop(a) * (-1)
heapq.heappush(a, b // 2 * (-1))
print((-sum(a))) | p02912 |
def mmm(li):
li[li.index(max(a))]//=2
n,m = list(map(int,input().split()))
a= list(map(int,input().split()))
[mmm(a) for i in range(m)]
print((sum(a))) | import heapq
n,m = list(map(int,input().split()))
a= list(map(int,input().split()))
h = list([-1*x for x in a])
heapq.heapify(h)
for i in range(m):
heapq.heapreplace(h,-(-h[0]//2))
print((-1*sum(h))) | 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] //= 2
print((sum(a))) | import heapq
n,m=list(map(int,input().split()))
a=list([x*(-1) for x in list(map(int,input().split()))])
heapq.heapify(a)
for _ in range(m):
k = heapq.heappop(a)*(-1) // 2
heapq.heappush(a,k*(-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)
for _ in range(M):
X = heapq.heappop(a)
heapq.heappush(a, X/2)
print((sum(int(-x) for x in a))) | from heapq import heapify, heappop, heappush
N, M = list(map(int, input().split()))
A = [-a for a in list(map(int, input().split()))]
heapify(A)
for _ in range(M):
p = heappop(A)
heappush(A, -((-p)//2))
print((-sum(A))) | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(m):
a_max = max(a)
a_max_i = a.index(a_max)
new = int(a_max / 2) if not a_max == 0 else 0
a[a_max_i] = new
print((int(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):
a_min = heapq.heappop(a)
heapq.heappush(a, int(a_min / 2))
print((-1 * sum(a))) | p02912 |
import bisect
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
for i in range(m):
tmp_max = a.pop()
bisect.insort(a, tmp_max // 2)
print((sum(a))) | import math
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):
min = (-1)*((-1)*(heapq.heappop(A))//2)
heapq.heappush(A, min)
print((int(sum(A))*(-1)))
| p02912 |
N, M = list(map(int, input().split()))
A = list(input().split())
A = [int(i) for i in A]
A.sort(reverse=True)
for _ in range(M):
A[A.index(max(A))] = max(A)//2
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = list(input().split())
A = [int(i) * (-1) for i in A]
heapq.heapify(A)
for _ in range(M):
val = heapq.heappop(A)
heapq.heappush(A, val*(-1)//2*(-1))
print((sum(A) * (-1))) | p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort(reverse=True)
#print(A)
B=A[0:min(N,M)]
for i in range(M):
idx = B.index(max(B))
B[idx] = int(B[idx] / 2.0)
# A.sort(reverse=True)
ans = 0
for i in range(N):
if i < len(B):
ans+=B[i]
else:
ans += A[i]
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]
heapq.heapify(A)
for j in range(M):
a = heapq.heappop(A)
b = -1*((-a) // 2)
heapq.heappush(A,b)
print((-sum(A))) | p02912 |
import sys
input = sys.stdin.readline
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
used = 0
while used < M:
ma = max(A)
idx = A.index(ma)
A[idx] = A[idx] // 2
used += 1
print((sum(A)))
# TLE
# for _ in range(M):
# A.sort()
# A[-1] = A[-1] // 2
# print(sum(A))
if __name__ == "__main__":
main()
| import sys
import heapq
input = sys.stdin.readline
def main():
N, M = list(map(int, input().split()))
A = list([int(x) * -1 for x in input().split()])
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A) * -1
a = a // 2
heapq.heappush(A, a * -1)
print((sum(A) * -1))
if __name__ == "__main__":
main()
| p02912 |
import bisect
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
for i in range(M):
p = A.pop()
p //= 2
index = bisect.bisect_left(A, p)
A.insert(index, p)
print((sum(A))) | import heapq
import bisect
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):
P = heapq.heappop(A)
p = P[1] // 2
heapq.heappush(A, (-p, p))
s = 0
for i in range(N):
s += A[i][1]
print(s) | p02912 |
N, M = list(map(int, input().split()))
A = [int(x) for x in input().split()]
A = sorted(A)[::-1]
res = 0
for x in A:
res += x
for m in range(M):
tmp = sorted(A[:m+1])[::-1]
k = tmp[0]
tmp[0] = int(tmp[0]/2)
l = tmp[0]
tmp.extend(A[m+1:])
A = tmp
res -= k-l
print(res)
| from heapq import *
N, M = list(map(int, input().split()))
A = [-int(x) for x in input().split()]
heapify(A)
for x in range(M):
tmp = int(heappop(A)/2)
heappush(A,tmp)
res = 0
for x in A:
res -= x
print(res)
| p02912 |
import bisect
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
for _ in range(m):
q = arr.pop()
bisect.insort_right(arr, q // 2)
print((sum(arr))) | from heapq import heapify, heapreplace
n, m = list(map(int, input().split()))
arr = [-x for x in map(int, input().split())]
heapify(arr)
for _ in range(m):
heapreplace(arr, int(arr[0] / 2))
print((-sum(arr))) | p02912 |
from heapq import heapify, heappop, heappush
n, m = list(map(int, input().split()))
arr = [-x for x in map(int, input().split())]
heapify(arr)
for _ in range(m):
tmp = heappop(arr)
heappush(arr, int(tmp / 2))
print((-sum(arr))) | from heapq import heappop, heappush, heapify
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = [-x for x in arr]
heapify(arr)
for _ in range(m):
a = heappop(arr)
heappush(arr, -(-a // 2))
print((-sum(arr))) | p02912 |
import heapq
N,M=list(map(int,input().split()))
A=list([-int(x) for x in input().split()])
heapq.heapify(A)
while M>0:
a=heapq.heappop(A)
a=-a
a=a>>1
a=-a
heapq.heappush(A,a)
M-=1
print((-sum(A))) | import heapq
n,m=list(map(int,input().split()))
*a,=list(map(int,input().split()))
q=[]
for aa in a:
heapq.heappush(q,-aa)
while m>0:
aa=heapq.heappop(q)
heapq.heappush(q,-((-aa)//2))
m-=1
print((-sum(q))) | p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
while M > 0:
M -= 1
A[A.index(max(A))] //= 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) # aを優先度付きキューに
for _ in range(m):
tmp_min = heapq.heappop(a)
heapq.heappush(a, (-1)*(-tmp_min//2)) # 計算誤差の関係で-1を2回かけてます
print((-sum(a)))
| p02912 |
n, m = [int(i) for i in input().split()]
prices = sorted([int(i) for i in input().split()], reverse=True)
for i in range(m):
prices[0] = prices[0] // 2
prices = sorted(prices, reverse=True)
print((sum(prices))) | n, m = [int(i) for i in input().split()]
prices = sorted([int(i) for i in input().split()], reverse=True)
d = 1
while(True):
d *= 2
if d * 2 > 10 ** 9:
break
while(d > 0):
for i, price in enumerate(prices):
if price >= d:
prices[i] = prices[i] // 2
m -= 1
if m == 0:
d = 0
break
prices = sorted(prices, reverse=True)
d /= 2
print((sum(prices)))
| p02912 |
N = int(2e5+3)
heap_arr, heap_size = [0] * N, 0
def heap_push(x):
global heap_size
heap_arr[heap_size] = x
i = heap_size
while i > 0 and heap_arr[i] > heap_arr[(i-1)//2]:
heap_arr[i], heap_arr[(i-1)//2] = heap_arr[(i-1)//2], heap_arr[i]
i = (i-1)//2
heap_size += 1
def get_max():
global heap_size
if heap_size == 0:
return -2e9
return heap_arr[0]
def heap_pop():
global heap_size
if heap_size == 0:
return
heap_size -= 1
heap_arr[0], heap_arr[heap_size] = heap_arr[heap_size], heap_arr[0]
i, j = 0, -1
while i != j:
j = i
l = 2*i+1
r = 2*i+2
if l < heap_size and heap_arr[l] > heap_arr[i]:
i = l
if r < heap_size and heap_arr[r] > heap_arr[i]:
i = r
heap_arr[i], heap_arr[j] = heap_arr[j], heap_arr[i]
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
for i in arr:
heap_push(i)
while m >= 1:
x = get_max() // 2
heap_pop()
heap_push(x)
m -= 1
print((sum(heap_arr)))
| 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):
tmp=heapq.heappop(A)
tmp=-tmp//2
heapq.heappush(A,-tmp)
print((-sum(A)))
| 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] = int(max(a)/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] = (-1) * a[i]
heapq.heapify(a)
for i in range(m):
d = heapq.heappop(a)
heapq.heappush(a,d/2)
ans = 0
for i in range(n):
ans += int(-a[i])
print(ans)
| p02912 |
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(0,m):
b=a.index(max(a))
a[b]=a[b]//2
print((sum(a))) | import heapq as hq
n,m = list(map(int,input().split()))
A = []
for a in [int(_) for _ in input().split()]:
hq.heappush(A, -a)
for _ in range(m):
t = hq.heappop(A)
hq.heappush(A, t / 2)
print((-sum([int(a) for a in A]))) | p02912 |
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
for _ in range(m):
_max = max(arr)
i = arr.index(_max)
arr[i] = _max // 2
print((sum(arr))) | n, m = list(map(int, input().split()))
arr = sorted(list(map(int, input().split())), reverse=True)
b = arr[0] // 2
i = 0
while True:
if m == 0:
break
if b <= arr[i]:
arr[i] = arr[i] // 2
m -= 1
else:
arr = sorted(arr, reverse=True)
i = 0
b = arr[0] // 2
continue
if i < n-1:
i += 1
else:
i = 0
print((sum(arr))) | p02912 |
import sys
from io import StringIO
import unittest
def resolve():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(M):
m = max(A)
m_index = A.index(m)
A[m_index] //= 2
print((int(sum(A))))
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3 3
2 13 8"""
output = """9"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """4 4
1 9 3 5"""
output = """6"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """1 100000
1000000000"""
output = """0"""
self.assertIO(input, output)
def test_入力例_4(self):
input = """10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000"""
output = """9500000000"""
self.assertIO(input, output)
if __name__ == "__main__":
resolve()
| import sys
from io import StringIO
import unittest
import heapq
def resolve():
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):
m = -1 * heapq.heappop(A)
heapq.heappush(A, -1 * (m//2))
print((-1 * int(sum(A))))
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3 3
2 13 8"""
output = """9"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """4 4
1 9 3 5"""
output = """6"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """1 100000
1000000000"""
output = """0"""
self.assertIO(input, output)
def test_入力例_4(self):
input = """10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000"""
output = """9500000000"""
self.assertIO(input, output)
if __name__ == "__main__":
# unittest.main()
resolve()
| p02912 |
N, M = list(map(int, input().split()))
A_lis = list(map(int, input().split()))
#A_lis.sort()
def discount(B_lis,delta):
#B_lis.sort()
max_index = B_lis.index(max(B_lis))
delta[max_index] += B_lis[max_index]/2
B_lis[max_index] = B_lis[max_index]/2
#B_lis.sort()
return B_lis,delta
dis = [0]*N
for i in range(M):
A_lis,dis = discount(A_lis,dis)
#print(A_lis)
#print(dis)
ans = 0
for i in range(len(A_lis)):
ans+=int(A_lis[i])
print(ans)
| import heapq
N,M = list(map(int, input().split()))
A_lis = list([int(x)*(-1) for x in input().split()])
heapq.heapify(A_lis)
def discount(A_lis):
popped = heapq.heappop(A_lis)
heapq.heappush(A_lis,popped/2)
return A_lis
for i in range(M):
A_lis = discount(A_lis)
ans = 0
for i in A_lis:
ans += int(i)
print((ans*(-1)))
| p02912 |
import heapq
def heapsort(iterable):
h = []
for value in iterable:
heapq.heappush(h, value)
return [heapq.heappop(h) for i in range(len(h))]
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
for i in range(M):
A = heapsort(A)
A[N-1] //= 2
print((sum(A))) | import heapq
import math
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
# 各要素に1掛ける
A = list([x * -1 for x in A])
heapq.heapify(A)
for _ in range(M):
heapq.heappush(A, ((-1*heapq.heappop(A))//2)*-1 )
print((sum(A) * -1)) | p02912 |
N, M = list(map(int, input().split()))
A = [int(_) for _ in input().split()]
for i in range(M):
ind = A.index(max(A))
A[ind] = A[ind] // 2
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = [int(_)*(-1) for _ in input().split()]
heapq.heapify(A)
while M != 0:
max_ = -heapq.heappop(A) // 2
heapq.heappush(A, -max_)
M -= 1
print((-sum(A))) | p02912 |
N, M = list(map(int, input().split()))
A = list(map(float, input().split()))
for _ in range(M):
i = max(list(range(len(A))), key=A.__getitem__)
A[i] /= 2
A = list(map(int, A))
print((sum(A)))
| import heapq
N, M = list(map(int, input().split()))
A = list(map(float, input().split()))
heap = [-Ai for Ai in A]
heapq.heapify(heap)
for _ in range(M):
heapq.heapreplace(heap, heap[0]/2)
A = [int(-p) for p in heap]
print((sum(A)))
| p02912 |
import bisect
N,M=[int(i) for i in input().split()]
A = sorted([int(i) for i in input().split()])
for i in range(M):
A2=A[N-1]//2
A.pop(N-1)
A.insert(bisect.bisect_left(A, A2), A2)
print((sum(A)))
| import heapq
N,M=[int(i) for i in input().split()]
A=sorted([-int(i) for i in input().split()])
for i in range(M):heapq.heappush(A,-(-heapq.heappop(A)//2))
print((-sum(A))) | p02912 |
#!/usr/bin/env python3
import sys
import heapq
def solve(N: int, M: int, A: "List[int]"):
a = []
for i in A:
heapq.heappush(a, -i)
for _ in range(M):
m = heapq.heappop(a)
heapq.heappush(a, -(-m // 2))
sum = 0
for i in a:
sum += i
print((-sum))
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
M = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, M, A)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import heapq
def main():
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
a = []
for i in A:
heapq.heappush(a, -i)
for _ in range(M):
m = heapq.heappop(a)
heapq.heappush(a, -(-m // 2))
sum = 0
for i in a:
sum += i
print((-sum))
return
if __name__ == '__main__':
main()
| p02912 |
import sys
import bisect
sys.setrecursionlimit(10 ** 9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
_, M = lr()
A = lr()
A.sort()
for m in range(M):
a = A[-1] // 2
i = bisect.bisect_left(A, a)
A.insert(i, a)
A = A[:-1]
print((sum(A)))
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
import heapq
n, m = lr()
a = list([- int(x) for x in input().split()])
heapq.heapify(a)
for i in range(m):
b = heapq.heappop(a) * (-1)
b //= 2
heapq.heappush(a, -b)
print((-sum(a)))
| p02912 |
n, m = list(map(int, input().split()))
a = [int(x) for x in input().split()]
for i in range(m):
x = max(a)
i = a.index(x)
x_b = x//2
a[i] = x_b
print((sum(a))) | import heapq
import math
n, m = list(map(int, input().split()))
a = [-1*int(x) for x in input().split()]
heapq.heapify(a)
for _ in range(m):
min_a = heapq.heappop(a)
heapq.heappush(a, math.ceil(min_a / 2))
print((sum(a)*(-1)))
| p02912 |
n,m = list(map(int, input().split()))
L=list(map(int, input().split()))
L.sort(reverse=True)
for i in range(m):
L[0]=L[0]/2
for j in range(n-1):
if L[j]<L[j+1]:
L[j], L[j+1]= L[j+1], L[j]
else:
break
#小数点を切り捨てる
for i in range(n):
L[i]=int(L[i])
print((sum(L))) | n, m = list(map(int, input().split()))
L=list(map(int, input().split()))
A=[]
for i in range(n):
A.append(-L[i])
import heapq
heapq.heapify(A)
for i in range(m):
a= -heapq.heappop(A)
heapq.heappush(A, -(a//2))
print((-sum(A))) | p02912 |
N, M = list(map(int, input().split()))
A_list = list(map(int, input().split()))
for i in range(M):
A_list[A_list.index(max(A_list))] //= 2
print((sum(A_list))) | N, M = list(map(int, input().split()))
A_list = list(map(int, input().split()))
import heapq, math
A_list = [-x for x in A_list]
heapq.heapify(A_list)
for _ in range(M):
A_min = heapq.heappop(A_list)
heapq.heappush(A_list, math.ceil(A_min/2))
print((-sum(A_list))) | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
# list内の最も大きい数字を2で割るのをm回行う
for i in range(m):
a = sorted(a)
a[n -1] = int(a[n -1] / 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 i in range(m):
heapq.heappush(a, int(heapq.heappop(a) / 2))
print((sum(a) * -1)) | p02912 |
import math
N,Y=list(map(int,input().split()))
a=[float(x) for x in input().split()]
for b in range(Y):
a.sort(reverse=True)
a[0]=float(a[0])/2
v=0
for c in range(N):
v+=int(a[c])
print(v)
| 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 heapq
N, M = [int(x) for x in input().split()]
A = list([int(x) * - 1 for x in input().split()])
while M > 0:
heapq.heapify(A)
count = (heapq.heappop(A) * -1 // 2) * -1
heapq.heappush(A, count)
M -= 1
print((sum(A) * -1))
| import heapq
N, M = [int(x) for x in input().split()]
A = list([int(x) * - 1 for x in input().split()])
heapq.heapify(A)
for _ in range(M):
target = heapq.heappop(A) * -1
heapq.heappush(A, (target // 2) * -1)
print((sum(A) * -1))
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for _ in range(M):
max_i = A.index(max(A))
A[max_i] >>= 1
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):
v = heapq.heappop(A) * (-1)
heapq.heappush(A, -(v >> 1))
print((-sum(A))) | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
from math import floor
def bubble(x):
for i in range(len(x)-1):
if x[i] < x[i+1]:
x[i], x[i+1] = x[i+1], x[i]
else:
break
return x
a.sort(reverse=True)
for _ in range(m):
a[0] /= 2
a = bubble(a)
ans = 0
for ele in a:
ans += floor(ele)
print(ans) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
from math import floor
import heapq
for i in range(n):
a[i] = -a[i]
h = []
for ele in a:
heapq.heappush(h, ele)
for _ in range(m):
mx = heapq.heappop(h)
mx /= 2
heapq.heappush(h, mx)
ans = 0
for ele in h:
ans += floor(-ele)
print(ans) | p02912 |
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
for i in range(M):
A[0] = int(A[0] / 2)
A = sorted(A, reverse=True)
print((sum(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):
a = -int(heapq.heappop(A) / 2)
heapq.heappush(A, -a)
print((-sum(A))) | p02912 |
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):
a = -int(heapq.heappop(A) / 2)
heapq.heappush(A, -a)
print((-sum(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):
a = -heapq.heappop(A) // 2
heapq.heappush(A, -a)
print((-sum(A))) | p02912 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.