2026-05-21：变成目标数组的最少操作次数。用go语言，给定两个长度相同的数组 nums 和 target。 - nums[i] 表示当前位置 i...|nums|target|哈希|复杂度|操作次数|遍历

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{}{}
        }
    }
    returnlen(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{}{}
        }
    }
    returnlen(set)
}

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

C++完整代码如下：

  

  

  


 using namespace std;

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

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