In an operation, you select a set of indices in str1, and for each index i in the set, increment str1[i] to the next character cyclically. That is 'a' becomes 'b', 'b' becomes 'c', and so on, and 'z' becomes 'a'.

Return true if it is possible to make str2 a subsequence of str1 by performing the operation at most once, and false otherwise.

Note: A subsequence of a string is a new string that is formed from the original string by deleting some (possibly none) of the characters without disturbing the relative positions of the remaining characters.

Example 1:

Input: str1 = "abc", str2 = "ad"
Output: true
Explanation: Select index 2 in str1.
Increment str1[2] to become 'd'. 
Hence, str1 becomes "abd" and str2 is now a subsequence. Therefore, true is returned.

Example 2:

Input: str1 = "zc", str2 = "ad"
Output: true
Explanation: Select indices 0 and 1 in str1. 
Increment str1[0] to become 'a'. 
Increment str1[1] to become 'd'. 
Hence, str1 becomes "ad" and str2 is now a subsequence. Therefore, true is returned.

Example 3:

Input: str1 = "ab", str2 = "d"
Output: false
Explanation: In this example, it can be shown that it is impossible to make str2 a subsequence of str1 using the operation at most once. 
Therefore, false is returned.

Constraints:

• 1 <= str1.length <= 105
• 1 <= str2.length <= 105
• str1 and str2 consist of only lowercase English letters.

Solution: Two pointers

s1[i] and s2[j] can match if
s1[i] == s2[j] or inc(s1[i]) == s2[j]

If matched: ++i; ++j else ++i.

Time complexity: O(n)
Space complexity: O(1)

class Solution {
public:
  bool canMakeSubsequence(string_view s1, string_view s2) {    
    for (int i = 0, j = 0, n = s1.size(), m = s2.size(); i < n; ++i)
      if (s1[i] == s2[j] || (s1[i] - 'a' + 1) % 26 == s2[j] - 'a')
        if (++j == m) return true;
    return false;
  }
};

Iterator version

class Solution {
public:
  bool canMakeSubsequence(string_view s1, string_view s2) {    
    for (auto i = begin(s1), j = begin(s2); i != end(s1); ++i)
      if (*i == *j || (*i - 'a' + 1) % 26 == *j - 'a')
        if (++j == end(s2)) return true;
    return false;
  }
};

The post 花花酱 LeetCode 2825. Make String a Subsequence Using Cyclic Increments appeared first on Huahua's Tech Road.

Note that even if there are multiple ways to obtain the same subsequence, it is still only counted once.

A palindrome is a string that reads the same forwards and backwards.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

• For example, "ace" is a subsequence of "abcde".

Example 1:

Input: s = "aabca"
Output: 3
Explanation: The 3 palindromic subsequences of length 3 are:
- "aba" (subsequence of "aabca")
- "aaa" (subsequence of "aabca")
- "aca" (subsequence of "aabca")

Example 2:

Input: s = "adc"
Output: 0
Explanation: There are no palindromic subsequences of length 3 in "adc".

Example 3:

Input: s = "bbcbaba"
Output: 4
Explanation: The 4 palindromic subsequences of length 3 are:
- "bbb" (subsequence of "bbcbaba")
- "bcb" (subsequence of "bbcbaba")
- "bab" (subsequence of "bbcbaba")
- "aba" (subsequence of "bbcbaba")

Constraints:

• 3 <= s.length <= 105
• s consists of only lowercase English letters.

Solution: Enumerate first character of a palindrome

For a length 3 palindrome, we just need to enumerate the first character c.
We found the first and last occurrence of c in original string and scan the middle part to see how many unique characters there.

e.g. aabca
Enumerate from a to z, looking for a*a, b*b, …, z*z.
For a*a, aabca, we found first and last a, in between is abc, which has 3 unique letters.
We can use a hastable or a bitset to track unique letters.

Time complexity: O(26*n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countPalindromicSubsequence(string s) {
    auto count = [&](char c) -> int {
      int l = s.find_first_of(c);
      int r = s.find_last_of(c);
      if (l == string::npos || r == string::npos) return 0;
      bitset<26> m;
      for (int i = l + 1; i < r; ++i)
        m.set(s[i] - 'a');
      return m.count();
    };
    int ans = 0;
    for (char c = 'a'; c <= 'z'; ++c)
      ans += count(c);
    return ans;
  }
};

The post 花花酱 LeetCode 1930. Unique Length-3 Palindromic Subsequences appeared first on Huahua's Tech Road.

You want to choose an integer k (0 <= k <= removable.length) such that, after removing k characters from s using the first k indices in removable, p is still a subsequence of s. More formally, you will mark the character at s[removable[i]] for each 0 <= i < k, then remove all marked characters and check if p is still a subsequence.

Return the maximum k you can choose such that p is still a subsequence of s after the removals.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

Example 1:

Input: s = "abcacb", p = "ab", removable = [3,1,0]
Output: 2
Explanation: After removing the characters at indices 3 and 1, "abcacb" becomes "accb".
"ab" is a subsequence of "accb".
If we remove the characters at indices 3, 1, and 0, "abcacb" becomes "ccb", and "ab" is no longer a subsequence.
Hence, the maximum k is 2.

Example 2:

Input: s = "abcbddddd", p = "abcd", removable = [3,2,1,4,5,6]
Output: 1
Explanation: After removing the character at index 3, "abcbddddd" becomes "abcddddd".
"abcd" is a subsequence of "abcddddd".

Example 3:

Input: s = "abcab", p = "abc", removable = [0,1,2,3,4]
Output: 0
Explanation: If you remove the first index in the array removable, "abc" is no longer a subsequence.

Constraints:

• 1 <= p.length <= s.length <= 105
• 0 <= removable.length < s.length
• 0 <= removable[i] < s.length
• p is a subsequence of s.
• s and p both consist of lowercase English letters.
• The elements in removable are distinct.

Solution: Binary Search + Two Pointers

If we don’t remove any thing, p is a subseq of s, as we keep removing, at some point L, p is no longer a subseq of s. e.g [0:True, 1: True, …, L – 1: True, L: False, L+1: False, …, m:False], this array is monotonic. We can use binary search to find the smallest L such that p is no long a subseq of s. Ans = L – 1.

For each guess, we can use two pointers to check whether p is subseq of removed(s) in O(n).

Time complexity: O(nlogn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maximumRemovals(string s, string p, vector<int>& removable) {
    const int n = s.length();
    const int t = p.length();
    const int m = removable.size();    
    int l = 0;
    int r = m + 1;
    vector<int> idx(n, INT_MAX);
    for (int i = 0; i < m; ++i)
      idx[removable[i]] = i;
    while (l < r) {
      int mid = l + (r - l) / 2;
      int j = 0;
      for (int i = 0; i < n && j < t; ++i)
        if (idx[i] >= mid && s[i] == p[j]) ++j;      
      if (j != t)
        r = mid;
      else
        l = mid + 1;
    }
    // l is the smallest number s.t. p is no longer a subseq of s.
    return l - 1;
  }
};

The post 花花酱 LeetCode 1898. Maximum Number of Removable Characters appeared first on Huahua's Tech Road.

You are given two strings, word1 and word2. You want to construct a string in the following manner:

• Choose some non-empty subsequence subsequence1 from word1.
• Choose some non-empty subsequence subsequence2 from word2.
• Concatenate the subsequences: subsequence1 + subsequence2, to make the string.

Return the length of the longest palindrome that can be constructed in the described manner. If no palindromes can be constructed, return 0.

A subsequence of a string s is a string that can be made by deleting some (possibly none) characters from s without changing the order of the remaining characters.

A palindrome is a string that reads the same forward as well as backward.

Example 1:

Input: word1 = "cacb", word2 = "cbba"
Output: 5
Explanation: Choose "ab" from word1 and "cba" from word2 to make "abcba", which is a palindrome.

Example 2:

Input: word1 = "ab", word2 = "ab"
Output: 3
Explanation: Choose "ab" from word1 and "a" from word2 to make "aba", which is a palindrome.

Example 3:

Input: word1 = "aa", word2 = "bb"
Output: 0
Explanation: You cannot construct a palindrome from the described method, so return 0.

Constraints:

• 1 <= word1.length, word2.length <= 1000
• word1 and word2 consist of lowercase English letters.

Solution: DP

Similar to 花花酱 LeetCode 516. Longest Palindromic Subsequence

Let s = word1 + word2, build dp table on s. We just need to make sure there’s at least one char from each string.

Time complexity: O((m+n)^2)
Space complexity: O((m+n)^2)

// Author: Huahua
class Solution {
public:
  int longestPalindrome(string word1, string word2) {
    const int l1 = word1.length();
    const int l2 = word2.length();
    string s = word1 + word2;
    const int n = l1 + l2;
    vector<vector<int>> dp(n, vector<int>(n));
    for (int i = 0; i < n; ++i) dp[i][i] = 1;
    for (int l = 2; l <= n; ++l)
      for (int i = 0, j = i + l - 1; j < n; ++i, ++j) {
        if (s[i] == s[j])
          dp[i][j] = dp[i + 1][j - 1] + 2;
        else
          dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
      }
    
    int ans = 0;
    for (int i = 0; i < l1; ++i)
      for (int j = 0; j < l2; ++j)
        if (word1[i] == word2[j])
          ans = max(ans, dp[i][l1 + j]);
    return ans;
  }
};

O(m+n) Space complexity

// Author: Huahua
class Solution {
public:
  int longestPalindrome(string word1, string word2) {
    const int l1 = word1.length();
    const int l2 = word2.length();
    string s = word1 + word2;
    const int n = l1 + l2;
    vector<int> dp1(n, 1), dp2(n);
    int ans = 0;
    for (int l = 2; l <= n; ++l) {
      vector<int> dp(n);
      for (int i = 0, j = i + l - 1; j < n; ++i, ++j) {
        if (s[i] == s[j]) {
          dp[i] = dp2[i + 1] + 2;
          if (i < l1 && j >= l1)
            ans = max(ans, dp[i]);
        } else {
          dp[i] = max(dp1[i + 1], dp1[i]);
        }
      }
      // dp2, dp1 = dp1, dp
      dp1.swap(dp); 
      dp2.swap(dp);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1771. Maximize Palindrome Length From Subsequences appeared first on Huahua's Tech Road.

Given two arrays nums1 and nums2.

Return the maximum dot product between non-empty subsequences of nums1 and nums2 with the same length.

A subsequence of a array is a new array which is formed from the original array by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, [2,3,5] is a subsequence of [1,2,3,4,5] while [1,5,3] is not).

Example 1:

Input: nums1 = [2,1,-2,5], nums2 = [3,0,-6]
Output: 18
Explanation: Take subsequence [2,-2] from nums1 and subsequence [3,-6] from nums2.
Their dot product is (2*3 + (-2)*(-6)) = 18.

Example 2:

Input: nums1 = [3,-2], nums2 = [2,-6,7]
Output: 21
Explanation: Take subsequence [3] from nums1 and subsequence [7] from nums2.
Their dot product is (3*7) = 21.

Example 3:

Input: nums1 = [-1,-1], nums2 = [1,1]
Output: -1
Explanation: Take subsequence [-1] from nums1 and subsequence [1] from nums2.
Their dot product is -1.

Constraints:

• 1 <= nums1.length, nums2.length <= 500
• -1000 <= nums1[i], nums2[i] <= 1000

Solution: DP

dp[i][j] := max product of nums1[0~i], nums2[0~j].

dp[i][j] = max(dp[i-1][j], dp[i][j -1], max(0, dp[i-1][j-1]) + nums1[i]*nums2[j])

Time complexity: O(n1*n2)
Space complexity: O(n1*n2)

// Author: Huahua
class Solution {
public:
  int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
    const int n1 = nums1.size();
    const int n2 = nums2.size();
    // dp[i][j] = max dot product of two subsequences 
    // of nums1[0:i] and nums2[0:j]
    vector<vector<int>> dp(n1 + 1, vector<int>(n2 + 1, INT_MIN / 2));
        
    for (int i = 1; i <= n1; ++i)
      for (int j = 1; j <= n2; ++j)
        dp[i][j] = max({
          dp[i - 1][j],
          dp[i][j - 1],
          max(0, dp[i - 1][j - 1]) + nums1[i - 1] * nums2[j - 1]
        });
    return dp[n1][n2];
  }
};

// Author: Huahua
class Solution {
public:
  int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
    const int n1 = nums1.size();
    const int n2 = nums2.size();
    // dp[i][j] = max dot product of two subsequences 
    // of nums1[0~i] and nums2[0~j]
    vector<vector<int>> dp(n1, vector<int>(n2));
        
    for (int i = 0; i < n1; ++i)
      for (int j = 0; j < n2; ++j) {
        dp[i][j] = nums1[i] * nums2[j];
        if (i > 0 && j > 0) dp[i][j] += max(0, dp[i - 1][j - 1]);
        if (i > 0) dp[i][j] = max(dp[i][j], dp[i - 1][j]);
        if (j > 0) dp[i][j] = max(dp[i][j], dp[i][j - 1]);     
      }
    return dp.back().back();
  }
};

The post 花花酱 LeetCode 1458. Max Dot Product of Two Subsequences appeared first on Huahua's Tech Road.

Return the minimum number of steps to make the given string empty.

A string is a subsequence of a given string, if it is generated by deleting some characters of a given string without changing its order.

A string is called palindrome if is one that reads the same backward as well as forward.

Example 1:

Input: s = "ababa"
Output: 1
Explanation: String is already palindrome

Example 2:

Input: s = "abb"
Output: 2
Explanation: "abb" -> "bb" -> "". 
Remove palindromic subsequence "a" then "bb".

Example 3:

Input: s = "baabb"
Output: 2
Explanation: "baabb" -> "b" -> "". 
Remove palindromic subsequence "baab" then "b".

Example 4:

Input: s = ""
Output: 0

Constraints:

• 0 <= s.length <= 1000
• s only consists of letters ‘a’ and ‘b’

Solution: Math

if s is empty => 0 step
if s is a palindrome => 1 step
Otherwise, 2 steps…
1. delete all the as
2. delete all the bs

Time complexity: O(n)
Space complexity: O(n) / O(1)

// Author: Huahua
class Solution {
public:
  int removePalindromeSub(string s) {
    if (s.empty()) return 0;
    if (s == string(rbegin(s), rend(s))) return 1;
    return 2;
  }
};

The post 花花酱 LeetCode 1332. Remove Palindromic Subsequences appeared first on Huahua's Tech Road.

Given an integer array arr and an integer difference, return the length of the longest subsequence in arr which is an arithmetic sequence such that the difference between adjacent elements in the subsequence equals difference.

Example 1:

Input: arr = [1,2,3,4], difference = 1
Output: 4
Explanation: The longest arithmetic subsequence is [1,2,3,4].

Example 2:

Input: arr = [1,3,5,7], difference = 1
Output: 1
Explanation: The longest arithmetic subsequence is any single element.

Example 3:

Input: arr = [1,5,7,8,5,3,4,2,1], difference = -2
Output: 4
Explanation: The longest arithmetic subsequence is [7,5,3,1].

Constraints:

• 1 <= arr.length <= 10^5
• -10^4 <= arr[i], difference <= 10^4

Solution: DP

dp[i] := max length of sequence ends with x
dp[x] = max(0, dp[x – diff]) + 1

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int longestSubsequence(vector<int>& arr, int d) {
    unordered_map<int, int> dp;
    int ans = 0;
    for (int x : arr)      
      ans = max(ans, dp[x] = dp[x - d] + 1);    
    return ans;
  }
};

The post 花花酱 LeetCode 1218. Longest Arithmetic Subsequence of Given Difference appeared first on Huahua's Tech Road.

Given two strings str1 and str2, return the shortest string that has both str1 and str2 as subsequences.  If multiple answers exist, you may return any of them.

(A string S is a subsequence of string T if deleting some number of characters from T (possibly 0, and the characters are chosen anywherefrom T) results in the string S.)

Example 1:

Input: str1 = "abac", str2 = "cab"
Output: "cabac"
Explanation: 
str1 = "abac" is a substring of "cabac" because we can delete the first "c".
str2 = "cab" is a substring of "cabac" because we can delete the last "ac".
The answer provided is the shortest such string that satisfies these properties.

Note:

1. 1 <= str1.length, str2.length <= 1000
2. str1 and str2 consist of lowercase English letters.

Solution: LCS

Find the LCS (longest common sub-sequence) of two strings, and insert unmatched characters into the LCS.

Time complexity: O(mn)
Space complexity: O(mn)

// Author: Huahua, running time: 16 ms, 15.3 MB
class Solution {
public:
  string shortestCommonSupersequence(string str1, string str2) {
    int l1 = str1.length();
    int l2 = str2.length();    
    vector<vector<int>> dp(l1 + 1, vector<int>(l2 + 1));    
    for (int i = 1; i <= l1; ++i)
      for (int j = 1; j <= l2; ++j)
        dp[i][j] = str1[i - 1] == str2[j - 1] ? 
                     1 + dp[i - 1][j - 1] : 
                     max(dp[i - 1][j], dp[i][j - 1]);
    deque<char> ans;
    while (l1 || l2) {
      char c;
      if (l1 == 0) c = str2[--l2];
      else if (l2 == 0) c = str1[--l1];
      else if (str1[l1 - 1] == str2[l2 - 1]) c = str1[--l1] = str2[--l2];
      else if (dp[l1 - 1][l2] == dp[l1][l2]) c = str1[--l1];
      else if (dp[l1][l2 - 1] == dp[l1][l2]) c = str2[--l2];
      ans.push_front(c);
    }    
    return {begin(ans), end(ans)};
  }
};

The post 花花酱 LeetCode 1092. Shortest Common Supersequence appeared first on Huahua's Tech Road.

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.

Given a string S, count the number of distinct, non-empty subsequences of S .

Since the result may be large, return the answer modulo 10^9 + 7.

Example 1:

Input: "abc"
Output: 7
Explanation: The 7 distinct subsequences are "a", "b", "c", "ab", "ac", "bc", and "abc".

Example 2:

Input: "aba"
Output: 6
Explanation: The 6 distinct subsequences are "a", "b", "ab", "ba", "aa" and "aba".

Example 3:

Input: "aaa"
Output: 3
Explanation: The 3 distinct subsequences are "a", "aa" and "aaa".

Note:

1. S contains only lowercase letters.
2. 1 <= S.length <= 2000

Solution: DP

counts[i][j] := # of distinct sub sequences of s[1->i] and ends with letter j. (‘a'<= j <= ‘z’)

Initialization:

counts[*][*] = 0

Transition:

counts[i][j] = sum(counts[i-1]) + 1 if s[i] == j  else counts[i-1][j]

ans = sum(counts[n])

e.g. S = “abc”

counts[1] = {‘a’ : 1}
counts[2] = {‘a’ : 1, ‘b’ : 1 + 1 = 2}
counts[3] = {‘a’ : 1, ‘b’ : 2, ‘c’: 1 + 2 + 1 = 4}
ans = sum(counts[3]) = 1 + 2 + 4 = 7

Time complexity: O(N*26)

Space complexity: O(N*26) -> O(26)

// Author: Huahua, running time: 12 ms
class Solution {
public:
  int distinctSubseqII(string S) {
    constexpr int kMod = 1e9 + 7;
    std::vector<int> counts(26);
    for (char c : S)
      counts[c - 'a'] = accumulate(begin(counts), end(counts), 1L) % kMod;
    return accumulate(begin(counts), end(counts), 0L) % kMod;
  }
};

# Author: Huahua, running time: 64 ms
class Solution:
  def distinctSubseqII(self, S):
    kMod = 10**9 + 7
    dp = {}
    for c in S:
      dp[c] = (sum(dp.values()) + 1) % kMod
    return sum(dp.values()) % kMod

The post 花花酱 LeetCode 940. Distinct Subsequences II appeared first on Huahua's Tech Road.

Problem

Given an array of integers A, consider all non-empty subsequences of A.

For any sequence S, let the width of S be the difference between the maximum and minimum element of S.

Return the sum of the widths of all subsequences of A.

As the answer may be very large, return the answer modulo 10^9 + 7.

Example 1:

Input: [2,1,3]
Output: 6
Explanation:
Subsequences are [1], [2], [3], [2,1], [2,3], [1,3], [2,1,3].
The corresponding widths are 0, 0, 0, 1, 1, 2, 2.
The sum of these widths is 6.

Note:

• 1 <= A.length <= 20000
• 1 <= A[i] <= 20000

Solution: Math

Sort the array, for A[i]:

• i numbers <= A[i]. A[i] is the upper bound of 2^i subsequences.
• n – i – 1 numbers >= A[i]. A[i] is the lower bound of 2^(n – i – 1) subsequences.
• A[i] contributes A[i] * 2^i – A[i] * 2^(n – i – 1) to the ans.

\(ans = \sum\limits_{i=0}^{n-1}A_{i}2^{i} – A_{i}2^{n – i – 1} =\sum\limits_{i=0}^{n-1}(A_i – A_{n-i-1})2^{i}\)

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua
// Running time: 56 ms
class Solution {
public:
  int sumSubseqWidths(vector<int>& A) {
    constexpr long kMod = 1e9 + 7;
    const int n = A.size();
    sort(begin(A), end(A));
    long ans = 0;
    long p = 1;
    for (int i = 0; i < n; ++i) {
      ans = (ans + (A[i] - A[n - i - 1]) * p) % kMod;
      p = (p << 1) % kMod;
    }
    return (ans + kMod) % kMod;
  }
};

Time complexity: O(n)

Space complexity: O(n)

Counting sort

// Author: Huahua
// Running time: 16 / 44 ms (beats 100%)
static auto x = [](){std::ios::sync_with_stdio(false);cin.tie(nullptr);return nullptr;}();

class Solution {
public:
  int sumSubseqWidths(vector<int>& A) {
    constexpr long kMod = 1e9 + 7;
    const int n = A.size();    
    countingSort(A);
    long ans = 0;
    long p = 1;
    for (int i = 0; i < n; ++i) {
      ans = (ans + (A[i] - A[n - i - 1]) * p) % kMod;
      p = (p << 1) % kMod;
    }
    return (ans + kMod) % kMod;
  }
private:
  void countingSort(vector<int>& A) {    
    int max_v = INT_MIN;
    int min_v = INT_MAX;
    for (int a : A) {      
      if (a > max_v) max_v = a;
      if (a < min_v) min_v = a;      
    }      
    vector<int> c(max_v - min_v + 1);
    for (int a : A)
      ++c[a - min_v];
    int i = 0;
    int j = 0;
    while (i < c.size()) {
      if (--c[i] >= 0) 
        A[j++] = i + min_v;
      else
        ++i;
    }
  }
};

The post 花花酱 LeetCode 891. Sum of Subsequence Widths appeared first on Huahua's Tech Road.

Problem

Given a string S and a string T, count the number of distinct subsequences of S which equals T.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE" is a subsequence of "ABCDE" while "AEC" is not).

Example 1:

Input: S = "rabbbit", T = "rabbit"
Output: 3
Explanation:  As shown below, there are 3 ways you can generate "rabbit" from S. (The caret symbol ^ means the chosen letters) 
rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
^^^ ^^^

Example 2:

Input: S = "babgbag", T = "bag"
Output: 5
Explanation:  As shown below, there are 5 ways you can generate "bag" from S. (The caret symbol ^ means the chosen letters)
babgbag
^^ ^
babgbag
^^ ^
babgbag
^ ^^
babgbag
^ ^^
babgbag
^^^

Solution: DP

Time complexity: O(|s| * |t|)

Space complexity: O(|s| * |t|)

C++

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int numDistinct(string s, string t) {
    int ls = s.length();
    int lt = t.length();
    vector<vector<int>> dp(lt + 1, vector<int>(ls + 1));
    fill(begin(dp[0]), end(dp[0]), 1);        
    for (int i = 1; i <= lt; ++i)
      for (int j = 1; j <= ls; ++j)
        dp[i][j] = dp[i][j - 1] + (t[i - 1] == s[j - 1] ? dp[i - 1][j - 1] : 0);        
    return dp[lt][ls];
  }
};

Related Problems:

• 花花酱 LeetCode 72. Edit Distance

The post 花花酱 LeetCode 115. Distinct Subsequences 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.

Problem

题目大意：找出最长回文子序列的长度。

https://leetcode.com/problems/longest-palindromic-subsequence/description/

Given a string s, find the longest palindromic subsequence’s length in s. You may assume that the maximum length of s is 1000.

Example 1:
Input:

"bbbab"

Output:

4

One possible longest palindromic subsequence is “bbbb”.

Example 2:
Input:

"cbbd"

Output:

2

One possible longest palindromic subsequence is “bb”.

Solution: DP

Time complexity: O(n^2)

Space complexity: O(n^2)

C++

// Author: Huahua
// Running time: 102 ms
class Solution {
public:
  int longestPalindromeSubseq(string s) {
    const int n = s.length();
    vector<vector<int>> dp(n, vector<int>(n, 0));
    for (int l = 1; l <= n; ++l)
      for (int i = 0; i <= n - l; ++i) {
        int j = i + l - 1;
        if (i == j) {
          dp[i][j] = 1;
          continue;
        }
        dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
        if (s[i] == s[j])
          dp[i][j] = dp[i + 1][j - 1] + 2;
      }
    return dp[0][n - 1];
  }
};

Time complexity: O(n^2)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 28 ms
class Solution {
public:
  int longestPalindromeSubseq(string s) {
    const int n = s.length();
    vector<int> dp0(n); // sols of len = l
    vector<int> dp1(n); // sols of len = l - 1
    vector<int> dp2(n); // sols of len = l - 2
    for (int l = 1; l <= n; ++l) {    
      for (int i = 0; i <= n - l; ++i) {
        int j = i + l - 1;
        if (i == j) {
          dp0[i] = 1;
          continue;
        }
        if (s[i] == s[j])
          dp0[i] = dp2[i + 1] + 2;
        else
          dp0[i] = max(dp1[i + 1], dp1[i]);
      }
      dp0.swap(dp1);
      dp2.swap(dp0);
    }
    return dp1[0];
  }
};

Python3

"""
Author: Huahua
Running time: 1276 ms
"""
class Solution:
  def longestPalindromeSubseq(self, s):
    n = len(s)
    dp0 = [0] * n
    dp1 = [1] * n
    dp2 = [0] * n
    for l in range(2, n + 1):
      for i in range(0, n - l + 1):        
        j = i + l - 1
        if s[i] == s[j]:
          dp0[i] = dp2[i + 1] + 2
        else:
          dp0[i] = max(dp1[i + 1], dp1[i])      
      dp0, dp1, dp2 = dp2, dp0, dp1
    return dp1[0]

C#

// Author: Huahua
// Running time: 116 ms (beats 100%)
public class Solution {
  public int LongestPalindromeSubseq(string s) {
    var n = s.Length; 
    var dp0 = new int[n];
    var dp1 = new int[n];
    var dp2 = new int[n];
    
    for (var l = 1; l <= n; ++l) {
      for (var i = 0; i <= n - l; ++i) {
        int j = i + l - 1;
        if (i == j) {
          dp0[i] = 1;
          continue;
        }
        if (s[i] == s[j])
          dp0[i] = dp2[i + 1] + 2;
        else
          dp0[i] = Math.Max(dp1[i], dp1[i + 1]);
      }
      var tmp = dp2;
      dp2 = dp1;
      dp1 = dp0;
      dp0 = tmp;
    }
    return dp1[0];
  }
}

The post 花花酱 LeetCode 516. Longest Palindromic Subsequence appeared first on Huahua's Tech Road.