weekly contest Archives - Huahua's Tech Road https://zxi.mytechroad.com/blog/tag/weekly-contest/ Sun, 19 May 2019 04:06:17 +0000 en hourly 1 https://wordpress.org/?v=6.0.8 https://zxi.mytechroad.com/blog/wp-content/uploads/2017/09/cropped-photo-32x32.jpg weekly contest Archives - Huahua's Tech Road https://zxi.mytechroad.com/blog/tag/weekly-contest/ 32 32 花花酱 LeetCode Weekly Contest 137 https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-137/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-137/#respond Sun, 19 May 2019 04:00:15 +0000 https://zxi.mytechroad.com/blog/?p=5206 1046. Last Stone Weight Solution: Simulation (priority_queue) Time complexity: O(nlogn)Space complexity: O(n) [crayon-6646c606c9b77892139901/] 1047. Remove All Adjacent Duplicates In String Solution: Stack / Deque Time complexity:…

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

]]> 1046. Last Stone Weight

Solution: Simulation (priority_queue)

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

C++

// 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)

C++

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)

C++

// 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)

C++

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

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-137/feed/ 0 花花酱 LeetCode Weekly Contest 135 (1037, 1038, 1039, 1040) https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-135-1037-1038-1039-1040/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-135-1037-1038-1039-1040/#respond Sun, 05 May 2019 04:58:09 +0000 https://zxi.mytechroad.com/blog/?p=5142 LeetCode 1037. Valid Boomerang Solution: MathTime complexity: O(1)Space complexity: O(1) [crayon-6646c606ca016416121225/] LeetCode 1038. Binary Search Tree to Greater Sum Tree Solution: Recursion: right, root, left Time…

The post 花花酱 LeetCode Weekly Contest 135 (1037, 1038, 1039, 1040) appeared first on Huahua's Tech Road.

]]> LeetCode 1037. Valid Boomerang

Solution: Math
Time complexity: O(1)
Space complexity: O(1)

C++

class Solution {
public:
  bool isBoomerang(vector<vector<int>>& points) {
    if (points[0] == points[1] || 
        points[1] == points[2] ||
        points[0] == points[2]) return false;
    int dx0 = points[0][0] - points[1][0];
    int dy0 = points[0][1] - points[1][1];
    int dx1 = points[0][0] - points[2][0];
    int dy1 = points[0][1] - points[2][1];    
    return dy0 * dx1 != dy1 * dx0;
  }
};

LeetCode 1038. Binary Search Tree to Greater Sum Tree

Solution: Recursion: right, root, left

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

C++

class Solution {
public:
  TreeNode* bstToGst(TreeNode* root) {     
    int s = 0;    
    function<void(TreeNode*)> dfs = [&](TreeNode* n) {
      if (!n) return;
      dfs(n->right);
      n->val = s += n->val;      
      dfs(n->left);
    };
    dfs(root);
    return root;
  }
};

1039. Minimum Score Triangulation of Polygon

Solution: DP

Init: dp[i][j] = 0 if 0 <= j – i <= 1
dp[i][j] := min score to triangulate A[i] ~ A[j]
dp[i][j] = min{dp[i][k] + dp[k][j] + A[i]*A[k]*A[j]), i < k < j
answer: dp[0][n – 1]

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

C++/bottom-up

class Solution {
public:
  int minScoreTriangulation(vector<int>& A) {
    const int n = A.size();
    vector<vector<int>> dp(n, vector<int>(n));
    for (int l = 3; l <= n; ++l)
      for (int i = 0; i + l <= n; ++i) {        
        int j = i + l - 1;
        dp[i][j] = INT_MAX;
        for (int k = i + 1; k <= j - 1; ++k)
          dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + A[i] * A[k] * A[j]);
      }
    return dp[0][n - 1];
  }
};

C++/top-down

class Solution {
public:
  int minScoreTriangulation(vector<int>& A) {
    const int n = A.size();
    vector<vector<int>> dp(n, vector<int>(n, INT_MAX));
    function<int(int, int)> solve = [&](int i, int j) {
      if (j - i <= 1) return 0;
      if (dp[i][j] != INT_MAX) return dp[i][j];
      dp[i][j] = INT_MAX;
      for (int k = i + 1; k <= j - 1; ++k)
        dp[i][j] = min(dp[i][j], 
                       solve(i, k) + solve(k, j) + A[i] * A[k] * A[j]);
      return dp[i][j];  
    };
    return solve(0, n - 1);
  }
};

Python

"Author: Huahua"
from functools import lru_cache

class Solution:
  def minScoreTriangulation(self, A: List[int]) -> int:     
    @lru_cache(None)
    def dp(i, j):      
      return 0 if j - i <= 1 else min(dp(i, k) + dp(k, j) + A[i] * A[k] * A[j] for k in range(i + 1, j))
    return dp(0, len(A) - 1)

1040. Moving Stones Until Consecutive II

Solution: Sliding Window

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

C++

class Solution {
public:
  vector<int> numMovesStonesII(vector<int>& stones) {
    const int n = static_cast<int>(stones.size());
    sort(begin(stones), end(stones));
    int max_steps = max(stones[n - 1] - stones[1] - n + 2,
                        stones[n - 2] - stones[0] - n + 2);
    int min_steps = INT_MAX;
    int i = 0;
    for (int j = 0; j < n; ++j) {
      while (stones[j] - stones[i] >= n) ++i;
      if (j - i + 1 == n - 1 && stones[j] - stones[i] == n - 2)
        min_steps = min(min_steps, 2);
      else
        min_steps = min(min_steps, n - (j - i + 1));
    }
    return {min_steps, max_steps};
  }
};

The post 花花酱 LeetCode Weekly Contest 135 (1037, 1038, 1039, 1040) appeared first on Huahua's Tech Road.

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-135-1037-1038-1039-1040/feed/ 0 花花酱 LeetCode Weekly Contest 134 (1033,1034,1035,1036) https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-134/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-134/#respond Sun, 28 Apr 2019 05:42:58 +0000 https://zxi.mytechroad.com/blog/?p=5114 1033. Moving Stones Until Consecutive Solution: Math Time complexity: O(1)Space complexity: O(1) [crayon-6646c606ca295204655033/] 1034. Coloring A Border Solution: DFS Time complexity: O(mn)Space complexity: O(mn) [crayon-6646c606ca298987772227/]…

The post 花花酱 LeetCode Weekly Contest 134 (1033,1034,1035,1036) appeared first on Huahua's Tech Road.

]]> 1033. Moving Stones Until Consecutive

Solution: Math

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

C++

// Author: Huahua, running time: 4 ms / 8.3 MB
class Solution {
public:
  vector<int> numMovesStones(int a, int b, int c) {
    if (a > c) swap(a, c);
    if (a > b) swap(a, b);
    if (b > c) swap(b, c);
    int u = c - b - 1 + (b - a -1);
    int l = 0;
    if (a + 1 == b && b + 1 == c) l = 0;
    else if (a + 2 >= b || b + 2 >= c) l = 1;
    else l = 2;
    return {l, u};
  }
};

1034. Coloring A Border

Solution: DFS

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

C++

// Author: Huahua, 52 MB / 12.6 MB
class Solution {
public:
  vector<vector<int>> colorBorder(vector<vector<int>>& grid, int r0, int c0, int color) {
    vector<vector<int>> b(grid.size(), vector<int>(grid[0].size()));
    dfs(grid, r0, c0, grid[r0][c0], b);
    for (int i = 0; i < b.size(); ++i)
      for (int j = 0; j < b[0].size(); ++j)
        if (b[i][j] > 0) grid[i][j] = color;
    return grid;
  }
private:
  bool dfs(const vector<vector<int>>& grid, int r, int c, int color, vector<vector<int>>& b) {
    if (r < 0 || c < 0 || r >= grid.size() || c >= grid[0].size()) return true;
    if (grid[r][c] != color) return true;
    if (b[r][c]) return false;
    b[r][c] = -1;
    bool valid = dfs(grid, r + 1, c, color, b) |
                 dfs(grid, r - 1, c, color, b) | 
                 dfs(grid, r, c + 1, color, b) |
                 dfs(grid, r, c - 1, color, b);
    if (valid) b[r][c] = 1;
    return false;
  }
};

1035. Uncrossed Lines

Solution: LCS

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

C++

// Author: Huahua, 12 ms / 12.1 MB
class Solution {
public:
  int maxUncrossedLines(vector<int>& A, vector<int>& B) {
    const int m = A.size();
    const int n = B.size();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
    dp[0][0] = 0;
    for (int i = 1; i <= m; ++i)
      for (int j = 1; j <= n; ++j) {        
        if (A[i - 1] == B[j - 1]) 
          dp[i][j] = dp[i-1][j-1] + 1;
        else
          dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
      }
    return dp[m][n];
  }
};

1036. Escape a Large Maze

Solution: limited search

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

C++

// Author: Huahua, running time: 168 ms, 49.7 MB class Solution { public: bool isEscapePossible(vector>& blocked, vector& source, vector& target) { for (const auto& p : blocked) b.insert(static_cast(p[0]) << 32 | p[1]); seen = 0; t = target; bool first = dfs(source[0], source[1]); t = source; bool second = dfs(target[0], target[1]); return first && second; } private: const static int kMaxN = 1000000; const static int kMaxSeen = 20000; unordered_set b; vector t; int seen; int tx; int ty; bool dfs(int x, int y) { if (x < 0 || y < 0 || x >= kMaxN || y >= kMaxN) return false; if (x == t[0] && y == t[1]) return true; long key = static_cast(x) << 32 | y; if (b.find(key) != b.end()) return false; b.insert(key); if (++seen > kMaxSeen) return true; return dfs(x + 1, y) || dfs(x – 1, y) || dfs(x, y + 1) || dfs(x, y – 1); } };

The post 花花酱 LeetCode Weekly Contest 134 (1033,1034,1035,1036) appeared first on Huahua's Tech Road.

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-134/feed/ 0 花花酱 LeetCode Weekly Contest 132 (1025,1026,1027,1028) https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-132/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-132/#respond Sun, 14 Apr 2019 04:12:05 +0000 https://zxi.mytechroad.com/blog/?p=5064 1025. Divisor Game Solution: Recursion with Memoization Time complexity: O(n^2)Space complexity: O(n) [crayon-6646c606ca467032597861/] 1026. Maximum Difference Between Node and Ancestor Solution: Resolution, pass min /…

The post 花花酱 LeetCode Weekly Contest 132 (1025,1026,1027,1028) appeared first on Huahua's Tech Road.

]]>

1025. Divisor Game

Solution: Recursion with Memoization

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

C++

// Author: Huahua, running time: 12 ms
class Solution {
public:
  bool divisorGame(int N) {
    cache_ = vector<int>(N + 1, -1);
    return canWin(N);
  }
private:
  vector<int> cache_;
  bool canWin(int N) {
    if (N == 1) return false;
    if (cache_[N] != -1) return cache_[N];
    bool win = false;
    for (int i = 1; i < N; ++i)
      if (N % i == 0)
        win |= !canWin(N - i);
    return cache_[N] = win;
  }
};

1026. Maximum Difference Between Node and Ancestor

Solution: Resolution, pass min / max of ancestor nodes

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

C++

class Solution {
public:
  int maxAncestorDiff(TreeNode* root) {
    if (!root) return 0;
    return maxDiff(root, root-&gt;val, root-&gt;val);
  }
private:
  int maxDiff(TreeNode* root, int l, int r) {
    if (!root) return 0;
    int cur = max(abs(root-&gt;val - l), abs(root-&gt;val - r));
    l = min(l, root-&gt;val);
    r = max(r, root-&gt;val);
    return max(cur, max(maxDiff(root-&gt;left, l, r),
                        maxDiff(root-&gt;right, l, r)));
  }
};

1027. Longest Arithmetic Sequence

Solution 1: Brute Force + Pruning

Time complexity: O(n^3) ~ O(n^2) in practice
Space complexity: O(n)

C++

// Author: Huahua, running time: 352 ms
class Solution {
public:
  int longestArithSeqLength(vector<int>& A) {
    int n = A.size();
    unordered_set<int> h;
    int ans = 2;
    for (int a: A) h.insert(a);
    for (int i = 0; i < n - 1; ++i)
      for (int j = i + 1; j < n; ++j) {
        int d = (A[j] - A[i]);
        int t = A[j] + d;
        int l = 2;
        if (!h.count(t)) continue;
        int k = j + 1;
        for (int k = j + 1; k < n; ++k)
          if (A[k] == t) {
            t += d;
            ++l;
          }        
        ans = max(ans, l);
      }
    return ans;
  }
};

1028. Recover a Tree From Preorder Traversal

Solution: Recursion

Check the current depth and expected depth, if don’t match, return nullptr.

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

C++

// Author: Huahua, running time: 24 ms
class Solution {
public:
  TreeNode* recoverFromPreorder(string S) {
    int i = 0;
    return recover(S, i, 0);
  }
private:
  TreeNode* recover(const string& s, int& i, int depth) {    
    const int d = getD(s, i);
    if (d != depth) { i -= d; return nullptr; }    
    auto root = new TreeNode(getVal(s, i));
    root->left = recover(s, i, d + 1);    
    root->right = recover(s, i, d + 1);
    return root;
  }
  
  int getD(const string& s, int& i) {
    int d = 0;
    while (i < s.length() && s[i] == '-') {++d; ++i;}
    return d;
  }
  
  int getVal(const string& s, int& i) {
    int val = 0;
    while (i < s.length() && isdigit(s[i]))
      val = val * 10 + (s[i++] - '0');       
    return val;
  }
};

The post 花花酱 LeetCode Weekly Contest 132 (1025,1026,1027,1028) appeared first on Huahua's Tech Road.

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-132/feed/ 0 花花酱 LeetCode Weekly Contest 131 (1021, 1022, 1023, 1024) https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-131-1021-1022-1023-1024/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-131-1021-1022-1023-1024/#respond Sun, 07 Apr 2019 22:46:19 +0000 https://zxi.mytechroad.com/blog/?p=5015 LeetCode 1021. Remove Outermost Parentheses Solution: Track # of opened parentheses Let n denote the # of opened parentheses after current char, keep ‘(‘ if…

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

]]> 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 == '(' &amp;&amp; n++) ans += c;
      if (c == ')' &amp;&amp; --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<bool> camelMatch(vector<string>& queries, string p) {
    vector<bool> 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<vector<int>>& clips, int T) {
    constexpr int kInf = 101;
    // dp[i][j] := min clips to cover range [i, j]
    vector<vector<int>> dp(T + 1, vector<int>(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<vector<int>>& clips, int T) {
    constexpr int kInf = 101;
    // dp[i][j] := min clips to cover range [i, j]
    vector<vector<int>> dp(T + 1, vector<int>(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.

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-131-1021-1022-1023-1024/feed/ 0 花花酱 LeetCode Weekly 125 https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-125/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-125/#respond Sun, 24 Feb 2019 20:56:09 +0000 https://zxi.mytechroad.com/blog/?p=4903 Problems https://zxi.mytechroad.com/blog/graph/leetcode-997-find-the-town-judge/ https://zxi.mytechroad.com/blog/tree/leetcode-998-maximum-binary-tree-ii/ https://zxi.mytechroad.com/blog/simulation/leetcode-999-available-captures-for-rook/ https://zxi.mytechroad.com/blog/hashtable/leetcode-1001-grid-illumination/

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

]]>

Problems

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

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-125/feed/ 0 LeetCode Weekly Contest 124 https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-124/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-124/#respond Sun, 17 Feb 2019 19:43:57 +0000 https://zxi.mytechroad.com/blog/?p=4879 Solutions https://zxi.mytechroad.com/blog/tree/leetcode-993-cousins-in-binary-tree/ https://zxi.mytechroad.com/blog/searching/leetcode-994-rotting-oranges/ https://zxi.mytechroad.com/blog/greedy/leetcode-995-minimum-number-of-k-consecutive-bit-flips/ https://zxi.mytechroad.com/blog/searching/leetcode-996-number-of-squareful-arrays/

The post LeetCode Weekly Contest 124 appeared first on Huahua's Tech Road.

]]>

Solutions

The post LeetCode Weekly Contest 124 appeared first on Huahua's Tech Road.

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-124/feed/ 0 花花酱 LeetCode Weekly Contest 122 https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-122/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-122/#respond Sun, 03 Feb 2019 08:46:43 +0000 https://zxi.mytechroad.com/blog/?p=4784 https://zxi.mytechroad.com/blog/simulation/leetcode-985-sum-of-even-numbers-after-queries/ https://zxi.mytechroad.com/blog/geometry/leetcode-986-interval-list-intersections/ https://zxi.mytechroad.com/blog/tree/leetcode-987-vertical-order-traversal-of-a-binary-tree/ https://zxi.mytechroad.com/blog/tree/leetcode-988-smallest-string-starting-from-leaf/

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

]]>

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

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-122/feed/ 0 LeetCode Weekly Contest 113 https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-113/ https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-113/#respond Sun, 02 Dec 2018 03:47:20 +0000 https://zxi.mytechroad.com/blog/?p=4389 The post LeetCode Weekly Contest 113 appeared first on Huahua's Tech Road.

]]>

The post LeetCode Weekly Contest 113 appeared first on Huahua's Tech Road.

]]> https://zxi.mytechroad.com/blog/leetcode/leetcode-weekly-contest-113/feed/ 0