You are given a 0-indexed integer array piles, where piles[i] represents the number of stones in the ith pile, and an integer k. You should apply the following operation exactly k times:


	Choose any piles[i] and remove floor(piles[i] / 2) stones from it.


Notice that you can apply the operation on the same pile more than once.

Return the minimum possible total number of stones remaining after applying the k operations.

floor(x) is the greatest integer that is smaller than or equal to x (i.e., rounds x down).

&nbsp;
Example 1:

Input: piles = [5,4,9], k = 2
Output: 12
Explanation:&nbsp;Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [5,4,5].
- Apply the operation on pile 0. The resulting piles are [3,4,5].
The total number of stones in [3,4,5] is 12.


Example 2:

Input: piles = [4,3,6,7], k = 3
Output: 12
Explanation:&nbsp;Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [4,3,3,7].
- Apply the operation on pile 3. The resulting piles are [4,3,3,4].
- Apply the operation on pile 0. The resulting piles are [2,3,3,4].
The total number of stones in [2,3,3,4] is 12.


&nbsp;
Constraints:


	1 &lt;= piles.length &lt;= 105
	1 &lt;= piles[i] &lt;= 104
	1 &lt;= k &lt;= 105


class Solution:
    def minStoneSum(self, piles: List[int], k: int) -> int:
        heap = [-p for p in piles]
        heapq.heapify(heap)
        for _ in range(k):
            cur = -heapq.heappop(heap)
            heapq.heappush(heap, -(cur-cur//2))
        return -sum(heap)            
class Solution {
        public int minStoneSum(int[] A, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b)->b - a);
        int res = 0;
        for (int a : A) {
            pq.add(a);
            res += a;
        }
        while (k-- > 0) {
            int a = pq.poll();
            pq.add(a - a / 2);
            res -= a / 2;
        }
        return res;
    }
}
class Solution {
public:
    int minStoneSum(vector<int>& piles, int k) {
        priority_queue<int> pq;
        int sum = 0, curr;

        for (auto pile : piles) {
            pq.push(pile);
            sum += pile;
        }

        while (k--) {
            curr = pq.top();
            pq.pop();
            sum -= curr/2;
            pq.push(curr - curr/2);
        }

        return sum;
    }
};
/**
 * @param {number[]} piles
 * @param {number} k
 * @return {number}
 */

var minStoneSum = function(piles, k) {
    var heapArr = [];
    for (let i=0; i<piles.length; i++){
        heapArr.push(piles[i]);
        heapifyUp();
    }

    function heapifyUp(){
        let currIndex = heapArr.length-1;
        while (heapArr[currIndex] > heapArr[Math.floor((currIndex-1)/2)]){
            swap(currIndex, Math.floor((currIndex-1)/2));
            currIndex = Math.floor((currIndex-1)/2);
        }
    }
    
    function heapifyDown(){
        let currIndex = 0;
        let bigger = currIndex;
        while (heapArr[currIndex*2+1]){
            if (heapArr[currIndex] < heapArr[currIndex*2+1]){
                bigger = currIndex * 2 + 1;
            }
            
            if (heapArr[bigger] < heapArr[currIndex*2+2]){
                bigger = currIndex * 2 + 2;
            }
            
            if (bigger === currIndex){
                break;
            }
            swap(currIndex, bigger);
            currIndex = bigger;
        }
    }
    
    function swap(currIndex, otherIndex){
        let temp = heapArr[currIndex];
        heapArr[currIndex] = heapArr[otherIndex];
        heapArr[otherIndex] = temp;
    }
    
    while (k > 0){
        heapArr[0] -= Math.floor(heapArr[0]/2);
        heapifyDown();
        k--;
    }
    
    return heapArr.reduce((a,num) => a+num, 0);
};
Remove Stones to Minimize the Total