// 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();
  }
};

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)};
  }
};

// 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;
  }
};

// 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;
  }
};

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;
  }
};

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;
  }
};

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];
  }
};

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);
  }
};

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

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};
  }
};

// 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};
  }
};

// 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;
  }
};

// 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];
  }
};

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

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int twoCitySchedCost(vector<vector<int>>& costs) {
    int n = costs.size();
    vector<vector<int>> dp(n + 1, vector<int>(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];
  }
};

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int twoCitySchedCost(vector<vector<int>>& 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;
  }
};

// Author: Huahua
class Solution {
public:
  vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {
    vector<vector<int>> 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<int>& a, const vector<int>& b){
      return (abs(a[0] - r0) + abs(a[1] - c0)) < (abs(b[0] - r0) + abs(b[1] - c0));
    });
    return ans;
  }
};

// Author: Huahua
class Solution {
public:
  int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
    const int n = A.size();
    vector<int> 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<int>& 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;
  }
};

// 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<string>& words) {
    root_ = std::make_unique<TrieNode>();
    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<TrieNode> root_;
};

// 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;
  }  
}

// 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;
  }
};

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

// 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;
  }
};

// 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;
  }
};

// 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;
  }
};

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);
    }
};

// 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;
  }
};

// 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];
  }
};

// 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];
  }
};

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

// 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<char> 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)};
  }
};

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

// Author: Huahua
class Solution {
public:
  vector<int> nextLargerNodes(ListNode* head) {    
    vector<int> nums;
    while (head) {
      nums.push_back(head->val);
      head = head->next;      
    }
    stack<int> s;
    vector<int> 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;
  }
};

// Author: Huahua
class Solution {
public:
  int numEnclaves(vector<vector<int>>& 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<vector<int>>& 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;
  }
};

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

class Solution {
public:
  int maxScoreSightseeingPair(vector<int>& 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;
  }
};

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;
  }
};

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