LeetCode – 801. Minimum Swaps To Make Sequences Increasing

We have two integer sequences A and B of the same non-zero length.

We are allowed to swap elements A[i] and B[i].  Note that both elements are in the same index position in their respective sequences.

At the end of some number of swaps, A and B are both strictly increasing.  (A sequence is strictly increasing if and only if A[0] < A[1] < A[2] < ... < A[A.length - 1].)

Given A and B, return the minimum number of swaps to make both sequences strictly increasing.  It is guaranteed that the given input always makes it possible.

Example:
Input: A = [1,3,5,4], B = [1,2,3,7]
Output: 1
Explanation: 
Swap A[3] and B[3].  Then the sequences are:
A = [1, 3, 5, 7] and B = [1, 2, 3, 4]
which are both strictly increasing.

Note:

• A, B are arrays with the same length, and that length will be in the range [1, 1000].
• A[i], B[i] are integer values in the range [0, 2000].

题意：

给定两个长度相同的数组A和B，交换两个数组中下标相同的两个数字A[i]和B[i]。假设输入的两个数组在交换若干次之后，一定能变成严格递增的数组。输入两个数组，请问至少需要交换多少次使得两个数组都变成严格递增的？

例如，输入数组A = [1, 3, 5, 4]，B = [1, 2, 3, 7]。如果交换A[3]和B[3]，得到A = [1, 3, 5, 7]，B = [1, 2, 3, 4]，此时两个数组都是严格递增的。因此输出是1。

分析：

通常如果算法面试题是求一个问题的最优解（求最大值或者最小值），那么可以优先考虑动态规划。这是算法面试的一个常用套路。这个题目也不例外，可以用动态规划求解。

应用动态规划的第一步——用递归的思路找出规律。假设我们想求出长度为i的两个数组需要交换的最少次数。长度为i的数组A和B相当于在长度为i-1的两个数组的末尾各增加一个数字。由于我们可能交换两个数组的第i个数字，也可能不交换，因此我们需要两个函数f1(i)和f2(i)，其中f1(i)是当我们不交换第i个数字时使长度为i的两个数组变成递增数组的最少交换次数，f2(i)是当我们交换第i个数字时使长度为i的两个数组变成递增数组的最少交换次数。

第二步——根据题目的特点找出这个函数的递归关系。记住交换的目标是让两个数组都变成递增的。如果数组中A[i] <= A[i-1]或者B[i] <= B[i-1]，这意味着如果我们不想交换第i个数字，那么一定要交换两个数组的第i-1个数字，即f1(i) = f2(i - 1)；如果我们想交换两个数组的第i个数字，那么一定不能交换两个数组的第i-1个数字，即f2(i) = f1(i - 1) + 1。

如果数组中A[i] <= B[i - 1]或者B[i] <= A[i - 1]，这意味着如果我们不想交换两个数组的第i个数字，那么一定不能交换两个数组第i-1个数字，即f1(i) = f1(i - 1)；如果我们打算交换两个数组的第i 个数字，那么一定要交换两个数组的第i-1个数字，即f2(i) = f2(i - 1) + 1。

除了上述两种情况之外，不管是否交换了两个数组中的第i - 1个数字，我们可以自由选择交换或者不交换两个数组中的第i个数字。因此f1(i) = min(f1(i - 1), f2(i - 1))，f2(i) = min(f1(i - 1), f2(i - 1)) + 1。

假设两个数组的长度为n，那么f1(n)和f2(n)的最小值就是这个题目的最优解。

我们可以用递归代码求解上述两个递归函数，只是时间效率很低。为了优化时间效率，我们需要两个长度为n的数组dp1和dp2，其中dp1[i]缓存f1(i )的值，而dp2[i]缓存f2(i)的值。

也可以用循环的代码自下而上求解。这个题目如果用自下而上的方法求解，可以进一步优化空间效率。注意到求解dp1[i]和dp2[i]只需要用到dp1[i - 1]和dp2[i - 1]两个值，我们并不真的需要两个数组，可以只用两个变量来缓存。

优化之后的代码如下所示：

public int minSwap(int[] arrayA, int[] arrayB) {
        int f1 = 0;
        int f2 = 1;
        for (int i = 1; i < arrayA.length; i ++) {
            if (arrayA[i] <= arrayA[i-1] || arrayB[i] <= arrayB[i-1]) {
                int temp1 = f2;
                int temp2 = f1 + 1;
                f1 = temp1;
                f2 = temp2;
            } else if (arrayA[i] <=arrayB[i-1] || arrayB[i] <= arrayA[i-1]) {
                f2 = f2 + 1;
            } else {
                int temp1 = Math.min(f1, f2);
                int temp2 = Math.min(f1, f2) + 1;
                f1 = temp1;
                f2 = temp2;
            }
        }
        return Math.min(f1, f2);
    }

时间空间复杂度：

上述代码中，变量f1保存函数f1(i)的值，而f2保存函数f2(i)的值。

由于代码中有一个for循环，因此时间复杂度是O(n)。由于我们只用了两个变量缓存中间结果，因此空间复杂度是O(1)。