Now, we may choose any set of deletion indices, and for each string, we delete all the characters in those indices.

For example, if we have an array A = ["babca","bbazb"] and deletion indices {0, 1, 4}, then the final array after deletions is ["bc","az"].

Suppose we chose a set of deletion indices D such that after deletions, the final array has every element (row) in lexicographic order.

For clarity, A[0] is in lexicographic order (ie. A[0][0] <= A[0][1] <= ... <= A[0][A[0].length - 1]), A[1] is in lexicographic order (ie. A[1][0] <= A[1][1] <= ... <= A[1][A[1].length - 1]), and so on.

Return the minimum possible value of D.length.

Example 1:

Input: ["babca","bbazb"]
Output: 3
Explanation: After deleting columns 0, 1, and 4, the final array is A = ["bc", "az"].
Both these rows are individually in lexicographic order (ie. A[0][0] <= A[0][1] and A[1][0] <= A[1][1]).
Note that A[0] > A[1] - the array A isn't necessarily in lexicographic order.

Example 2:

Input: ["edcba"]
Output: 4
Explanation: If we delete less than 4 columns, the only row won't be lexicographically sorted.

Example 3:

Input: ["ghi","def","abc"]
Output: 0
Explanation: All rows are already lexicographically sorted.

Note:

1. 1 <= A.length <= 100
2. 1 <= A[i].length <= 100

Solution: DP

dp[i] := max length of increasing sub-sequence (of all strings) ends with i-th letter.
dp[i] = max(dp[j] + 1) if all A[*][j] <= A[*][i], j < i
Time complexity: (n*L^2)
Space complexity: O(L)

// Author: Huahua, running time: 24 ms
class Solution {
public:
  int minDeletionSize(vector<string>& A) {
    vector<int> dp(A[0].length(), 1);
    for (int i = 0; i < A[0].length(); ++i)
      for (int j = 0; j < i; ++j) {
        bool valid = true;
        for (const auto& a : A)
          if (a[j] > a[i]) {
            valid = false;
            break;
          }
        if (valid) dp[i] = max(dp[i], dp[j] + 1);
      }
    return A[0].length() - *max_element(begin(dp), end(dp));
  }
};

// Author: Huahua, running time: 176 ms
class Solution:
  def minDeletionSize(self, A):
    n = len(A[0])
    dp = [1] * n
    for i in range(1, n):
      for j in range(i):
        valid = True
        for a in A:
          if a[j] > a[i]: 
            valid = False
            break
        if valid:
          dp[i] = max(dp[i], dp[j] + 1)
    return n - max(dp)

The post 花花酱 LeetCode 960. Delete Columns to Make Sorted III appeared first on Huahua's Tech Road.

Input: [4, 6, 7, 7]
Output: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

Solution: DFS

Time complexity: O(2^n)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 140 ms (<99.88%)
class Solution {
public:
  vector<vector<int>> findSubsequences(vector<int>& nums) {
    vector<vector<int>> ans;
    vector<int> cur;
    dfs(nums, 0, cur, ans);
    return ans;
  }
private:
  void dfs(const vector<int>& nums, int s, vector<int>& cur, vector<vector<int>>& ans) {    
    unordered_set<int> seen;
    for (int i = s; i < nums.size(); ++i) {
      if (!cur.empty() && nums[i] < cur.back()) continue;
      // each number can be used only once at the same depth.
      if (seen.count(nums[i])) continue; 
      seen.insert(nums[i]);
      cur.push_back(nums[i]);
      if (cur.size() > 1) 
        ans.push_back(cur);
      dfs(nums, i + 1, cur, ans);
      cur.pop_back();
    }
  }
};

The post 花花酱 LeetCode 491. Increasing Subsequences appeared first on Huahua's Tech Road.

题目大意：判断一个数组中是否存在长度为3的单调递增子序列。

Formally the function should:

Return true if there exists i, j, k 
such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return false.

Your algorithm should run in O(n) time complexity and O(1) space complexity.

Examples:
Given [1, 2, 3, 4, 5],
return true.

Given [5, 4, 3, 2, 1],
return false.

Credits:
Special thanks to @DjangoUnchained for adding this problem and creating all test cases.

Solution: Greedy

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 7 ms
class Solution {
public:
  bool increasingTriplet(vector<int>& nums) {
    int min1 = INT_MAX;
    int min2 = INT_MAX;
    for (int num : nums) {
      if (num > min2) return true;
      else if (num < min1) {
        min1 = num;
      } else if (num > min1 && num < min2) {
        min2 = num;
      }
    }
    return false;
  }
};

The post 花花酱 LeetCode 334. Increasing Triplet Subsequence appeared first on Huahua's Tech Road.