801. Minimum Swaps To Make Sequences Increasing

最新推荐文章于 2021-08-08 12:18:16 发布

bwcxljsm

最新推荐文章于 2021-08-08 12:18:16 发布

阅读量164

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 动态规划算法 leetcode不会做的 Leetcode

本文链接：https://blog.youkuaiyun.com/qq_36718317/article/details/79773592

Leetcode 同时被 3 个专栏收录

89 篇文章

订阅专栏

leetcode

85 篇文章

订阅专栏

算法

83 篇文章

订阅专栏

本文介绍了一种算法，用于解决两个整数序列通过最少次数的元素交换实现严格递增的问题。通过定义状态转移方程，利用动态规划的方法实现了这一目标。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

题意：

给出两个相同长度的数组，求至少交换几次，使得两个数组都是严格递增的。交换必须是相同的index处交换，即A[i]只能与B[i]交换。

思路：

答案都看半天，手动再见，真难啊。。。还是找状态转移方程，设置数组dp[i][0]和dp[i][1]，dp[i][0]表示第i处不交换需要交换的总次数，dp[i][1]表示第i次交换所需要交换的总次数。如果A[i-1]<A[i]&&B[i-1]<B[i]，那么第i处不交换的话，dp[i][[0=min(dp[i][0],dp[i-1][0]),交换的话，dp[i][1]=min(dp[i-1][1]+1,dp[i][1])，因为交换第i处，那么第i-1处也可能也要交换。

对于A[i-1]<B[i]&&B[i-1]<A[i]，也可以照此分析。

代码:

class Solution {
    public int minSwap(int[] A, int[] B) {
        int [][]dp=new int[A.length][2];
        for(int i=0;i<A.length;i++)
        {
            dp[i][0]=Integer.MAX_VALUE;
            dp[i][1]=Integer.MAX_VALUE;
        }
        dp[0][0]=0;
        dp[0][1]=1;
        for(int i=1;i<A.length;i++)
        {
            if(A[i-1]<A[i]&&B[i-1]<B[i])
                dp[i][0]=Math.min(dp[i][0],dp[i-1][0]);
            if(A[i-1]<B[i]&&B[i-1]<A[i])
                dp[i][0]=Math.min(dp[i][0],dp[i-1][1]);
            if(A[i-1]<A[i]&&B[i-1]<B[i])
                dp[i][1]=Math.min(dp[i-1][1]+1,dp[i][1]);
            if(A[i-1]<B[i]&&B[i-1]<A[i])
                dp[i][1]=Math.min(dp[i][1],dp[i-1][0]+1);
        }
        return Math.min(dp[A.length-1][0],dp[A.length-1][1]);
    }
}