目标
给你一个长度为 偶数 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 和一个整数 limit，每次操作可以将任意元素替换为 [1, limit] 中的任意整数，求使得 nums 互补的最少操作次数。所谓互补指 nums[i] + nums[n - 1 - i] 的和都相等。
由于 1 <= nums[i] <= limit，每一对元素和都可以变成 [2, 2 * limit] 中的任意数字。
令 a = nums[i], b = nums[n - 1 - i], sum = a + b，如果只操作一次，考虑左侧 a -> 1 或者 b -> 1，sum 最多变化 max(a, b) - 1；右侧 a -> limit 或者 b -> limit，sum 最多变化 limit - min(a, b)。
- 将
sum变成区间[sum - (max(a, b) - 1), sum - 1], [sum + 1, sum + limit - min(a, b)]内的值需要操作一次 - 变成
sum的操作次数不变 - 其它
[2, sum - (max(a, b) - 1) - 1], [sum + limit - min(a, b) + 1, 2 * limit]需要操作两次
使用差分数组来记录每对元素和变成目标和所需的操作次数，最后遍历所有目标和，取操作次数最小的即可。
代码
/**
* @date 2026-05-13 10:13
*/
public class MinMoves1674 {
public int minMoves(int[] nums, int limit) {
int n = nums.length;
int max = 2 * limit;
int[] diff = new int[max + 2];
for (int i = 0; i < n / 2; i++) {
int a = nums[i];
int b = nums[n - 1 - i];
int sum = a + b;
int l = sum - (Math.max(a, b) - 1);
int r = sum + (limit - Math.min(a, b));
diff[2] += 2;
diff[Math.max(2, l)]--;
diff[sum]--;
diff[Math.min(sum + 1, max + 1)]++;
diff[Math.min(r + 1, max + 1)]++;
}
int sum = 0, res = Integer.MAX_VALUE;
for (int i = 2; i <= max; i++) {
sum += diff[i];
res = Math.min(sum, res);
}
return res;
}
}
性能
