Leetcode 801. 使序列递增的最小交换次数

我们有两个长度相等且不为空的整型数组 nums1 和 nums2 。在一次操作中，我们可以交换 nums1[i] 和 nums2[i]的元素。

• 例如，如果 nums1 = [1,2,3,8] ， nums2 =[5,6,7,4] ，你可以交换 i = 3 处的元素，得到 nums1 =[1,2,3,4] 和 nums2 =[5,6,7,8] 。
  返回 使 nums1 和 nums2 严格递增 所需操作的最小次数 。

数组 arr 严格递增 且 arr[0] < arr[1] < arr[2] < … < arr[arr.length - 1] 。

注意：

• 用例保证可以实现操作。

示例 1:

输入: nums1 = [1,3,5,4], nums2 = [1,2,3,7]
输出: 1
解释: 交换 A[3] 和 B[3]后，两个数组如下:
A = [1, 3, 5, 7] ， B = [1, 2, 3, 4]
两个数组均为严格递增的。

示例 2:

输入: nums1 = [0,3,5,8,9], nums2 = [2,1,4,6,9]
输出: 1

提示:

2 <= nums1.length <= 10^5
nums2.length == nums1.length
0 <= nums1[i],nums2[i] <= 2 * 10^5

第一想法是边换边排序，记录次数，当啥时候列表和排序后的列表相等了，就输出次数。

# python
class Solution:
    def minSwap(self, nums1: List[int], nums2: List[int]) -> int:
        n1 = sorted(nums1)
        n2 = sorted(nums2)
        print(n1)
        temp = -1
        times = 0
        while nums1 != n1:
            for i in range(len(nums1)):
                if n1[i] != nums1[i]:
                    nums1[i], nums2[i] = nums2[i], nums1[i]
                    times += 1
                    n1 = sorted(nums1)
                    break
        # return times
        while nums2 != n2:
            for i in range(len(nums2)):
                if n2[i] != nums2[i]:
                    nums2[i], nums1[i] = nums1[i], nums2[i]
                    times += 1
                    n2 = sorted(nums2)
                    break
        return times

通过测试用例： 48 / 117
输入： [1,3,5,4] [1,2,3,7]
输出： 2
预期结果： 1

然后想着干脆直接暴力换吧，又重写

class Solution:
    def minSwap(self, nums1: List[int], nums2: List[int]) -> int:
        listlength = len(nums1)
        times = 0
        for i in range(listlength - 1):
            if nums1[i] > nums1[i+1] or nums2[i] > nums2[i+1] :
                nums1[i+1], nums2[i+1] = nums2[i+1], nums1[i+1]
                times += 1
            if nums1[i] == nums1[i+1] or nums2[i] == nums2[i+1]:
                if i+2 < listlength-1:
                    if nums1[i+1] >= nums2[i+2] or nums2[i+1] >= nums1[i+2]:
                        nums1[i], nums2[i] = nums2[i], nums1[i]
                    else:
                        nums1[i+1], nums2[i+1] = nums2[i+1], nums1[i+1]
                else:
                        nums1[i+1], nums2[i+1] = nums2[i+1], nums1[i+1]
                times += 1
        return times

通过测试用例：
87 / 117
输入：
[0,3,4,9,10]
[2,3,7,5,6]
输出：
2
预期结果：
1

不会了，看题解，清一色动态规划。
我知道有动态规划这东西，我知道那是啥，但是我不会写，哈哈tmd。
然后我就找不是动态规划的题解，还真有!

作者：shapo
链接：https://leetcode.cn/problems/minimum-swaps-to-make-sequences-increasing/solution/by-shapo-j8jt/

按着这个老哥的代码写了之后提交成功。

#python3
class Solution:
       def minSwap(self, nums1: List[int], nums2: List[int]) -> int:
            period_start = 0
            result = 0
            count = 0
            cur = 1
            length = len(nums1)
            while cur < length :
                if nums1[cur] <= nums1[cur - 1] or nums2[cur] <= nums2[cur - 1] :
                    count += 1
                    nums1[cur], nums2[cur] = nums2[cur], nums1[cur] 
                elif nums1[cur] > nums2[cur - 1] and nums2[cur] > nums1[cur - 1] :
                    result += min(count, cur - period_start  - count)
                    count = 0
                    period_start = cur
                cur += 1
            result += min(count, cur - period_start - count)
            return result

min(count, cur - period_start - count)，min中cur - period_start - count 老哥的解释为

一段区间完成交换之后，它们的序列是固定的，而且这两段序列分别出现在 nums1 或者 nums2 都是合法的。

如果我不交换第一对元素，后续的元素就会根据第一对元素依次确定，需要交换的次数是 count；

如果我交换第一对元素，后续元素正好是1中元素互换，需要交换的次数是区块大小减去 count，即cur-period_start-count。
所以处理过程中不需要交换第一对元素，只需要计count，区间处理完后直接计算两种情况中的较小值。

也可以看这个老哥的解释也很好：

作者：qun-yue
链接：https://leetcode.cn/problems/minimum-swaps-to-make-sequences-increasing/solution/dpzhi-wai-de-ling-yi-chong-si-lu-by-qun-fypob/

动态规划看这个题解的解释还蛮好的。
作者：haonshi
链接：https://leetcode.cn/problems/minimum-swaps-to-make-sequences-increasing/solution/by-haonshi-cys6/