<p>You are given a <strong>0-indexed</strong> integer array <code>piles</code>, where <code>piles[i]</code> represents the number of stones in the <code>i<sup>th</sup></code> pile, and an integer <code>k</code>. You should apply the following operation <strong>exactly</strong> <code>k</code> times:</p>

<ul>
	<li>Choose any <code>piles[i]</code> and <strong>remove</strong> <code>floor(piles[i] / 2)</code> stones from it.</li>
</ul>

<p><strong>Notice</strong> that you can apply the operation on the <strong>same</strong> pile more than once.</p>

<p>Return <em>the <strong>minimum</strong> possible total number of stones remaining after applying the </em><code>k</code><em> operations</em>.</p>

<p><code>floor(x)</code> is the <b>greatest</b> integer that is <strong>smaller</strong> than or <strong>equal</strong> to <code>x</code> (i.e., rounds <code>x</code> down).</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

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

<p><strong class="example">Example 2:</strong></p>

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

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= piles.length &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= piles[i] &lt;= 10<sup>4</sup></code></li>
	<li><code>1 &lt;= k &lt;= 10<sup>5</sup></code></li>
</ul>

class Solution {
public:
    int heapsize;

    void MaxHeapify(vector<int> &p,int i){
        int l=2*i+1; //figlio sinistro
        int r=2*i+2; //figlio destro
        int largest = i;

        if(l<heapsize && p[l] > p[largest]){
            largest = l;
        }

        if(r<heapsize && p[r] > p[largest]){
            largest = r;
        }

        if(largest != i){
            swap(p[i],p[largest]);
            MaxHeapify(p,largest);
        }
    }

    void BuildMaxHeap(vector<int> &p){
        heapsize = p.size();
        for(int i=(p.size()/2)-1;i>=0;i--){
            MaxHeapify(p,i);
        }
    }


    //scelta greedy : scelgo la pila con piu pietre in ogni istante 
    //maggiore riduzione di pietre
    int minStoneSum(vector<int>& piles, int k) {
        
        int tot_stones = 0;
        for(int i=0;i<piles.size();i++){
            tot_stones += piles[i];
        }

        BuildMaxHeap(piles);

        int stones = 0;
        for(int i=0;i<k;i++){
            stones += floor(piles[0]/2);
            piles[0] -= floor(piles[0]/2);
            MaxHeapify(piles,0);
        }
        return tot_stones - stones;
    }
};
97200