前缀和题目：使数组互补的最少操作次数

题目

标题和出处

标题：使数组互补的最少操作次数

出处：1674. 使数组互补的最少操作次数

难度

7 级

题目描述

要求

给定一个长度为偶数 $\text{n}$ 的整数数组 $\text{nums}$ 和一个整数 $\text{limit}$。每一次操作，可以将 $\text{nums}$ 中的任何整数替换为 $\text{1}$ 到 $\text{limit}$ 之间的另一个整数，包含 $\text{1}$ 和 $\text{limit}$。

如果对于所有下标 $\text{i}$（下标从 $\text{0}$ 开始），$\text{nums[i] + nums[n - 1 - i]}$ 都等于同一个数，则数组 $\text{nums}$ 是互补的。例如，数组 $\text{[1,2,3,4]}$ 是互补的，因为对于所有下标 $\text{i}$，$\text{nums[i] + nums[n - 1 - i] = 5}$。

返回使数组 $\text{nums}$ 互补的最少操作次数。

示例

示例 1：

输入：$\text{nums = [1,2,4,3], limit = 4}$
输出：$\text{1}$
解释：经过 $\text{1}$ 次操作，可以将数组 nums 变成 $\text{[1,2,2,3]}$。
$\text{nums[0] + nums[3] = 1 + 3 = 4}$
$\text{nums[1] + nums[2] = 2 + 2 = 4}$
$\text{nums[2] + nums[1] = 2 + 2 = 4}$
$\text{nums[3] + nums[0] = 3 + 1 = 4}$
对于每个 $\text{i}$，$\text{nums[i] + nums[n-1-i] = 4}$，所以 $\text{nums}$ 是互补的。

示例 2：

输入：$\text{nums = [1,2,2,1], limit = 2}$
输出：$\text{2}$
解释：经过 $\text{2}$ 次操作，可以将数组 $\text{nums}$ 变成 $\text{[2,2,2,2]}$。不能将任何数字变更为 $\text{3}$，因为 $\text{3}>\text{limit}$。

示例 3：

输入：$\text{nums = [1,2,1,2], limit = 2}$
输出：$\text{0}$
解释：$\text{nums}$ 已经是互补的。

数据范围

• $\text{n}=\text{nums.length}$
• $\text{2}\le \text{n}\le {\text{10}}^{\text{5}}$
• $\text{1}\le \text{nums[i]}\le \text{limit}\le {\text{10}}^{\text{5}}$
• $\text{n}$ 是偶数

解法

思路和算法

当数组 $\text{nums}$ 互补时，对于所有符合 $0\le i<j<n$ 且 $i+j=n-1$ 的下标 $i$ 和 $j$，$\text{nums}[i]+\text{nums}[j]$ 都是相同的值。

以下将符合 $0\le i<j<n$ 且 $i+j=n-1$ 的下标 $i$ 和下标 $j$ 处的两个元素称为一对元素。

由于数组 $\text{nums}$ 中的每个整数可以替换成 $[1,\text{limit}]$ 范围中的任意整数，因此每一对元素的和的取值范围是 $[2,\text{limit}\times 2]$。令 $\text{sumLimit}=\text{limit}\times 2$，则每一对元素的和的取值范围是 $[2,\text{sumLimit}]$。

用 $\text{target}$ 表示数组 $\text{nums}$ 互补时的每一对元素的和，则 $2\le \text{target}\le \text{sumLimit}$。对于一对元素 $\text{nums}[i]$ 和 $\text{nums}[j]$，将初始时这一对元素的和记为 $\text{sum}$，为了使这一对元素的和变成 $\text{target}$，需要执行 $0$ 次至 $2$ 次操作。

• 如果执行 $0$ 次操作，则这一对元素的和一定是 $\text{sum}$。当 $\text{target}=\text{sum}$ 时，执行 $0$ 次操作即可使这一对元素的和等于 $\text{target}$。

• 如果执行 $1$ 次操作，则将其中的较大元素替换成 $1$ 之后可以得到元素和最小值 $\min (\text{nums}[i],\text{nums}[j])+1$，将其中的较小元素替换成 $\text{limit}$ 之后可以得到元素和最大值 $\max (\text{nums}[i],\text{nums}[j])+\text{limit}$。当 $\min (\text{nums}[i],\text{nums}[j])+1\le \text{target}\le \max (\text{nums}[i],\text{nums}[j])+\text{limit}$ 时，执行 $1$ 次操作即可使这一对元素的和等于 $\text{target}$。

• 当 $\text{target}<\min (\text{nums}[i],\text{nums}[j])+1$ 或 $\text{target}>\max (\text{nums}[i],\text{nums}[j])+\text{limit}$ 时，需要执行 $2$ 次操作才能使这一对元素的和等于 $\text{target}$。

令 $\text{minSumOne}=\min (\text{nums}[i],\text{nums}[j])+1$，$\text{maxSumOne}=\max (\text{nums}[i],\text{nums}[j])+\text{limit}$。根据上述分析可知，$\text{target}$ 在不同区间对应的一对元素的操作次数如下。

• 当 $\text{target}$ 位于区间 $[2,\text{minSumOne}-1]$ 时，操作次数是 $2$。

• 当 $\text{target}$ 位于区间 $[\text{minSumOne},\text{sum}-1]$ 时，操作次数是 $1$。

• 当 $\text{target}=\text{sum}$ 时，操作次数是 $0$。

• 当 $\text{target}$ 位于区间 $[\text{sum}+1,\text{maxSumOne}]$ 时，操作次数是 $1$。

• 当 $\text{target}$ 位于区间 $[\text{maxSumOne}+1,\text{sumLimit}]$ 时，操作次数是 $2$。

为了得到使数组互补的最少操作次数，需要对 $2\le \text{target}\le \text{sumLimit}$ 的每个 $\text{target}$ 计算操作次数。由于每一对元素的和的范围是 $[2,\text{sumLimit}]$，因此直接计算每个 $\text{target}$ 的操作次数的时间复杂度过高。为了降低时间复杂度，需要使用差分数组。

创建长度为 $\text{sumLimit}+1$ 的差分数组 $\text{diffs}$，对于 $1\le k\le \text{sumLimit}$，$\text{diffs}[k]$ 表示 $\text{target}=k$ 和 $\text{target}=k-1$ 对应的操作次数之差。对于每一对元素 $\text{nums}[i]$ 和 $\text{nums}[j]$，更新差分数组的做法如下。

1. 将 $\text{diffs}[\text{minSumOne}]$ 的值减 $1$。

2. 将 $\text{diffs}[\text{sum}]$ 的值减 $1$。

3. 如果 $\text{sum}<\text{sumLimit}$，将 $\text{diffs}[\text{sum}+1]$ 的值加 $1$。

4. 如果 $\text{maxSumOne}<\text{sumLimit}$，将 $\text{diffs}[\text{maxSumOne}+1]$ 的值加 $1$。

遍历数组 $\text{nums}$ 之后，遍历差分数组，计算每个元素和对应的操作次数，得到最少操作次数。具体做法是，将操作次数初始化为 $n$，表示数组中的所有元素都需要替换，对于 $1\le i\le \text{sumLimit}$，将 $\text{diffs}[i]$ 加到操作次数，即可得到元素和 $i$ 对应的操作次数。遍历差分数组结束之后，即可得到最少操作次数。

证明

上述解法中，对于每一对元素分别考虑 $5$ 个区间，按照区间从小到大的顺序，每个区间对应的操作次数依次是 $2$、$1$、$0$、$1$、$2$。

如果每个区间都非空，即区间的长度大于等于 $1$，则上述解法可以得到正确的结果。需要证明：如果存在空区间，即区间的长度等于 $0$，上述解法仍可以得到正确的结果。

操作次数是 $0$ 的区间一定包含一个数，因此不为空。对于其余 $4$ 个区间，为了方便分析，假设 $\text{nums}[i]\le \text{nums}[j]$，则每个变量的值如下：$\text{sumLimit}=\text{limit}\times 2$，$\text{sum}=\text{nums}[i]+\text{nums}[j]$，$\text{minSumOne}=\text{nums}[i]+1$，$\text{maxSumOne}=\text{nums}[j]+\text{limit}$。则其余 $4$ 个区间的等价表示如下。

• $[2,\text{minSumOne}-1]=[2,\text{nums}[i]]$；

• $[\text{minSumOne},\text{sum}-1]=[\text{nums}[i]+1,\text{nums}[i]+\text{nums}[j]-1]$；

• $[\text{sum}+1,\text{maxSumOne}]=[\text{nums}[i]+\text{nums}[j]+1,\text{nums}[j]+\text{limit}]$；

• $[\text{maxSumOne}+1,\text{sumLimit}]=[\text{nums}[j]+\text{limit}+1,\text{limit}\times 2]$。

用 $[\text{start},\text{end}]$ 表示每个区间，则区间的长度是 $\max (0,\text{end}-\text{start}+1)$。由于 $1\le \text{nums}[i]\le \text{nums}[j]\le \text{limit}$，因此这 $4$ 个区间都满足 $\text{end}\ge \text{start}-1$，即当区间为空时一定有 $\text{end}=\text{start}-1$。

用区间 $[\text{start},\text{end}]$ 更新差分数组时，做法是将差分数组的下标 $\text{start}$ 处的元素加 $1$ 并将下标 $\text{end}+1$ 处的元素减 $1$，或者将差分数组的下标 $\text{start}$ 处的元素减 $1$ 并将下标 $\text{end}+1$ 处的元素加 $1$。当区间 $[\text{start},\text{end}]$ 为空时，$\text{end}+1=\text{start}$，因此更新差分数组的效果是两次更新抵消，不会更新差分数组的任何元素值。

因此，如果存在空区间，上述解法仍可以得到正确的结果。

代码

class Solution {
    public int minMoves(int[] nums, int limit) {
        int sumLimit = limit * 2;
        int[] diffs = new int[sumLimit + 1];
        int n = nums.length;
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            int sum = nums[i] + nums[j];
            int minSumOne = Math.min(nums[i], nums[j]) + 1;
            int maxSumOne = Math.max(nums[i], nums[j]) + limit;
            diffs[minSumOne]--;
            diffs[sum]--;
            if (sum < sumLimit) {
                diffs[sum + 1]++;
            }
            if (maxSumOne < sumLimit) {
                diffs[maxSumOne + 1]++;
            }
        }
        int minimumMoves = n, moves = n;
        for (int i = 1; i <= sumLimit; i++) {
            moves += diffs[i];
            minimumMoves = Math.min(minimumMoves, moves);
        }
        return minimumMoves;
    }
}

复杂度分析

• 时间复杂度：$O(n+\text{limit})$，其中 $n$ 是数组 $\text{nums}$ 的长度，$\text{limit}$ 是允许替换成的最大整数。需要创建长度为 $\text{limit}\times 2+1$ 的差分数组，需要遍历数组 $\text{nums}$ 一次更新差分数组的值，需要遍历差分数组一次计算最少操作次数，因此时间复杂度是 $O(n+\text{limit})$。

• 空间复杂度：$O(\text{limit})$，其中 $\text{limit}$ 是允许替换成的最大整数。需要创建长度为 $\text{limit}\times 2+1$ 的差分数组。