[leetcode 801] Minimum Swaps To Make Sequences Increasing

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].

题目大意：输入为两个integer 数组， 可以交换 相同index上的A[i] 和B[i], 求最小交换次数，使得 两个数组从小到大递增。

解析：判断是否需要交换 index=i上的元素， 依赖于 index =i-1的状态 --> DP 解法。

/*
1） 定义两个DP数组 swap[i] 表示 如果交换第i个元素， 那么使得0<X<i 两个数组同时满足递增的最小交换次数之和。
not_swap[i] 表示如果不交换第i个元素，那么使得0<X<i 两个数组同时满足递增的最小交换次数之和。

2） 递推公式：
#1 if A[i - 1] < A[i] && B[i - 1] < B[i]，
then 如果此时选择不交换， 那么同样不需要交换 第i-1个元素 -> not_swap[i] = not_swap[i-1]
如果此时选择交换， 那么同样需要交换 第i-1个元素 -> swap[i] = swap[i-1] +1; +1 表示在swap[i-1]基础上增加一次交换次数。

#2, A[i - 1] < B[i] && B[i - 1] < A[i]
此时， 如果选择不交换第i个元素， 那么需要交换 第i-1个元素 或者根据#1判断成立下，不交换第i-1个元素 -> Math.min(not_swap[i], swap[i - 1]).
如果选择交换第i个元素，那么需要在不交换i-1元素的前提下+1 或者在#1成立下，交换第i-1个元素。

*/
class Solution {
    public int minSwap(int[] A, int[] B) {
        int[] swap = new int[1000];
        int[] not_swap = new int[1000];
        swap[0] = 1;
        for (int i = 1; i < A.length; ++i) {
            not_swap[i] = swap[i] = A.length;
            if (A[i - 1] < A[i] && B[i - 1] < B[i]) {
                not_swap[i] = not_swap[i - 1];
                swap[i] = swap[i - 1] + 1;
            }
            if (A[i - 1] < B[i] && B[i - 1] < A[i]) {
                not_swap[i] = Math.min(not_swap[i], swap[i - 1]);
                swap[i] = Math.min(swap[i], not_swap[i - 1] + 1);
            }
        }
        return Math.min(swap[A.length - 1], not_swap[A.length - 1]);
    }

}