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

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

我们有两个长度相等且不为空的整型数组 A 和 B 。我们可以交换 A[i] 和 B[i] 的元素。注意这两个元素在各自的序列中应该处于相同的位置。在交换过一些元素之后，数组 A 和 B 都应该是严格递增的（数组严格递增的条件仅为A[0] < A[1] < A[2] < … < A[A.length - 1]）。

给定数组 A 和 B ，请返回使得两个数组均保持严格递增状态的最小交换次数。假设给定的输入总是有效的。

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

注意:

A, B 两个数组的长度总是相等的，且长度的范围为 [1, 1000]。
A[i], B[i] 均为 [0, 2000]区间内的整数。

解题思路：来自于六六先森博客的分享：地址

用swap数组中的swap[i]表示第i个元素如果要交换来使得AB成为递增序列那么需要多少次的代价。

用keep数组的keep[i]表示第i个元素不交换使得两个数组依然有序需要多少代价。

举个例子，我们再推导转移方程。

针对A=[1,3,5,4] B=[1,2,3,7]

swap[0]=1,keep[0]=0表示第0个元素为了使其保持有序，交换确实可以，但付出了1次的代价，不交换也可以，0次代价。

swap[1]=2,keep[1]=0,前两个元素满足单调递增条件，如果非要交换来使得顺序成立，那就需要前两个数据都交换，不交换依然可以，0次。

swap[2]=3,keep[2]=0,道理同上一段的推导。

swap[3]=1,keep[3]=3，观察AB的末尾，容易看出其实只要交换了7和4就满足了条件，那么swap就是1。但是如果我不想交换这个元素，那么就需要把前三个都交换一次，就是3.

经过上述的推导，我们发现keep[i],swap[i]总是与keep[i-1],swap[i-1]存在着某种联系。

首先有两种情况：

一、第i个元素是满足增序的，也就是A[i]>A[i-1],B[i]>B[i-1]因为只要保持就可以了，所以keep[i]=keep[i-1]，但是如果要交换，那就比swap[i-1]还多了个第i个元素的代价，也就是swap[i]=swap[i-1]+1.

二、A[i]>B[i-1] 而且B[i]>A[i-1]这种情况满足了“交换使得满足条件”这两个条件应该同时判断，因为谁也不知道那种情况下会有更小的代价。但是如果交换就会是keep[i-1]+1的代价（因为实际上就是翻转了第i个再加上让前i-1个保持的代价），同理keep[i]此时等于swap[i-1]因为不翻转这个，但要翻转前i个。

代码如下。

class Solution:
    def minSwap(self, A: List[int], B: List[int]) -> int:
        n = len(A)
        swap = [0 for _ in range(n)]
        keep = [0 for _ in range(n)]
        swap[0] = 1 # 第一次交换
        for i in range(1,n):
            swap[i] = keep[i] = 0x7fffffff
            # 如果第i个元素是满足增序的，也就是A[i]>A[i-1],B[i]>B[i-1]因为只要保持就可以了，所以keep[i]=keep[i-1]，但是如果要交换，那就比swap[i-1]还多了个第i个元素的代价，也就是swap[i]=swap[i-1]+1.
            if A[i]>A[i-1] and B[i]>B[i-1]:
                swap[i] = swap[i-1] + 1
                keep[i] = keep[i-1]
            # A[i]>B[i-1] 而且B[i]>A[i-1]这种情况满足了“交换使得满足条件”
            if A[i] > B[i-1] and B[i] > A[i-1]:
                swap[i] = min(swap[i],keep[i-1] + 1)
                keep[i] = min(keep[i],swap[i-1])
        return min(keep[n-1],swap[n-1])