优先队列题目：多次求和构造目标数组

题目

标题和出处

标题：多次求和构造目标数组

出处：1354. 多次求和构造目标数组

难度

7 级

题目描述

要求

给你一个由 $\text{n}$ 个整数组成的数组 $\text{target}$。初始数组 $\text{arr}$ 由 $\text{n}$ 个 $\text{1}$ 组成，你可以执行以下操作：

• 令 $\text{x}$ 为你的数组中的所有元素之和。
• 选择下标 $\text{i}$，满足 $\text{0}\le \text{i}<\text{n}$，将 $\text{arr}$ 的下标 $\text{i}$ 处的值设为 $\text{x}$。
• 你可以重复该过程任意次。

如果可以从 $\text{arr}$ 开始构造出目标数组 $\text{target}$，返回 $\text{true}$，否则返回 $\text{false}$。

示例

示例 1：

输入：$\text{target = [9,3,5]}$
输出：$\text{true}$
解释：从 $\text{arr = [1, 1, 1]}$ 开始。
$\text{[1, 1, 1]}$，和为 $\text{3}$，选择下标 $\text{1}$。
$\text{[1, 3, 1]}$，和为 $\text{5}$，选择下标 $\text{2}$。
$\text{[1, 3, 5]}$，和为 $\text{9}$，选择下标 $\text{0}$。
$\text{[9, 3, 5]}$ 完成。

示例 2：

输入：$\text{target = [1,1,1,2]}$
输出：$\text{false}$
解释：不可能从 $\text{[1,1,1,1]}$ 出发构造目标数组。

示例 3：

输入：$\text{target = [8,5]}$
输出：$\text{true}$

数据范围

• $\text{n}=\text{target.length}$
• $\text{1}\le \text{n}\le \text{5}\times {\text{10}}^{\text{4}}$
• $\text{1}\le \text{target[i]}\le {\text{10}}^{\text{9}}$

解法

思路和算法

这道题最容易想到的思路是从初始数组开始模拟所有的可能性，但是可能性太多，会超出时间限制，因此需要考虑其他思路。

由于初始数组的元素都是 $1$，都是正整数，每次操作都是将数组中的一个元素替换成数组中的所有元素之和，因此每次操作的结果都是将数组中的一个元素值增加，且变化后的元素一定是数组中的最大元素。只要找到数组中的最大元素，即可知道在最后一次操作之前的数组中的所有元素之和，从而将数组恢复到最后一次操作之前的状态。

由此可以反向思考，即从目标数组开始，每次计算上一个状态，判断是否可以得到初始数组。

为了能得到数组中的最大元素，可以使用基于大根堆的优先队列存储数组中的所有元素，优先队列的队首元素即为数组中的最大元素。遍历数组 $\text{target}$，将所有元素加入优先队列，并计算所有元素之和，记为 $\text{sum}$，然后进行反向操作。

将优先队列的队首元素取出，记为 $\text{curr}$，数组中的其他元素之和为 $\text{remainSum}=\text{sum}-\text{curr}$，则在最后一次操作之前，数组中的所有元素之和为 $\text{curr}$，因此 $\text{curr}$ 元素的上一个值为 $\text{prev}=\text{curr}-\text{remainSum}$。将 $\text{sum}$ 的值减去 $\text{curr}-\text{prev}$，将 $\text{prev}$ 加入优先队列，则 $\text{sum}$ 为最后一次操作之前的数组中的所有元素之和，优先队列中的元素为最后一次操作之前的数组中的所有元素。重复上述反向操作，如果能到达初始数组，即数组中的所有元素都是 $1$，则返回 $\text{true}$，如果出现数组中的元素小于 $1$ 的情况，则返回 $\text{false}$。

当数组中的最大元素远大于数组中的其他元素之和时，上述反向操作的做法仍然会超时。注意到当 $\text{curr}>\text{remainSum}$ 时，数组中的最大元素一定是 $\text{curr}$，且 $\text{remainSum}$ 的值不会变化，因此每次反向操作都会使 $\text{curr}$ 的值减少 $\text{remainSum}$，直到 $\text{curr}\le \text{remainSum}$ 时数组中的最大元素才可能不是 $\text{curr}$。因此可以一步计算 $\text{prev}$，令 $\text{prev}$ 为 $\text{curr}$ 减去若干个 $\text{remainSum}$ 之后的值且满足 $1\le \text{prev}\le \text{remainSum}$，具体计算方法如下：

• 如果 $\text{curr}\mathrm{mod}\text{remainSum}=0$，则 $\text{prev}=\text{remainSum}$；

• 如果 $\text{curr}\mathrm{mod}\text{remainSum}\ne 0$，则 $\text{prev}=\text{curr}\mathrm{mod}\text{remainSum}$。

得到 $\text{prev}$ 之后，将 $\text{sum}$ 的值减去 $\text{curr}-\text{prev}$，将 $\text{prev}$ 加入优先队列，即达到用 $\text{prev}$ 更新 $\text{curr}$ 的效果。

上述反向操作的过程必须保证数组中的全部元素都大于 $0$。如果在某一步反向操作之后，数组中的全部元素之和等于 $n$，则恢复到初始数组，返回 $\text{true}$。

如果在反向操作的过程中出现 $\text{remainSum}=0$ 或者 $\text{curr}-\text{remainSum}<1$ 的情况，则说明反向操作会导致数组中出现小于 $1$ 的元素，返回 $\text{false}$。

代码

class Solution {
    public boolean isPossible(int[] target) {
        PriorityQueue<Long> pq = new PriorityQueue<Long>(new Comparator<Long>() {
            public int compare(Long num1, Long num2) {
                return num2.compareTo(num1);
            }
        });
        long sum = 0;
        for (int num : target) {
            sum += num;
            pq.offer((long) num);
        }
        int n = target.length;
        while (sum > n) {
            long curr = pq.poll();
            long remainSum = sum - curr;
            if (remainSum == 0 || curr - remainSum < 1) {
                return false;
            }
            long prev = curr % remainSum == 0 ? remainSum : curr % remainSum;
            sum -= curr - prev;
            pq.offer(prev);
        }
        return sum == n;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

复杂度分析

• 时间复杂度：$O(n\log n\times \log m)$，其中 $n$ 是数组 $\text{target}$ 的长度，$m$ 是数组 $\text{target}$ 的最大元素。
  由于每次反向操作都使数组的最大元素至少减少一半，因此数组中的每个元素最多需要 $O(\log m)$ 反向操作即可减少到 $1$，将 $n$ 个元素都减少到 $1$ 需要的反向操作次数是 $O(n\log m)$。
  由于每次反向操作需要对优先队列进行取出元素和添加元素操作，优先队列中有 $n$ 个元素，每次将元素从优先队列中取出和加入优先队列的时间复杂度是 $O(\log n)$，因此总时间复杂度是 $O(n\log n\times \log m)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{target}$ 的长度。空间复杂度主要取决于优先队列，优先队列中的元素个数不会超过 $n$。