2026-05-21：变成目标数组的最少操作次数。用go语言，给你两个长度为 n 的整数数组 nums 和 target。nums[i] 表示当前位置 i 的当前值，target[i] 表示你希望当前位置 i 最终变成的期望值。

你可以进行任意多次操作（可以不做）。每次操作你要先选定一个整数 x，然后在数组 nums 里找出所有“极大连续区间”：这些区间里的每个位置都等于 x，且该区间在保持全为 x 的前提下，不能再向左或向右扩展（也就是已经是该值 x 的最长连续段，并且是无法再延伸的那种）。

对每个这样的区间 [l, r]，本次操作会把这个区间内的 nums 全部替换成 target 对应位置的值：

把 nums[l…r] 直接改成 target[l…r]。

你的目标是让最终 nums 完全等于 target，问最少需要多少次操作。

1 <= n == nums.length == target.length <= 100000。

1 <= nums[i], target[i] <= 100000。

输入： nums = [1,2,3], target = [2,1,3]。

输出： 2

解释：

选择 x = 1：极大段 [0, 0] 被更新 -> nums 变为 [2, 2, 3]。

选择 x = 2：极大段 [0, 1] 被更新（nums[0] 保持为 2，nums[1] 变为 1） -> nums 变为 [2, 1, 3]。

因此，将 nums 转换为 target 需要 2 次操作。

题目来自力扣3810。

一、分步骤详细推演过程

初始状态

• nums：[1, 2, 3]
• target：[2, 1, 3]
• 已操作次数：0

第一步：执行第 1 次操作

1. 选择 x = 1（最优选择，能最快修正错误位置）
2. 找 nums 中 x=1 的极大连续区间：
   • 遍历数组：只有索引 0 位置是 1，左边无元素、右边是 2（不是1），所以极大区间是 [0, 0]。
3. 执行替换：
   • 把 nums[0] 替换成 target[0]（值为2）。
4. 操作后状态：
   • nums：[2, 2, 3]
   • target：[2, 1, 3]
   • 已操作次数：1

第二步：执行第 2 次操作

1. 选择 x = 2（当前唯一需要修正的错误值）
2. 找 nums 中 x=2 的极大连续区间：
   • 遍历数组：索引 0、1 都是 2，左边无元素、右边是 3（不是2），所以极大区间是 [0, 1]。
3. 执行替换：
   • 把 nums[0~1] 替换成 target[0~1]：
     • nums[0] 原本就是2（和target一致，不变）；
     • nums[1] 替换成 target[1]（值为1）。
4. 操作后状态：
   • nums：[2, 1, 3]
   • target：[2, 1, 3]
   • 已操作次数：2

第三步：终止

此时 nums 与 target 完全相等，停止操作。
最终最少操作次数：2

三、核心解题思路

1. 第一步：筛选差异位置
   遍历两个数组，找出所有 nums[i] ≠ target[i] 的位置，这些位置是必须通过操作修正的。
2. 第二步：统计「需要操作的不同数值」
   每次操作，我们只能选择一个数值x，批量修正所有x的极大区间。
   最少操作次数 = 所有需要修正的位置中，不同数值的数量。
   （示例中需要修正的数值是1和2，共2个，所以答案是2）
3. 第三步：输出结果
   直接返回统计到的不同数值的个数，就是最少操作次数。

四、时间复杂度 & 额外空间复杂度 分析

1. 总时间复杂度

• 核心操作：一次完整遍历数组（遍历所有元素，对比nums和target）+ 哈希表插入/查询操作。
• 数组长度为 n，哈希表的单次操作是 O(1) 常数时间。
• 总时间复杂度：O(n)
  （线性时间，处理10万级数据完全高效）

2. 总额外空间复杂度

• 额外使用了哈希集合存储需要修正的不同数值。
• 哈希集合的最大元素个数：最多等于数组长度 n（极端情况所有位置都需要修正，且数值全不同）。
• 总额外空间复杂度：O(n)
  （线性空间，符合题目数据范围要求）

总结

1. 过程：先选数值x→找x的最长连续段→批量替换为目标值，重复至数组一致；
2. 最少操作次数 = 需要修正的不同数值的个数；
3. 时间复杂度：O(n)（线性遍历）；
4. 空间复杂度：O(n)（哈希集合存储差异数值）。

Go完整代码如下：

package main

import (
	"fmt"
)

func minOperations(nums, target []int) int {
	set := map[int]struct{}{}
	for i, x := range nums {
		if x != target[i] {
			set[x] = struct{}{}
		}
	}
	return len(set)
}

func main() {
	nums := []int{1, 2, 3}
	target := []int{2, 1, 3}
	result := minOperations(nums, target)
	fmt.Println(result)
}

Python完整代码如下：

package main

import (
	"fmt"
)

func minOperations(nums, target []int) int {
	set := map[int]struct{}{}
	for i, x := range nums {
		if x != target[i] {
			set[x] = struct{}{}
		}
	}
	return len(set)
}

func main() {
	nums := []int{1, 2, 3}
	target := []int{2, 1, 3}
	result := minOperations(nums, target)
	fmt.Println(result)
}

C++完整代码如下：

#include <iostream>
#include <vector>
#include <unordered_set>

using namespace std;

int minOperations(vector<int>& nums, vector<int>& target) {
    unordered_set<int> set;
    for (int i = 0; i < nums.size(); i++) {
        if (nums[i] != target[i]) {
            set.insert(nums[i]);
        }
    }
    return set.size();
}

int main() {
    vector<int> nums = {1, 2, 3};
    vector<int> target = {2, 1, 3};
    int result = minOperations(nums, target);
    cout << result << endl;
    return 0;
}