Question

1962. 移除石子使总数最小

English Version

题目描述

给你一个整数数组 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

解法

方法一：贪心 + 优先队列（大根堆）

根据题目描述，为了使得剩下的石子总数最小，我们需要尽可能多地移除石子堆中的石子。因此，每次应该选择数量最多的石子堆进行移除。

我们创建一个优先队列（大根堆） $pq$，用于存储石子堆的数量。初始时，将所有石子堆的数量加入优先队列。

接下来，我们进行 $k$ 次操作。在每一次操作中，我们取出优先队列的堆顶元素 $x$，将 $x$ 减半后重新加入优先队列。

在进行了 $k$ 次操作后，优先队列中所有元素的和即为答案。

时间复杂度 $O(n + k \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 piles 的长度。

class Solution:
  def minStoneSum(self, piles: List[int], k: int) -> int:
    pq = [-x for x in piles]
    heapify(pq)
    for _ in range(k):
      heapreplace(pq, pq[0] // 2)
    return -sum(pq)

class Solution {
  public int minStoneSum(int[] piles, int k) {
    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
    for (int x : piles) {
      pq.offer(x);
    }
    while (k-- > 0) {
      int x = pq.poll();
      pq.offer(x - x / 2);
    }
    int ans = 0;
    while (!pq.isEmpty()) {
      ans += pq.poll();
    }
    return ans;
  }
}

class Solution {
public:
  int minStoneSum(vector<int>& piles, int k) {
    priority_queue<int> pq;
    for (int x : piles) {
      pq.push(x);
    }
    while (k--) {
      int x = pq.top();
      pq.pop();
      pq.push(x - x / 2);
    }
    int ans = 0;
    while (!pq.empty()) {
      ans += pq.top();
      pq.pop();
    }
    return ans;
  }
};

func minStoneSum(piles []int, k int) (ans int) {
  pq := &hp{piles}
  heap.Init(pq)
  for ; k > 0; k-- {
    x := pq.pop()
    pq.push(x - x/2)
  }
  for pq.Len() > 0 {
    ans += pq.pop()
  }
  return
}

type hp struct{ sort.IntSlice }

func (h hp) Less(i, j int) bool { return h.IntSlice[i] > h.IntSlice[j] }
func (h *hp) Push(v any)    { h.IntSlice = append(h.IntSlice, v.(int)) }
func (h *hp) Pop() any {
  a := h.IntSlice
  v := a[len(a)-1]
  h.IntSlice = a[:len(a)-1]
  return v
}
func (h *hp) push(v int) { heap.Push(h, v) }
func (h *hp) pop() int   { return heap.Pop(h).(int) }

function minStoneSum(piles: number[], k: number): number {
  const pq = new MaxPriorityQueue();
  for (const x of piles) {
    pq.enqueue(x);
  }
  while (k--) {
    const x = pq.dequeue().element;
    pq.enqueue(x - ((x / 2) | 0));
  }
  let ans = 0;
  while (pq.size()) {
    ans += pq.dequeue().element;
  }
  return ans;
}