Problem:
Score : 400 points

Problem Statement

Takahashi is going to buy N items one by one.

The price of the i-th item he buys is A_i yen (the currency of Japan).

He has M discount tickets, and he can use any number of them when buying an item.

If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.

What is the minimum amount of money required to buy all the items?

Constraints

All values in input are integers.

1 \leq N, M \leq 10^5

1 \leq A_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N M
A_1 A_2 ... A_N

Output

Print the minimum amount of money required to buy all the items.

Sample Input 1

3 3
2 13 8

Sample Output 1

9

We can buy all the items for 9 yen, as follows:

Buy the 1-st item for 2 yen without tickets.

Buy the 2-nd item for 3 yen with 2 tickets.

Buy the 3-rd item for 4 yen with 1 ticket.

Sample Input 2

4 4
1 9 3 5

Sample Output 2

6

Sample Input 3

1 100000
1000000000

Sample Output 3

0

We can buy the item priced 1000000000 yen for 0 yen with 100000 tickets.

Sample Input 4

10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000

Sample Output 4

9500000000

Solution in LuaJIT (2.0.4) (judge verdict: Runtime Error)

--[[問題文
高橋くんは N個の品物を 1個ずつ順番に買う予定です。i番目に買う品物の値段は Ai円です。高橋くんは M枚の割引券を持っています。品物を買う際に割引券を好きな枚数使うことができます。X円の品物を買う際に Y 枚の割引券を使った場合、その品物を X/2^Y円(小数点以下切り捨て)で買うことができます。最小で何円あれば全ての品物を買うことができるでしょうか。

制約
入力は全て整数である。
1≤N,M≤10^5, 1≤Ai≤10^9]]

--M枚の商品券をいかに効率良く振り分けるか。つまり商品券1枚あたりの割引価格をどれだけ大きくできるか。
--当然のことだけど全部使い切ったほうがいい。
--最初の1枚は、自明に1番値段の高いものに使うべき。
--次は、1枚割引券を使った状態でもっとも高いものに使うべき。
--以下M枚使い切るまで行う。
--素直に実装するなら、一番大きな要素を割るたびにソートを行ってループするという感じ。
--これを以前c++で実装したけどtleになった。ソートの計算量いくらなんだろうね。
--一応同じような実装で出してみる。tlew

--[[
n,m=io.read("*n","*n","*l")
a={}
for i=1,n do
    a[i]=io.read("*n")
end

for i=1,m do
    table.sort(a)
    a[n]=a[n]//2
end

total=0
for i=1,n do
    total=total+a[i]
end
print(total)
]]

--2分探索使えないかな。
--1番大きいのを割ったらa[i]<=a[n]<=a[j]となる位置に移動させる
--うーん。移動ってのはどう実装したらいいだろう。結局ソートと変わらないってことにはならないかな
--一番大きいのを割っていく過程で、キーを記録しておいて、割ったあとに最大だった項とその次に大きな項で比較して、大小関係に応じてキーの記録を更新するというやりかたをさっきやったけどそれだと最大値でなくなった項が再び最大値になるパターンを取りこぼすから、記録の仕方を工夫しないといけない。
--キーじゃなくて値を配列に保存して、配列の最大値と比較するってのはどうだろう。
--実装がややこしくなりそうだし計算量も改善できるだろうか。。。
--あっ、無理かも。格納される項の最大値M=10^5だから計算量はM(M-1)/2に比例するはず。
--実装してみよう。

--[[
n,m=io.read("*n","*n","*l")
a={}
for i=1,n do
    a[i]=io.read("*n")
end
table.sort(a)
if n==1 then
    return print(string.format("%d",a[1]//(2^m)))
end

t={}
key=n
for i=1,m do
    a[key]=a[key]//2
    table.insert(t,{a[key],key})
    if #t>1 then
        table.sort(t,function(a,b)
            return a[1]<b[1]
        end)
    end
    if t[#t][1]<=a[key] then
        key=t[#t][2]
    else
        if key-1==0 then
            break
        else
            key=key-1
        end
    end
end

total=0
for i=1,n do
    total=total+a[i]
end
print(total)
]]

--TLEかつWAだった。テーブルをキーの取得にしか使ってなかったせいだと思う。値を消さないと。

--url:https://gist.github.com/LukeMS/89dc587abd786f92d60886f4977b1953
--[[  Priority Queue implemented in lua, based on a binary heap.
Copyright (C) 2017 Lucas de Morais Siqueira <lucas.morais.siqueira@gmail.com>
License: zlib
  This software is provided 'as-is', without any express or implied
  warranty. In no event will the authors be held liable for any damages
  arising from the use of this software.
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgement in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
]]--

local floor = math.floor


local PriorityQueue = {}
PriorityQueue.__index = PriorityQueue

setmetatable(
    PriorityQueue,
    {
        __call = function (self)
            setmetatable({}, self)
            self:initialize()
            return self
        end
    }
)


function PriorityQueue:initialize()
    --[[  Initialization.
    Example:
        PriorityQueue = require("priority_queue")
        pq = PriorityQueue()
    ]]--
    self.heap = {}
    self.current_size = 0
end

function PriorityQueue:empty()
    return self.current_size == 0
end

function PriorityQueue:size()
    return self.current_size
end

function PriorityQueue:swim()
    -- Swim up on the tree and fix the order heap property.
    local heap = self.heap
    local floor = floor
    local i = self.current_size

    while floor(i / 2) > 0 do
        local half = floor(i / 2)
        if heap[i][2] < heap[half][2] then
            heap[i], heap[half] = heap[half], heap[i]
        end
        i = half
    end
end

function PriorityQueue:put(v, p)
    --[[ Put an item on the queue.
    Args:
        v: the item to be stored
        p(number): the priority of the item
    ]]--
    --

    self.heap[self.current_size + 1] = {v, p}
    self.current_size = self.current_size + 1
    self:swim()
end

function PriorityQueue:sink()
    -- Sink down on the tree and fix the order heap property.
    local size = self.current_size
    local heap = self.heap
    local i = 1

    while (i * 2) <= size do
        local mc = self:min_child(i)
        if heap[i][2] > heap[mc][2] then
            heap[i], heap[mc] = heap[mc], heap[i]
        end
        i = mc
    end
end

function PriorityQueue:min_child(i)
    if (i * 2) + 1 > self.current_size then
        return i * 2
    else
        if self.heap[i * 2][2] < self.heap[i * 2 + 1][2] then
            return i * 2
        else
            return i * 2 + 1
        end
    end
end

function PriorityQueue:pop()
    -- Remove and return the top priority item
    local heap = self.heap
    local retval = heap[1][1]
    heap[1] = heap[self.current_size]
    heap[self.current_size] = nil
    self.current_size = self.current_size - 1
    self:sink()
    return retval
end

--return PriorityQueue

local n,m=io.read("n","n")
local a=PriorityQueue()
for i=1,n do
    local x=io.read("n")
    a:put(-x,-x)
end
for i=1,m do
    x=a:pop()
    x=-x
    x=floor(x/2)
    a:put(-x,-x)
end

local total=0
for i=1,n do
    total=total+a:pop()
end
print(-total)