JAVA程序设计：使数组互补的最少操作次数（LeetCode：5615）

给你一个长度为 偶数 n 的整数数组 nums 和一个整数 limit 。每一次操作，你可以将 nums 中的任何整数替换为 1 到 limit 之间的另一个整数。

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

返回使数组 互补 的 最少 操作次数。

 

示例 1：

输入：nums = [1,2,4,3], limit = 4
输出：1
解释：经过 1 次操作，你可以将数组 nums 变成 [1,2,2,3]（加粗元素是变更的数字）：
nums[0] + nums[3] = 1 + 3 = 4.
nums[1] + nums[2] = 2 + 2 = 4.
nums[2] + nums[1] = 2 + 2 = 4.
nums[3] + nums[0] = 3 + 1 = 4.
对于每个 i ，nums[i] + nums[n-1-i] = 4 ，所以 nums 是互补的。
示例 2：

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

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

提示：

n == nums.length
2 <= n <= 10^5
1 <= nums[i] <= limit <= 10^5
n 是偶数。

思路：差分数组的应用，老套路题了，不得不说差分数组确实是一种比较经典的骚操作。

我们定义数组sum[x]表示将当前对称两个元素的和变为x的操作次数，我们可以清楚的是：

当target<1+a时，需要操作两次；
当1+a≤target<a+b时，需要操作一次；
当target=a+b时，不需要操作；
当a+b<target≤b+limit时，需要操作一次；
当target>b+limit时，需要操作两次。

所以，我们遍历每一组 nums[i] 和 nums[n-1-i]，然后先将 [2, 2*limit] 的范围需要的操作数 + 2。之后，将 [1 + min(A, B), limit + max(A, B)] 的范围需要的操作数 -1（即 2-1 = 1，操作 1 次）；之后，将 [A + B] 位置的值再 -1（即 1-1=0，操作 0 次）。

class Solution {
    public int minMoves(int[] nums, int limit) {
        int ans = 200005;
        int n = nums.length;
        int[] sum = new int[200005];
        for (int i = 0; i < n / 2; i++) {
            int l = Math.min(nums[i], nums[n - i - 1]); 
            int r = Math.max(nums[i], nums[n - i - 1]);
            int target = l + r;
            sum[2] += 2;
            sum[l + 1]--;
            sum[target]--;
            sum[target + 1]++;
            sum[r + limit + 1]++;
        }
        for (int i = 2; i < 200001; i++) {
            sum[i] += sum[i - 1];
            ans = Math.min(ans, sum[i]);
        }
        return ans;
    }
}