zoukankan      html  css  js  c++  java
  • [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,可在任意位置i交换A[i]和B[i]的值,使得数组A和B变成严格递增的数组,求最少需要交换的次数。

    解法:dp

    Java:

    class Solution {
        public int minSwap(int[] A, int[] B) {
            int swapRecord = 1, fixRecord = 0;
            for (int i = 1; i < A.length; i++) {
                if (A[i - 1] >= B[i] || B[i - 1] >= A[i]) {
    		// In this case, the ith manipulation should be same as the i-1th manipulation
                    // fixRecord = fixRecord;
                    swapRecord++;
                } else if (A[i - 1] >= A[i] || B[i - 1] >= B[i]) {
    		// In this case, the ith manipulation should be the opposite of the i-1th manipulation
                    int temp = swapRecord;
                    swapRecord = fixRecord + 1;
                    fixRecord = temp;
                } else {
                    // Either swap or fix is OK. Let's keep the minimum one
                    int min = Math.min(swapRecord, fixRecord);
                    swapRecord = min + 1;
                    fixRecord = min;
                }
            }
            return Math.min(swapRecord, fixRecord);
        }
    }  

    Python:

    class Solution(object):
        def minSwap(self, A, B):
            """
            :type A: List[int]
            :type B: List[int]
            :rtype: int
            """
            dp_no_swap, dp_swap = [0]*2, [1]*2
            for i in xrange(1, len(A)):
                dp_no_swap[i%2], dp_swap[i%2] = float("inf"), float("inf")
                if A[i-1] < A[i] and B[i-1] < B[i]:
                    dp_no_swap[i%2] = min(dp_no_swap[i%2], dp_no_swap[(i-1)%2])
                    dp_swap[i%2] = min(dp_swap[i%2], dp_swap[(i-1)%2]+1)
                if A[i-1] < B[i] and B[i-1] < A[i]:
                    dp_no_swap[i%2] = min(dp_no_swap[i%2], dp_swap[(i-1)%2])
                    dp_swap[i%2] = min(dp_swap[i%2], dp_no_swap[(i-1)%2]+1)
            return min(dp_no_swap[(len(A)-1)%2], dp_swap[(len(A)-1)%2])  

    C++:

    class Solution {
    public:
        int minSwap(vector<int>& A, vector<int>& B) {
            int n = A.size();
            vector<int> swap(n, n), noSwap(n, n);
            swap[0] = 1; noSwap[0] = 0;
            for (int i = 1; i < n; ++i) {
                if (A[i] > A[i - 1] && B[i] > B[i - 1]) {
                    swap[i] = swap[i - 1] + 1;
                    noSwap[i] = noSwap[i - 1];
                }
                if (A[i] > B[i - 1] && B[i] > A[i - 1]) {
                    swap[i] = min(swap[i], noSwap[i - 1] + 1);
                    noSwap[i] = min(noSwap[i], swap[i - 1]);
                }
            }
            return min(swap[n - 1], noSwap[n - 1]);
        }
    };
    

    C++:

    class Solution {
    public:
        int minSwap(vector<int>& A, vector<int>& B) {
            int n1 = 0, s1 = 1, n = A.size();
            for (int i = 1; i < n; ++i) {
                int n2 = INT_MAX, s2 = INT_MAX;
                if (A[i - 1] < A[i] && B[i - 1] < B[i]) {
                    n2 = min(n2, n1);
                    s2 = min(s2, s1 + 1);
                }
                if (A[i - 1] < B[i] && B[i - 1] < A[i]) {
                    n2 = min(n2, s1);
                    s2 = min(s2, n1 + 1);
                }
                n1 = n2;
                s1 = s2;
            }
            return min(n1, s1);
        }
    };
    

      

    类似题目:

    Best Time to Buy and Sell Stock with Transaction Fee  

    All LeetCode Questions List 题目汇总

  • 相关阅读:
    UVa 1349 (二分图最小权完美匹配) Optimal Bus Route Design
    UVa 1658 (拆点法 最小费用流) Admiral
    UVa 11082 (网络流建模) Matrix Decompressing
    UVa 753 (二分图最大匹配) A Plug for UNIX
    UVa 1451 (数形结合 单调栈) Average
    UVa 1471 (LIS变形) Defense Lines
    UVa 11572 (滑动窗口) Unique Snowflakes
    UVa 1606 (极角排序) Amphiphilic Carbon Molecules
    UVa 11054 Wine trading in Gergovia
    UVa 140 (枚举排列) Bandwidth
  • 原文地址:https://www.cnblogs.com/lightwindy/p/9576632.html
Copyright © 2011-2022 走看看