We have two integer sequencesAandBof the same non-zero length.

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

At the end of some number of swaps,AandBare both strictly increasing. (A sequence is_strictly increasing_if and only ifA[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] .

class Solution {
    public int minSwap(int[] A, int[] B) {
        int swap = 1, hold = 0;
        for (int i = 1; i < A.length; i++){
            // operation[i] should be the same as operation[i - 1]
            // hold[i - 1] = hold[i]
            if (A[i - 1] >= B[i] || B[i - 1] >= A[i]){
                swap++;
            }
            // operation[i] should be opposite of operation[i - 1]
            else if (A[i - 1] >= A[i] || B[i - 1] >= B[i]){
                int temp = swap;
                swap = hold + 1;
                hold = temp;
            }
            // either is ok, take the min
            else{
                int min = Math.min(swap, hold);
                swap = min + 1;
                hold = min;
            }
        }

        return Math.min(swap, hold);
    }
}