leetcode 1674. 使数组互补的最少操作次数 中等

给你一个长度为偶数 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 是偶数。

分析：考虑 nums 中任意符合题意的数对 (a,b)，其中 a 是两者中的较小值，b 是两者中的较大值。假设此时目标是将所有的 (a,b) 之和修改到 c，易得 c 的取值范围是 2,2×limit，根据 c 的取值不同，某个数对 (a,b) 需要的最小修改次数有如下五种情况：

当 2≤c<a+1 时：需要操作 2 次。即使将较大的数 b 变为极小值 1，新的数对和 a+1 依然大于 c，因此必须将 a 和 b 同时修改。

当 a+1≤c<a+b 时：需要操作 1 次。只需将较大的数 b 减小到 c−a 即可，修改后的 c−a 必然落在合法范围 1≤c−a≤limit 内。

当 c=a+b 时：此时无需修改。

当 a+b<c≤b+limit 时：需要操作 1 次。只需将较小的数 a 增大到 c−b 即可，修改后的 c−b 必然落在合法范围 1≤c−b≤limit 内。

当 b+limit<c≤2×limit 时：需要操作 2 次。即使将较小的数 a 变为极大值 limit，新的数对和 b+limit 依然小于 c，因此必须将 a 和 b 同时修改。

观察以上五种情况，可以发现对于给定的数对 (a,b) 和修改目标 c，其需要的操作次数在 2,2×limit 的各个连续子区间上是一定的，且分界点可以直接计算。这意味着每对数在不同目标值 c 下需要操作数可以使用差分数组来维护，其前缀和就是当前目标 c 下的总操作次数。维护该操作次数并取最小值即可。

int minMoves(int* nums, int numsSize, int limit) {
    int n=numsSize,m=limit*2+2;
    int diff[m];
    for(int i=0;i<m;++i)
        diff[i]=0;
    for(int i=0;i<n/2;++i)
    {
        int a=fmin(nums[i],nums[n-1-i]);
        int b=fmax(nums[i],nums[n-1-i]);

        diff[2]+=2;
        diff[a+1]-=1;
        diff[a+b]-=1;
        diff[a+b+1]+=1;
        diff[b+limit+1]+=1;
    }

    int min_ops=n,cur_ops=0;
    for(int c=2;c<=2*limit;++c)
    {
        cur_ops+=diff[c];
        if(cur_ops<min_ops)min_ops=cur_ops;
    }
    return min_ops;
}