weekly Archives - Huahua's Tech Road

花花酱 LeetCode Weekly Contest 133

zxi — Sun, 21 Apr 2019 04:39:26 +0000

LeetCode 1029 Two City Scheduling

Solution1: DP

dp[i][j] := min cost to put j people into city A for the first i people
dp[0][0] = 0
dp[i][0] = dp[i -1][0] + cost_b
dp[i][j] = min(dp[i – 1][j] + cost_b, dp[i – 1][j – 1] + cost_a)
ans := dp[n][n/2]

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

C++

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int twoCitySchedCost(vector>& costs) {
    int n = costs.size();
    vector> dp(n + 1, vector(n + 1, INT_MAX / 2));
    dp[0][0] = 0;
    for (int i = 1; i <= n; ++i) {      
      dp[i][0] = dp[i - 1][0] + costs[i - 1][1];
      for (int j = 1; j <= i; ++j)
        dp[i][j] = min(dp[i - 1][j - 1] + costs[i - 1][0], 
                       dp[i - 1][j] + costs[i - 1][1]);
    }
    return dp[n][n / 2];
  }
};

Solution 2: Greedy

Sort by cost_a – cost_b

Choose the first n/2 people for A, rest for B

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

C++

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int twoCitySchedCost(vector>& costs) {
    int n = costs.size();
    sort(begin(costs), end(costs), [](const auto& c1, const auto& c2){
      return c1[0] - c1[1] < c2[0] - c2[1];
    });
    int ans = 0;
    for (int i = 0; i < n; ++i)
      ans += i < n/2 ? costs[i][0] : costs[i][1];    
    return ans;
  }
};

1030. Matrix Cells in Distance Order

Solution: Sorting

Time complexity: O(RC*log(RC))
Space complexity: O(RC)

C++

// Author: Huahua
class Solution {
public:
  vector> allCellsDistOrder(int R, int C, int r0, int c0) {
    vector> ans;
    for (int i = 0; i < R; ++i)
      for (int j = 0; j < C; ++j)
        ans.push_back({i, j});
    std::sort(begin(ans), end(ans), [r0, c0](const vector& a, const vector& b){
      return (abs(a[0] - r0) + abs(a[1] - c0)) < (abs(b[0] - r0) + abs(b[1] - c0));
    });
    return ans;
  }
};

1031. Maximum Sum of Two Non-Overlapping Subarrays

Solution: Prefix sum

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

C++

// Author: Huahua
class Solution {
public:
  int maxSumTwoNoOverlap(vector& A, int L, int M) {
    const int n = A.size();
    vector s(n + 1, 0);
    for (int i = 0; i < n; ++i)
      s[i + 1] = s[i] + A[i];
    int ans = 0;
    for (int i = 0; i <= n - L; ++i) {
      int ls = s[i + L] - s[i];
      int ms = max(maxSum(s, 0, i - M - 1, M), 
                   maxSum(s, i + L, n - M, M));
      ans = max(ans, ls + ms);      
    }
    return ans;
  }
private:
  int maxSum(const vector& s, int start, int end, int l) {
    int ans = INT_MIN;    
    for (int i = start; i <= end; ++i)
      ans = max(ans, s[i + l] - s[i]);
    return ans;
  }
};

1032. Stream of Characters

Solution: Trie

Time complexity:

build O(sum(len(w))
query O(max(len(w))

Space complexity: O(sum(len(w))

C++

// Author: Huahua, 320 ms, 95 MB
class TrieNode {
public:        
  ~TrieNode() {
    for (auto node : next_)
      delete node;
  }

  void reverse_build(const string& s, int i) {
    if (i == -1) {
      is_word_ = true;
      return;
    }
    const int idx = s[i] - 'a';
    if (!next_[idx]) next_[idx] = new TrieNode();
    next_[idx]->reverse_build(s, i - 1);
  }
  
  bool reverse_search(const string& s, int i) {
    if (i == -1 || is_word_) return is_word_;
    const int idx = s[i] - 'a';
    if (!next_[idx]) return false;
    return next_[idx]->reverse_search(s, i - 1);
  }

private:
  bool is_word_ = false;
  TrieNode* next_[26] = {0};
};

class StreamChecker {
public:
  StreamChecker(vector& words) {
    root_ = std::make_unique();
    for (const string& w : words)
      root_->reverse_build(w, w.length() - 1);
  }

  bool query(char letter) {
    s_ += letter;
    return root_->reverse_search(s_, s_.length() - 1);    
  }
  
private:
  string s_;
  unique_ptr root_;
};

Java

// Author: Huahua, running time: 133 ms
class StreamChecker {
  class TrieNode {
    public TrieNode() {
      isWord = false;
      next = new TrieNode[26];
    }
    public boolean isWord;
    public TrieNode next[];    
  }
  
  private TrieNode root;
  private StringBuilder sb;

  public StreamChecker(String[] words) {
    root = new TrieNode();
    sb = new StringBuilder();
    for (String word : words) {
      TrieNode node = root;
      char[] w = word.toCharArray();
      for (int i = w.length - 1; i >= 0; --i) {        
        int idx = w[i] - 'a';
        if (node.next[idx] == null) node.next[idx] = new TrieNode();
        node = node.next[idx];
      }
      node.isWord = true;
    }
  }

  public boolean query(char letter) {
    sb.append(letter);
    TrieNode node = root;
    for (int i = sb.length() - 1; i >= 0; --i) {      
      int idx = sb.charAt(i) - 'a';
      if (node.next[idx] == null) return false;
      if (node.next[idx].isWord) return true;
      node = node.next[idx];
    }
    return false;
  }  
}

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

花花酱 LeetCode Weekly Contest 131 (1021, 1022, 1023, 1024)

zxi — Sun, 07 Apr 2019 22:46:19 +0000

LeetCode 1021. Remove Outermost Parentheses

Solution: Track # of opened parentheses

Let n denote the # of opened parentheses after current char, keep ‘(‘ if n > 1 and keep ‘)’ if n > 0

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

C++

// Author: Huahua
class Solution {
public:
  string removeOuterParentheses(string S) {    
    string ans;
    int n = 0;    
    for (char c : S) {      
      if (c == '(' && n++) ans += c;
      if (c == ')' && --n) ans += c;      
    }
    return ans;
  }
};

LeetCode 1022. Sum of Root To Leaf Binary Numbers

Solution: Recursion + Math

Keep tracking the number from root to current node.

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

C++

class Solution {
public:
    int sumRootToLeaf(TreeNode* root) {      
      return sums(root, 0);
    }
private:
    static constexpr int kMod = 1e9 + 7;
    int sums(TreeNode* root, int c) {
      if (!root) return 0;
      c = ((c << 1) | root->val) % kMod;
      if (!root->left && !root->right) {
        return c;
      }
      return sums(root->left, c) + sums(root->right, c);
    }
};

LeetCode 1023. Camelcase Matching

Solution: String…

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

C++

// Author: Huahua
class Solution {
public:
  vector camelMatch(vector& queries, string p) {
    vector ans;
    for (const string& q : queries)
      ans.push_back(match(q, p));
    return ans;
  }
private:
  bool match(const string& q, const string& p) {    
    int m = p.length();
    int n = q.length();
    int i = 0;
    int j = 0;
    for (i = 0; i < n; ++i) {      
      if (j == m && isupper(q[i])) return false;      
      if ((j == m || isupper(p[j])) && islower(q[i])) continue;        
      if ((isupper(p[j]) || isupper(q[i])) && p[j] != q[i]) return false;
      if (islower(p[j]) && p[j] != q[i]) continue;
      ++j;
    }
    return i == n && j == m;
  }
};

LeetCode 1024. Video Stitching

Solution 1: DP

Time complexity: O(nT^2)
Space complexity: O(T^2)

C++

// Author: Huahua, 16 ms / 9.5 MB
class Solution {
public:
  int videoStitching(vector>& clips, int T) {
    constexpr int kInf = 101;
    // dp[i][j] := min clips to cover range [i, j]
    vector> dp(T + 1, vector(T + 1, kInf));   
    for (const auto& c : clips) {
      int s = c[0];
      int e = c[1];
      for (int l = 1; l <= T; ++l) {
        for (int i = 0; i <= T - l; ++i) {
          int j = i + l;
          if (s > j || e < i) continue;
          if (s <= i && e >= j) dp[i][j] = 1;
          else if (e >= j) dp[i][j] = min(dp[i][j], dp[i][s] + 1);
          else if (s <= i) dp[i][j] = min(dp[i][j], dp[e][j] + 1);
          else dp[i][j] = min(dp[i][j], dp[i][s] + 1 + dp[e][j]);          
        }
      }
    }
    return dp[0][T] == kInf ? -1 : dp[0][T];
  }
};

C++/V2

// Author: Huahua, running time: 20 ms / 9.4 MB
class Solution {
public:
  int videoStitching(vector>& clips, int T) {
    constexpr int kInf = 101;
    // dp[i][j] := min clips to cover range [i, j]
    vector> dp(T + 1, vector(T + 1));
    for (int i = 0; i <= T; ++i)
      for (int j = 0; j <= T; ++j)
        dp[i][j] = i < j ? kInf : 0;
    for (const auto& c : clips) {
      const int s = min(c[0], T);
      const int e = min(c[1], T);
      for (int l = 1; l <= T; ++l)
        for (int i = 0, j = l; j <= T; ++i, ++j)
          dp[i][j] = min(dp[i][j], dp[i][s] + 1 + dp[e][j]);
    }
    return dp[0][T] == kInf ? -1 : dp[0][T];
  }
};

The post 花花酱 LeetCode Weekly Contest 131 (1021, 1022, 1023, 1024) appeared first on Huahua's Tech Road.

花花酱 LeetCode Weekly Contest 130 (1017, 1018, 1019, 1020)

zxi — Sun, 31 Mar 2019 04:58:31 +0000

1017. Convert to Base -2

Solution: Math / Simulation

Time complexity: O(logn)
Space complexity: O(logn)

C++

// Author: Huahua
class Solution {
public:
  string baseNeg2(int N) {
    if (N == 0) return "0"; 
    vector ans;
    while (N) {
      ans.push_back((N & 1) + '0');
      N = -(N >> 1);
    }    
    return {rbegin(ans), rend(ans)};
  }
};

base K

// Author: Huahua
class Solution {
public:  
  string baseNeg2(int N) {   
    if (N == 0) return "0"; 
    return baseNegK(N, -2);
  }
private:
  string baseNegK(int N, int K) {
    vector ans;
    while (N) {
      int r = N % K;
      N /= K;
      if (r < 0) {
        r += -K;
        N += 1;
      }
      ans.push_back(r + '0');
    }    
    return {rbegin(ans), rend(ans)};
  }
};

1018. Binary Prefix Divisible By 5

Solution: Math

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

C++

// Author: Huahua
class Solution {
public:
  vector prefixesDivBy5(vector& A) {
    int num = 0;
    vector ans(A.size());    
    for (int i = 0; i < A.size(); ++i) {
      num = ((num << 1) | A[i]) % 5;
      ans[i] = num == 0;
    }
    return ans;
  }
};

1019. Next Greater Node In Linked List

Solution: Reverse + Monotonic Stack

Process in reverse order and keep a monotonically increasing stack, pop all the elements that are smaller than the current one, then the top of the stack (if exists) will be the next greater node.

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

C++

// Author: Huahua
class Solution {
public:
  vector nextLargerNodes(ListNode* head) {    
    vector nums;
    while (head) {
      nums.push_back(head->val);
      head = head->next;      
    }
    stack s;
    vector ans(nums.size());
    for (int i = nums.size() - 1; i >= 0; --i) {
      while (!s.empty() && s.top() <= nums[i]) s.pop();
      ans[i] = s.empty() ? 0 : s.top();
      s.push(nums[i]);
    }
    return ans;
  }
};

1020. Number of Enclaves

Solution: DFS / Connected Components

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

C++

// Author: Huahua
class Solution {
public:
  int numEnclaves(vector>& A) {
    int ans = 0;
    for (int i = 0; i < A.size(); ++i)
      for (int j = 0; j < A[0].size(); ++j) {
        int count = 0;
        if (!dfs(A, j, i, count))
          ans += count;
      }
    return ans;
  }
private:
  static constexpr int dirs[5]{0, -1, 0, 1, 0};
  bool dfs(vector>& A, int x, int y, int& count) {
    if (x < 0 || x == A[0].size() || y < 0 || y == A.size()) return true;    
    if (A[y][x] == 0) return false;    
    ++count;
    A[y][x] = 0;
    bool valid = false;    
    for (int i = 0; i < 4; ++i)
      valid |= dfs(A, x + dirs[i], y + dirs[i + 1], count);
    return valid;
  }
};

The post 花花酱 LeetCode Weekly Contest 130 (1017, 1018, 1019, 1020) appeared first on Huahua's Tech Road.

花花酱 LeetCode Weekly Contest 129 (1020, 1021, 1022, 1023)

zxi — Sun, 24 Mar 2019 15:08:48 +0000

1020. Partition Array Into Three Parts With Equal Sum

Return true if there is a 2/3*sum prefix sum after a 1/3 prefix sum

[---- 1/3 ----][-----1/3-----][-----1/3-----]
[------------2/3-------------][-----1/3-----]

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

Python

class Solution:
  def canThreePartsEqualSum(self, A: List[int]) -> bool:
    s = sum(A)
    if s % 3 != 0: return False    
    c = 0
    found = False
    for a in A:
      c += a
      if c == s // 3 * 2 and found: return True
      if c == s // 3: found = True
    return False

1021. Best Sightseeing Pair

Greedy, only keep the best A[i] + i so far and pair with A[j] – j, i < j

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

C++

class Solution {
public:
  int maxScoreSightseeingPair(vector& A) {
    int ans = 0;
    int left = 0;
    for (int i = 0; i < A.size(); ++i) {
      ans = max(ans, left + A[i] - i);
      left = max(left, A[i] + i);
    }
    return ans;
  }
};

1022. Smallest Integer Divisible by K

Math

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

C++

class Solution {
public:
  int smallestRepunitDivByK(int K) {
    if (K % 2 == 0 || K % 5 == 0) return -1;
    int r = 0;
    for (int l = 1; l <= K; ++l) {
      r = (r * 10 + 1) % K;
      if (r == 0) return l;
    }
    return -1;
  }
};

1023. Binary String With Substrings Representing 1 To N

Brute Force, try all possible substrings and convert them into decimals.

Time complexity: O(|S|*log(N)^2)

Python

class Solution:
  def queryString(self, S: str, N: int) -> bool:
    s = set()
    c = 0    
    for l in range(1, 32):
      for i in range(0, len(S) - l + 1):        
        n = int(S[i:i+l], 2)
        if n == 0 or n > N or n in s: continue        
        s.add(n)
        c += 1
    return c == N

The post 花花酱 LeetCode Weekly Contest 129 (1020, 1021, 1022, 1023) appeared first on Huahua's Tech Road.

花花酱 LeetCode Weekly 123

zxi — Mon, 11 Feb 2019 04:28:00 +0000

Solutions

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

花花酱 LeetCode Weekly Contest 121

zxi — Sun, 27 Jan 2019 18:39:19 +0000

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