动态规划之使序列递增的最小交换次数

LeetCode 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]区间内的整数。

思路：
两个数组的元素，到底要不要交换，是决定最后交换次数的关键。因此，每一列元素，都有两个状态，换或者不换。

如果只有一列：那么dp = [0, 1]
dp[0] = 0, 不做交换，总交换数为0.
dp[1] = 1, 做交换，总交换数为1，同时也满足最后的要求，是一个递增数列，因为数组只有一个元素。

如果有两列， 假设 a1 = A[i - 1], b1 = B[i - 1] 以及 a2 = A[i], b2 = B[i]， i = 1
相对的有4中情况
（1）a1 < a2 并且 b1 < b2　例如　[1,3]和[1,4]
表明，当前列相对前一列，可以不做交换，因为条件已经满足了。
（2）a1 < b2 并且 b1 < a2 例如 [1,5]和[4, 3],对角满足严格递增
表明，当前列相对前一列，可以做交换，因为交换了条件可以满足。
（3） not a1 < a2 或者 not b1 < b2　任何一个非递增，就需要交换
是（1）取反，当前列相对前一列必须交换，这里的交换是相对的，如果前一列已经交换了，当前列可以不动。
（4）not a1 < b2 或者 not b1 < a2　对角不满足递增，不能交换
是（2）取反，当前列相对前一列必须不能换。

（1）（2）是可以共存的，比如[1, 3] 和 [1, 2]。且（1）（2）是模糊的，可以换，可以不换

对于（3）
new_dp[0] = dp[1]，要想当前列不动，那么前一列必须是换过的。
new_dp[1] = dp[0] + 1，要想当前列换，前一列必须没动过。总之，对于情况（3），与前一列操作相反就对了。

对于（4）
new_dp[0] = dp[0]，要想当前列不动，那么前一列必须也不动。
new_dp[1] = dp[1] + 1，要想当前列换，前一列必须也换过。总之，对于情况（4），与前一列操作相同就对了。

但是（3）（4）并没有包括全部的情况。对于（1）（2），可换可不换，按照贪心原则，那就是能不换就不换。
new_dp[0] = min(dp[0], dp[1])，管你前面换没换过，我是取小的那个数，然后就不换了。
new_dp[1] = min(dp[0], dp[1]) + 1，管你前面换没换过，我是取小的那个数，然后换一下，因为dp[1]对应的就是当前列交换的情况，所以不管怎么样，这个数值必须对应当前列交换这个操作。

class Solution:
    def minSwap(self, A: List[int], B: List[int]) -> int:
        dp = [0, 1]
        # dp[0]代表不交换，dp[1]代表交换
        for i in range(1, len(A)):
            a1, a2 = A[i - 1], A[i]
            b1, b2 = B[i - 1], B[i]
            if a1 >= a2 or b1 >= b2:
                # 任意一个逆序，都需要交换，如果前面交换，当前不交换，如果前面不交换，当前要交换
                dp[0], dp[1] = dp[1], dp[0] + 1
            elif a1 >= b2 or b1 >= a2:
                # 对角线不满足, 不能交换，如果前面交换，当前也要交换，如果前面不交换，当前也不交换
                dp[0], dp[1] = dp[0], dp[1] + 1
            else:
                # 可交换，可不交换，贪心思想，选取最小的
                mini = min(dp)
                dp[0] = mini
                dp[1] = mini + 1
        return min(dp)