花花酱 LeetCode 801. Minimum Swaps To Make Sequences Increasing

zxi — Sun, 18 Mar 2018 05:56:46 +0000

Problem

题目大意：给你两个数组A, B。问最少需要多少次对应位置元素的交换才能使得A和B变成单调递增。

https://leetcode.com/problems/minimum-swaps-to-make-sequences-increasing/description/

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

Solution: Search/DFS (TLE)

Time complexity: O(2^n)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: TLE 84/102 test cases passed.
class Solution {
public:
  int minSwap(vector& A, vector& B) {
    int ans = INT_MAX;
    dfs(A, B, 0, 0, ans);
    return ans;
  }
private:
  void dfs(vector& A, vector& B, int i, int c, int& ans) {
    if (c >= ans) return;
    
    if (i == A.size()) {
      ans = min(ans, c);
      return;
    }
    
    if (i == 0 || A[i] > A[i - 1] && B[i] > B[i - 1])
      dfs(A, B, i + 1, c, ans);
    
    if (i == 0 || A[i] > B[i - 1] && B[i] > A[i - 1]) {
      swap(A[i], B[i]);
      dfs(A, B, i + 1, c + 1, ans);
      swap(A[i], B[i]);
    }
  }
};

Solution: DP

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 15 ms
class Solution {
public:
  int minSwap(vector& A, vector& B) {
    const int n = A.size();
        
    vector keep(n, INT_MAX);
    vector swap(n, INT_MAX);
    
    keep[0] = 0;
    swap[0] = 1;
    
    for (int i = 1; i < n; ++i) {
      if (A[i] > A[i - 1] && B[i] > B[i - 1]) {
        // Good case, no swapping needed.
        keep[i] = keep[i - 1];
    
        // Swapped A[i - 1] / B[i - 1], swap A[i], B[i] as well
        swap[i] = swap[i - 1] + 1;
      }      
      
      if (B[i] > A[i - 1] && A[i] > B[i - 1]) {
        // A[i - 1] / B[i - 1] weren't swapped.
        swap[i] = min(swap[i], keep[i - 1] + 1);
      
        // Swapped A[i - 1] / B[i - 1], no swap needed for A[i] / B[i]      
        keep[i] = min(keep[i], swap[i - 1]);
      }      
    }
      
    return min(keep.back(), swap.back());
  }
};

Python3

"""
Author: Huahua
Running time: 60 ms
"""
class Solution:
  def minSwap(self, A, B):
    n = len(A)
    dp = [[float('inf'), float('inf')] for _ in range(n)]
    dp[0][0], dp[0][1] = 0, 1
    for i in range(1, n):
      if A[i] > A[i - 1] and B[i] > B[i - 1]:
        dp[i][0] = dp[i - 1][0]
        dp[i][1] = dp[i - 1][1] + 1
      if B[i] > A[i - 1] and A[i] > B[i - 1]:
        dp[i][0] = min(dp[i][0], dp[i - 1][1])
        dp[i][1] = min(dp[i][1], dp[i - 1][0] + 1)
    return min(dp[-1])

The post 花花酱 LeetCode 801. Minimum Swaps To Make Sequences Increasing appeared first on Huahua's Tech Road.

multistate Archives - Huahua's Tech Road

花花酱 LeetCode 801. Minimum Swaps To Make Sequences Increasing

Problem

Solution: Search/DFS (TLE)

C++

Solution: DP

C++

Python3