LeetCdoe 801——使序列递增的最小交换次数(动态规划)_java使序列增加所需的最小移动次数。-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_18527763/article/details/91869101

有两个长度相等且不为空的整型数组 A 和 B 。我们可以交换 A[i] 和 B[i] 的元素。注意这两个元素在各自的序列中应该处于相同的位置。

在交换过一些元素之后，数组 A 和 B 都应该是严格递增的（数组严格递增的条件仅为A[0] < A[1] < … < 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]区间内的整数。

package test.com;

import java.util.Arrays;

/**
 * @program: Aglorithm
 * @Date: today
 * @Author: Kyrie
 * @Description:
 *      使序列递增的最小交换次数
 */
public class LeetCode10 {
    public static int minSwap(int[] A, int[] B) {
        int len = A.length;
        int[] swap = new int[len];
        int[] no_swap = new int[len];
        swap[0] = 1;
        no_swap[0] = 0;
        /**初始状态：swap[0] = 1;
                     no_swap[0] = 0;
         * 分三种情况
         *     1.若仅满足A[i] > A[i-1] && B[i] > B[i-1]:
         *     swap[i] = swap[i-1] + 1;
         *     no_swap[i] = no_swap[i-1];
         *     比如A = {3，4};
         *        B ={1,2};  swap[1] = swap[0] + 1; no_swap[1] = no_swap[i-1];
         *
         *     2.若仅满足A[i] > B[i-1] && B[i] > A[i-1]:
         *     swap[i] = no_swap[i-1] + 1;
         *     no_swap[i] = swap[i-1];
         *     比如A = {1,6,5};
         *         B ={1,2,7};  swap[2] = no_swap[1] + 1; no_swap[2] = swap[1];
         *
         *     3.若同时满足1和2，即(A[i] > A[i-1] && B[i] > B[i-1])&& (A[i] > B[i-1] && B[i] > A[i-1])
         *     swap[i] = Math.min(swap[i-1],no_swap[i-1]) + 1;
         *     no_swap[i] = Math.min(swap[i-1],no_swap[i-1]);
         *     A[i]与B[i]换不换都成立，要获取最小交换次数，就取决于swap[i-1]与no_swap[i-1]谁能取得最小值,
         *     即min = Math.min(swap[i-1],no_swap[i-1]);
         *
         */
        for (int i = 1; i < len; i++) {
            if(A[i] > A[i-1] && B[i] > B[i-1] && A[i] > B[i-1] && B[i] > A[i-1]){  // 情况3
                swap[i] = Math.min(swap[i-1],no_swap[i-1]) + 1;
                no_swap[i] = Math.min(swap[i-1],no_swap[i-1]);

            }else if(A[i] > A[i-1] && B[i] > B[i-1]){     // 情况1
                swap[i] = swap[i-1] + 1;
                no_swap[i] = no_swap[i-1];
            }
            else{                                       // 情况2
                swap[i] = no_swap[i-1] + 1;
                no_swap[i] = swap[i-1];
            }
        }
        System.out.println(Arrays.toString(swap));
        System.out.println(Arrays.toString(no_swap));
        return Math.min(swap[len-1], no_swap[len-1]);
    }

    public static void main(String[] args) {
        int[] A = {0,3,5,8,9};
        int[] B = {2,1,4,6,9};
        System.out.println(minSwap(A, B));
    }
}