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 <= 105
1 <= nums[i] <= limit <= 105
n 是偶数。

 

这个题是一个枚举最终值的题目，由于这个题的limit的范围不是很大，所以差分可以过

这个题最终值一定是 [2, 2*limit]中的数

设目标值为 target，显然 target ∈ [2, 2*limit]。

对于一对数字 (a,b)，假设 a <= b。则对移动次数的贡献如下：

• target ∈ [2, a+1)，需要操作两次。
• target ∈ [a+1, a+b)，需要操作一次。
• target ∈ [a+b, a+b]，不需要操作。
• target ∈ (a+b, b + limit]，需要操作一次。
• target ∈ (b+limit, 2*limit]，需要操作两次。

这个题看到上面的结论，立马想到这不是差分数组吗，就是支持区间所有数加或者减k，o（n)的复杂度算出最终的状态

然后从2到2*limit中找到操作最小的就行

int a=min(nums[i],nums[n-i-1]);
            int b=max(nums[i],nums[n-i-1]);
            int p0=2;
            int p1=a+1;     // target ∈ [2, a+1)，需要操作两次
            int p2=a+b;     // target ∈ [a+1, a+b)，需要操作一次
                                // target ∈ [a+b, a+b]，不需要操作
            int p3=b+limit; // target ∈ (a+b, b + limit]，需要操作一次 
            int p4=2*limit; // target ∈ (b+limit, 2*limit]，需要操作两次
            
            dis[p0]+=2;
            dis[p1]-=2;// target ∈ [2, a+1)，需要操作两次

            dis[p1]+=1;
            dis[p2]-=1;// target ∈ [a+1, a+b)，需要操作一次

            dis[p2+1]+=1; // target ∈ (a+b, b + limit]，需要操作一次
            dis[p3+1]-=1;

            dis[p3+1]+=2;
            dis[p4+1]-=2;// target ∈ (b+limit, 2*limit]，需要操作两次

 

就是这样

class Solution {
public:
    int minMoves(vector<int>& nums, int limit) {
        vector<int> dis(2*limit+2,0);
        int n=nums.size();
        for(int i=0;i<n/2;i++){
            int a=min(nums[i],nums[n-i-1]);
            int b=max(nums[i],nums[n-i-1]);
            int p0=2;
            int p1=a+1;     // target ∈ [2, a+1)，需要操作两次
            int p2=a+b;     // target ∈ [a+1, a+b)，需要操作一次
                                // target ∈ [a+b, a+b]，不需要操作
            int p3=b+limit; // target ∈ (a+b, b + limit]，需要操作一次 
            int p4=2*limit; // target ∈ (b+limit, 2*limit]，需要操作两次
            
            dis[p0]+=2;
            dis[p1]-=2;// target ∈ [2, a+1)，需要操作两次

            dis[p1]+=1;
            dis[p2]-=1;// target ∈ [a+1, a+b)，需要操作一次

            dis[p2+1]+=1; // target ∈ (a+b, b + limit]，需要操作一次
            dis[p3+1]-=1;

            dis[p3+1]+=2;
            dis[p4+1]-=2;// target ∈ (b+limit, 2*limit]，需要操作两次
        }
        int sum=0;
        int res=INT_MAX;
        for(int i=2;i<=2*limit;i++){
            sum+=dis[i];
            res=min(res,sum);
        }
        return res;
    }
};