題目描述：

給你一個整數陣列 piles ，陣列 下標從 0 開始 ，其中 piles[i] 表示第 i 堆石子中的石子數量。另給你一個整數 k ，請你執行下述操作 恰好 k 次：

選出任一石子堆 piles[i] ，並從中 移除 floor(piles[i] / 2) 顆石子。
注意：你可以對 同一堆 石子多次執行此操作。

返回執行 k 次操作後，剩下石子的 最小 總數。

floor(x) 為 小於 或 等於 x 的 最大 整數。（即，對 x 向下取整）。



示例 1：

輸入：piles = [5,4,9], k = 2
輸出：12
解釋：可能的執行情景如下：
- 對第 2 堆石子執行移除操作，石子分佈情況變成 [5,4,5] 。
- 對第 0 堆石子執行移除操作，石子分佈情況變成 [3,4,5] 。
剩下石子的總數為 12 。
示例 2：

輸入：piles = [4,3,6,7], k = 3
輸出：12
解釋：可能的執行情景如下：
- 對第 2 堆石子執行移除操作，石子分佈情況變成 [4,3,3,7] 。
- 對第 3 堆石子執行移除操作，石子分佈情況變成 [4,3,3,4] 。
- 對第 0 堆石子執行移除操作，石子分佈情況變成 [2,3,3,4] 。
剩下石子的總數為 12 。


提示：

1 
 
<= piles.length <= 105
1 <= piles[i] <= 104
1 <= k <= 105

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/remove-stones-to-minimize-the-total
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

解題思路：

public class RemoveStone {
    //元素可以改變順序！！超時！！
    public int minStoneSum(int[] piles, int k) {
        
 
for(int i = 0; i < k; i++){
            int max_number = 0;//當前輪最大的數值
            int max_number_index = 0;//當前值最大的下標
            for(int j = 0; j < piles.length; j++ ){
                if(piles[j] > max_number){
                    max_number_index = j;
                    max_number = piles[j];
                }
            }
            
 
//去除當前值最的number的一半
            piles[max_number_index] -= (int) Math.floor(piles[max_number_index]/2);
        }
        int sum = 0;
        for(int i = 0; i < piles.length; i++){
            sum += piles[i];
        }
        return sum;
    }

    public int minStoneSum1(int[] piles, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>((a,b) -> b-a);//構建大頂堆
        //將piles中元素入隊
        for(int i = 0; i < piles.length; i++){
            pq.add(piles[i]);
        }
        //取堆頂元素減少一半並且重新放會堆中,迴圈k次
        //堆新增元素時間複雜度O(log N)
        for(int j = 0; j < k; j++){
            int top_que = pq.poll();
            top_que -= Math.floor(top_que/2.0);
            pq.add(top_que);
        }
        //計算和
        int sum = 0;
        for(Integer q: pq){
            sum += q;
        }
        return sum;
    }
    public int minStoneSum2(int[] piles, int k) {
        List<Integer> piles_list = new ArrayList<>();
        //將陣列轉換為list  超時！！
        for(int i = 0; i< piles.length;i++){
            piles_list.add(piles[i]);
        }

        //Collection.sort()採用的排序演算法是一種改進的歸併排序，歸併演算法的時間複雜度是O(nlog n)
        for(int j = 0; j < k; j++){
            piles_list.sort((a,b)->b-a);//先對list進行倒序排序
            piles_list.set(0, piles_list.get(0)-(int) Math.floor(piles_list.get(0)/2.0));//設定第一個值減少原來的一半
        }
        int sum =0;
        for(Integer q : piles_list){
            sum += q;
        }
        return sum;
    }
    public static void main(String[] args) {
        int[] piles = new int[]{4,3,6,7};
        int k = 3;
        RemoveStone rs = new RemoveStone();
        int result = rs.minStoneSum2(piles, k);
        System.out.println(result);
    }
}