LeetCode 2208. 将数组和减半的最少操作次数

2208. 将数组和减半的最少操作次数

给你一个正整数数组 nums 。每一次操作中，你可以从 nums 中选择 任意 一个数并将它减小到 恰好 一半。（注意，在后续操作中你可以对减半过的数继续执行操作）

请你返回将 nums 数组和 至少 减少一半的 最少 操作数。

示例 1：

输入：nums = [5,19,8,1]
输出：3
解释：初始 nums 的和为 5 + 19 + 8 + 1 = 33 。
以下是将数组和减少至少一半的一种方法：
选择数字 19 并减小为 9.5 。
选择数字 9.5 并减小为 4.75 。
选择数字 8 并减小为 4 。
最终数组为 [5, 4.75, 4, 1] ，和为 5 + 4.75 + 4 + 1 = 14.75 。
nums 的和减小了 33 - 14.75 = 18.25 ，减小的部分超过了初始数组和的一半，18.25 >= 33/2 = 16.5 。
我们需要 3 个操作实现题目要求，所以返回 3 。
可以证明，无法通过少于 3 个操作使数组和减少至少一半。

示例 2：

输入：nums = [3,8,20]
输出：3
解释：初始 nums 的和为 3 + 8 + 20 = 31 。
以下是将数组和减少至少一半的一种方法：
选择数字 20 并减小为 10 。
选择数字 10 并减小为 5 。
选择数字 3 并减小为 1.5 。
最终数组为 [1.5, 8, 5] ，和为 1.5 + 8 + 5 = 14.5 。
nums 的和减小了 31 - 14.5 = 16.5 ，减小的部分超过了初始数组和的一半， 16.5 >= 31/2 = 15.5 。
我们需要 3 个操作实现题目要求，所以返回 3 。
可以证明，无法通过少于 3 个操作使数组和减少至少一半。

提示：

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^7

---

提示 1

It is always optimal to halve the largest element.

---

提示 2

What data structure allows for an efficient query of the maximum element?

---

提示 3

Use a heap or priority queue to maintain the current elements.

解法1：贪心 + 大顶堆（优先队列）

基于贪心的思想，将数组和减半的操作次数最小化的做法为：每次操作都选择当前数组的最大值进行减半操作。

证明：假设某一种做法（该做法操作次数最小）的某一步操作没有选择对最大值 x 进行操作，而是选择对 y 进行操作，那么有两种情况：
1.后续的操作都没有选择对 x 进行操作，那么我们将后续（包括当前操作）所有对 y 的操作替换成对 x 的操作，操作次数不变；
2.后续的某一步操作选择对 x 进行操作，那么我们可以交换这两步操作，操作次数不变。

将数组所有元素都放入一个浮点数优先队列（最大堆）中，使用 total 记录初始数组和，reduction 记录减少和，当 reduction ​< total / 2​ 时，重复以下步骤：

1. 从优先队列中取出最大元素 x；
2. 令 reduction += x / 2 ；
3. 将 x​ /2 放入优先队列中。

返回执行步骤次数即可。

Java版：

class Solution {
    public int halveArray(int[] nums) {
        PriorityQueue<Double> q = new PriorityQueue<>(
            (a, b) -> {
                return a < b ? 1 : -1;
            }
        );
        double total = 0;
        for (int num : nums) {
            total += num;
            q.offer((double) num);
        }
        total /= 2;
        double reduction = 0.0;
        int cnt = 0;
        while (reduction < total) {
            double t = q.poll() / 2;
            reduction += t;
            q.offer(t);
            cnt++;
        }
        return cnt;
    }
}

Python3版：

class Solution:
    def halveArray(self, nums: List[int]) -> int:
        q = [-i for i in nums]
        heapify(q)
        total = sum(nums) / 2
        reduction = 0
        cnt = 0
        while reduction < total:
            x = -heappop(q) / 2
            reduction += x
            heappush(q, -x)
            cnt += 1
        return cnt

复杂度分析

• 时间复杂度：O(nlogn)，其中 n 是数组 nums 的长度。将数组和减半最多不超过 n 次操作，每次操作需要 O(logn)。
• 空间复杂度：O(n)。保存优先队列需要 O(n) 的空间。