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. (eg, “ace” is a subsequence of “abcde” while “aec” is not). A common subsequence of two strings is a subsequence that is common to both strings.

If there is no common subsequence, return 0.

Example 1:

Input: text1 = "abcde", text2 = "ace" 
Output: 3  
Explanation: The longest common subsequence is "ace" and its length is 3.

Example 2:

Input: text1 = "abc", text2 = "abc"
Output: 3
Explanation: The longest common subsequence is "abc" and its length is 3.

Example 3:

Input: text1 = "abc", text2 = "def"
Output: 0
Explanation: There is no such common subsequence, so the result is 0.

Constraints:

• 1 <= text1.length <= 1000
• 1 <= text2.length <= 1000
• The input strings consist of lowercase English characters only.

Solution: DP

Use dp[i][j] to represent the length of longest common sub-sequence of text1[0:i] and text2[0:j]
dp[i][j] = dp[i – 1][j – 1] + 1 if text1[i – 1] == text2[j – 1] else max(dp[i][j – 1], dp[i – 1][j])

Time complexity: O(mn)
Space complexity: O(mn) -> O(n)

// Author: Huahua, 16ms 14.9 MB
class Solution {
public:
  int longestCommonSubsequence(string text1, string text2) {
    int m = text1.length();
    int n = text2.length();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        if (text1[i] == text2[j])
          dp[i + 1][j + 1] = dp[i][j] + 1;
        else
          dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);      
    return dp[m][n];
  }
};

// Author: Huahua, 8ms, 8.8MB
class Solution {
public:
  int longestCommonSubsequence(string text1, string text2) {
    int m = text1.length();
    int n = text2.length();    
    vector<int> dp(n + 1);    
    for (int i = 0; i < m; ++i) {
      int prev = 0; // dp[i][j]
      for (int j = 0; j < n; ++j) {        
        int curr = dp[j + 1]; // dp[i][j + 1]
        if (text1[i] == text2[j])
          // dp[i + 1][j + 1] = dp[i][j] + 1
          dp[j + 1] = prev + 1; 
        else
          // dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j])
          dp[j + 1] = max(curr, dp[j]);
        prev = curr;
      }    
    }    
    return dp[n]; // dp[m][n]
  }
};

// Author: Huahua
class Solution {
public:
  int longestCommonSubsequence(string text1, string text2) {
    int m = text1.length();
    int n = text2.length();    
    vector<int> dp1(n + 1);
    vector<int> dp2(n + 1);
    for (int i = 0; i < m; ++i) {      
      for (int j = 0; j < n; ++j)
        if (text1[i] == text2[j])
          dp2[j + 1] = dp1[j] + 1; 
        else          
          dp2[j + 1] = max(dp1[j + 1], dp2[j]);              
      swap(dp1, dp2);
    }    
    return dp1[n];
  }
};

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

Solution: Simulation (priority_queue)

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

// Author: Huahua
class Solution {
public:
  int lastStoneWeight(vector<int>& stones) {
    priority_queue<int> q;
    for (int s : stones)
      q.push(s);
    while (q.size() > 1) {
      int x = q.top(); q.pop();
      int y = q.top(); q.pop();
      if (x == y) continue;
      q.push(abs(x - y));
    }
    return q.empty() ? 0 : q.top();
  }
};

1047. Remove All Adjacent Duplicates In String

Solution: Stack / Deque

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

class Solution {
public:
  string removeDuplicates(string S) {
    deque<char> s;
    for (char c : S) {
      if (!s.empty() && s.back() == c) s.pop_back();
      else s.push_back(c);
    }    
    return {begin(s), end(s)};
  }
};

1048. Longest String Chain

Solution: DP

dp[i] := max length of chain of (A[0] ~ A[i-1])

dp[i] = max{dp[j] + 1} if A[j] is prederrsor of A[i], 1 <= j <i

Time complexity: O(n^2*l)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int longestStrChain(vector<string>& words) {
    int n = words.size();
    sort(begin(words), end(words), [](const string& a, const string& b) { 
      return a.length() < b.length();
    });
    vector<int> dp(n, 1);    
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < i; ++j) 
        if (valid(words[j], words[i]))
          dp[i] = dp[j] + 1;
    return *max_element(begin(dp), end(dp));
  }
private:
  bool valid(const string& a, const string& b) {
    if (a.length() + 1 != b.length()) return false;
    int count = 0;
    for (int i = 0, j = 0; i < a.length() && j < b.length();) {
      if (a[i] == b[j]) {
        ++i; ++j;
      } else { 
        ++count; ++j; 
      }
    }
    return count <= 1;
  }
};

1049. Last Stone Weight II

Solution: DP / target sum

Time complexity: O(n * S) = O(n * 100)

Space complexity: O(S) = O(100)

// Author: Huahua
class Solution {
public:
  int lastStoneWeightII(vector<int>& stones) {
    const int n = stones.size();
    const int max_sum = accumulate(begin(stones), end(stones), 0);    
    unordered_set<int> sums;
    sums.insert(stones[0]);
    sums.insert(-stones[0]);
    for (int i = 1; i < n; ++i) {
      unordered_set<int> tmp;
      for (int s : sums) {
        tmp.insert(s + stones[i]);
        tmp.insert(s - stones[i]);
      }
      swap(tmp, sums);
    }
    int ans = INT_MAX;
    for (int s : sums)           
      ans = min(ans, abs(s));
    return ans;
  }
};

The post 花花酱 LeetCode Weekly Contest 137 appeared first on Huahua's Tech Road.

There are N piles of stones arranged in a row.  The i-th pile has stones[i] stones.

A move consists of merging exactly K consecutive piles into one pile, and the cost of this move is equal to the total number of stones in these K piles.

Find the minimum cost to merge all piles of stones into one pile.  If it is impossible, return -1.

Example 1:

Input: stones = [3,2,4,1], K = 2
Output: 20
Explanation: 
We start with [3, 2, 4, 1].
We merge [3, 2] for a cost of 5, and we are left with [5, 4, 1].
We merge [4, 1] for a cost of 5, and we are left with [5, 5].
We merge [5, 5] for a cost of 10, and we are left with [10].
The total cost was 20, and this is the minimum possible.

Example 2:

Input: stones = [3,2,4,1], K = 3
Output: -1
Explanation: After any merge operation, there are 2 piles left, and we can't merge anymore.  So the task is impossible.

Example 3:

Input: stones = [3,5,1,2,6], K = 3
Output: 25
Explanation: 
We start with [3, 5, 1, 2, 6].
We merge [5, 1, 2] for a cost of 8, and we are left with [3, 8, 6].
We merge [3, 8, 6] for a cost of 17, and we are left with [17].
The total cost was 25, and this is the minimum possible.

Note:

• 1 <= stones.length <= 30
• 2 <= K <= 30
• 1 <= stones[i] <= 100

Solution: DP

dp[i][j][k] := min cost to merge subarray i ~ j into k piles
Init: dp[i][j][k] = 0 if i==j and k == 1 else inf
ans: dp[0][n-1][1]
transition:
1. dp[i][j][k] = min{dp[i][m][1] + dp[m+1][j][k-1]} for all i <= m < j
2. dp[i][j][1] = dp[i][j][K] + sum(A[i]~A[j])

Time complexity: O(n^3)
Space complexity: O(n^2*K)

// Running time: 12 ms, 12.1 MB
class Solution {
public:
  int mergeStones(vector<int>& stones, int K) {
    const int n = stones.size();
    if ((n - 1) % (K - 1)) return -1;
    const int kInf = 1e9;    
    vector<int> sums(n + 1);
    for (int i = 0; i < stones.size(); ++i)
      sums[i + 1] = sums[i] + stones[i];
    // dp[i][j][k] := min cost to merge subarray i~j into k piles.
    vector<vector<vector<int>>> dp(n, vector<vector<int>>(n, vector<int>(K + 1, kInf)));
    for (int i = 0; i < n; ++i)
      dp[i][i][1] = 0;
    
    for (int l = 2; l <= n; ++l) // subproblem length
      for (int i = 0; i <= n - l; ++i) { // start
        int j = i + l - 1; // end
        for (int k = 2; k <= K; ++k) // piles
          for (int m = i; m < j; m += K - 1) // split point
            dp[i][j][k] = min(dp[i][j][k], dp[i][m][1] + dp[m + 1][j][k - 1]);
        dp[i][j][1] = dp[i][j][K] + sums[j + 1] - sums[i];
      }        
    return dp[0][n - 1][1];
  }
};

// Author: Huahua, running time: 12 ms
class Solution {
public:
  int mergeStones(vector<int>& stones, int K) {
    const int n = stones.size();
    if ((n - 1) % (K - 1)) return -1;
    const int kInf = 1e9;
    vector<int> sums(n + 1);
    for (int i = 0; i < stones.size(); ++i)
      sums[i + 1] = sums[i] + stones[i];
    
    vector<vector<vector<int>>> cache(n, vector<vector<int>>(n, vector<int>(K + 1, INT_MAX)));
    std::function<int(int, int, int)> dp = [&stones, &sums, &cache, kInf, n, K, &dp](int i, int j, int k) {
      if ((j - i + 1 - k) % (K - 1)) return kInf;
      if (i == j) return k == 1 ? 0 : kInf;
      if (cache[i][j][k] != INT_MAX) return cache[i][j][k];      
      if (k == 1)
        return cache[i][j][k] = dp(i, j, K) + sums[j + 1] - sums[i];
      int ans = kInf;
      for (int m = i; m < j; m += K - 1) {
        int l = dp(i, m, 1);
        if (l >= ans) continue;
        int r = dp(m + 1, j, k - 1);
        if (r >= ans) continue;
        ans = min(ans, l + r);
      }
      return cache[i][j][k] = ans;
    };
    return dp(0, n - 1, 1);
  }
};

Solution 2: DP

dp[l][i] := min cost to merge [i, i + l) into as less piles as possible. Number of merges will be (l-1) / (K – 1) and
Transition: dp[l][i] = min(dp[m][i] + dp[l – m][i + m]) for 1 <= m < l
if ((l – 1) % (K – 1) == 0) [i, i + l) can be merged into 1 pile, dp[l][i] += sum(A[i:i+l])

Time complexity: O(n^3 / k)
Space complexity: O(n^2)

// Author: Huahua 4ms, 9.6 MB
class Solution {
public:
  int mergeStones(vector<int>& stones, int K) {
    const int n = stones.size();
    if ((n - 1) % (K - 1)) return -1;
        
    vector<int> sums(n + 1);
    for (int i = 0; i < stones.size(); ++i) 
      sums[i + 1] = sums[i] + stones[i];
    
    const int kInf = 1e9;
    // dp[i][j] := min cost to merge subarray A[i] ~ A[j] into (j-i)%(K-1) + 1 piles
    vector<vector<int>> dp(n, vector<int>(n, kInf));
    for (int i = 0; i < n; ++i) dp[i][i] = 0;
    
    for (int l = 2; l <= n; ++l) // subproblem length 
      for (int i = 0; i <= n - l; ++i) { // start        
        int j = i + l - 1;
        for (int m = i; m < j ; m += K - 1) // split point
            dp[i][j] = min(dp[i][j], dp[i][m] + dp[m + 1][j]);
        // If the current length can be merged into 1 pile
        // The cost is independent of the merge orders.
        if ((l - 1) % (K - 1) == 0)
          dp[i][j] += sums[j + 1] - sums[i];
      }
    return dp[0][n - 1];
  }
};

// Author: Huahua, 4 ms
class Solution {
public:
  int mergeStones(vector<int>& stones, int K) {
    const int n = stones.size();
    if ((n - 1) % (K - 1)) return -1;
    const int kInf = 1e9;
    vector<vector<int>> cache(n, vector<int>(n, kInf));    
    vector<int> sums(n + 1);
    for (int i = 0; i < stones.size(); ++i) sums[i + 1] = sums[i] + stones[i];
    
    std::function<int(int, int)> dp;
    dp = [&stones, &sums, &cache, &dp, K, kInf](int i, int j) {
      const int l = j - i + 1;
      if (l < K) return 0;
      if (cache[i][j] != kInf) return cache[i][j];
      int ans = kInf;
      for (int m = i; m < j ; m += K - 1) // split point
        ans = min(ans, dp(i, m) + dp(m + 1, j));
      if ((l - 1) % (K - 1) == 0)
        ans += sums[j + 1] - sums[i];
      return cache[i][j] = ans;
    };    
    return dp(0, n - 1);  
  }
};

The post 花花酱 LeetCode 1000. Minimum Cost to Merge Stones appeared first on Huahua's Tech Road.

Problem

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. You may assume the dictionary does not contain duplicate words.

Return all such possible sentences.

For example, given
s = "catsanddog",
dict = ["cat", "cats", "and", "sand", "dog"].

A solution is ["cats and dog", "cat sand dog"].

UPDATE (2017/1/4):
The wordDict parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

Solution

Time complexity: O(2^n)

Space complexity: O(2^n)

C++

// Author: Huahua
class Solution {
public:
    vector<string> wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> dict(wordDict.cbegin(), wordDict.cend());
        return wordBreak(s, dict);
    }
private:
    // >> append({"cats and", "cat sand"}, "dog");
    // {"cats and dog", "cat sand dog"}
    vector<string> append(const vector<string>& prefixes, const string& word) {
        vector<string> results;
        for(const auto& prefix : prefixes)
            results.push_back(prefix + " " + word);
        return results;
    }
    
    const vector<string>& wordBreak(string s, unordered_set<string>& dict) {
        // Already in memory, return directly
        if(mem_.count(s)) return mem_[s];
        
        // Answer for s
        vector<string> ans;
        
        // s in dict, add it to the answer array
        if(dict.count(s)) 
            ans.push_back(s);
        
        for(int j=1;j<s.length();++j) {
            // Check whether right part is a word
            const string& right = s.substr(j);
            if (!dict.count(right)) continue;
            
            // Get the ans for left part
            const string& left = s.substr(0, j);
            const vector<string> left_ans = 
                append(wordBreak(left, dict), right);
            
            // Notice, can not use mem_ here,
            // since we haven't got the ans for s yet.
            ans.insert(ans.end(), left_ans.begin(), left_ans.end());
        }
        
        // memorize and return
        mem_[s].swap(ans);
        return mem_[s];
    }
private:
    unordered_map<string, vector<string>> mem_;
};

Python3

"""
Author: Huahua
Running time: 56 ms
"""
class Solution:
  def wordBreak(self, s, wordDict):
    words = set(wordDict)
    mem = {}
    def wordBreak(s):
      if s in mem: return mem[s]
      ans = []
      if s in words: ans.append(s)
      for i in range(1, len(s)):
        right = s[i:]
        if right not in words: continue        
        ans += [w + " " + right for w in wordBreak(s[0:i])]
      mem[s] = ans
      return mem[s]
    return wordBreak(s)

Related Problems

• [解题报告] Leetcode 139. Word Break 花花酱
• [解题报告] LeetCode 127. Word Ladder
• [解题报告] LeetCode 126. Word Ladder II

The post 花花酱 Leetcode 140. Word Break II appeared first on Huahua's Tech Road.

Problem

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words. You may assume the dictionary does not contain duplicate words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

UPDATE (2017/1/4):
The wordDict parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

Idea:

DP

Time complexity O(n^2)

Space complexity O(n^2)

Solutions:

C++

// Author: Huahua
class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        // Create a hashset of words for fast query.
        unordered_set<string> dict(wordDict.cbegin(), wordDict.cend());
        // Query the answer of the original string.
        return wordBreak(s, dict);
    }
    
    bool wordBreak(const string& s, const unordered_set<string>& dict) {
        // In memory, directly return.
        if(mem_.count(s)) return mem_[s];
        // Whole string is a word, memorize and return.
        if(dict.count(s)) return mem_[s]=true;
        // Try every break point.
        for(int j=1;j<s.length();j++) {
            const string left = s.substr(0,j);
            const string right = s.substr(j);
            // Find the solution for s.
            if(dict.count(right) && wordBreak(left, dict))
                return mem_[s]=true;
        }
        // No solution for s, memorize and return.
        return mem_[s]=false;
    }
private:
    unordered_map<string, bool> mem_;
};

C++ V2 without using dict. Updated: 1/9/2018

// Author: Huahua
// Running time: 9 ms
class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
      // Mark evert word as breakable.
      for (const string& word : wordDict)
        mem_.emplace(word, true);

      // Query the answer of the original string.
      return wordBreak(s);
    }
    
    bool wordBreak(const string& s) {
      // In memory, directly return.
      if (mem_.count(s)) return mem_[s];

      // Try every break point.
      for (int j = 1; j < s.length(); j++) {         
          auto it = mem_.find(s.substr(j));
          // Find the solution for s.
          if (it != mem_.end() && it->second && wordBreak(s.substr(0, j)))
            return mem_[s] = true;
      }
      
      // No solution for s, memorize and return.
      return mem_[s] = false;
    }
private:
    unordered_map<string, bool> mem_;
};

Java

// Author: Huahua
// Runtime: 13 ms
class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> dict = new HashSet<String>(wordDict);
        Map<String, Boolean> mem = new HashMap<String, Boolean>();
        return wordBreak(s, mem, dict);
    }

    private boolean wordBreak(String s,
                              Map<String, Boolean> mem, 
                              Set<String> dict) {
        if (mem.containsKey(s)) return mem.get(s);
        if (dict.contains(s)) {
            mem.put(s, true);
            return true;
        }
        
        for (int i = 1; i < s.length(); ++i) {
            if (dict.contains(s.substring(i)) && wordBreak(s.substring(0, i), mem, dict)) {
                mem.put(s, true);
                return true;
            }
        }
        
        mem.put(s, false);
        return false;
    }
}

Python

"""
Author: Huahua
Runtime: 42 ms
"""
class Solution(object):
    def wordBreak(self, s, wordDict):
        def canBreak(s, m, wordDict):
            if s in m: return m[s]
            if s in wordDict: 
                m[s] = True
                return True
            
            for i in range(1, len(s)):
                r = s[i:]
                if r in wordDict and canBreak(s[0:i], m, wordDict):
                    m[s] = True
                    return True
            
            m[s] = False
            return False
            
        return canBreak(s, {}, set(wordDict))

The post 花花酱 Leetcode 139. Word Break appeared first on Huahua's Tech Road.

Problem

Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins.

Given an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score.

Example 1:
Input: [1, 5, 2]
Output: False
Explanation: Initially, player 1 can choose between 1 and 2.
If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2).
So, final score of player 1 is 1 + 2 = 3, and player 2 is 5.
Hence, player 1 will never be the winner and you need to return False.

Example 2:
Input: [1, 5, 233, 7]
Output: True
Explanation: Player 1 first chooses 1. Then player 2 have to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.
Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.
Note:
1 <= length of the array <= 20.
Any scores in the given array are non-negative integers and will not exceed 10,000,000.
If the scores of both players are equal, then player 1 is still the winner.

Solution 1: Recursion

Time complexity: O(2^n)

Space complexity: O(n)

// Author: Huahua
// Running time: 67 ms
class Solution {
public:
  bool PredictTheWinner(vector<int>& nums) {    
    return getScore(nums, 0, nums.size() - 1) >= 0;
  }
private:  
  // Max diff (my_score - op_score) of subarray nums[l] ~ nums[r].
  int getScore(vector<int>& nums, int l, int r) {
    if (l == r) return nums[l];
    return max(nums[l] - getScore(nums, l + 1, r), 
               nums[r] - getScore(nums, l, r - 1));    
  }
};

Solution 2: Recursion + Memoization

Time complexity: O(n^2)

Space complexity: O(n)

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  bool PredictTheWinner(vector<int>& nums) {
    m_ = vector<vector<int>>(nums.size(), vector<int>(nums.size(), INT_MIN));
    return getScore(nums, 0, nums.size() - 1) >= 0;
  }
private:
  vector<vector<int>> m_;
  // Max diff (my_score - op_score) of subarray nums[l] ~ nums[r].
  int getScore(vector<int>& nums, int l, int r) {
    if (l == r) return nums[l];    
    if (m_[l][r] != INT_MIN) return m_[l][r];
    m_[l][r] = max(nums[l] - getScore(nums, l + 1, r), 
                   nums[r] - getScore(nums, l, r - 1));
    return m_[l][r];
  }    
};

DP version

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  bool PredictTheWinner(vector<int>& nums) {
    const int n = nums.size();
    vector<vector<int>> dp(n, vector<int>(n, INT_MIN));
    for (int i = 0; i < n; ++i)
      dp[i][i] = nums[i];
    for (int l = 2; l <= n; ++l)
      for (int i = 0; i <= n - l; ++i) {
        int j = i + l - 1;
        dp[i][j] = max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
      }
    return dp[0][n - 1] >= 0;
  }
};

Related Problem

• 花花酱 LeetCode 877. Stone Game

The post 花花酱 LeetCode 486. Predict the Winner appeared first on Huahua's Tech Road.