298/298

MaskRay · MaskRay · commit e19ad4138f94 · 2015-12-06T21:44:42.000+08:00
diff --git a/README.md b/README.md
@@ -2,7 +2,7 @@
 
 [LeetCode solutions](http://maskray.me/blog/2014-06-29-leetcode-solutions) gives some thoughts on selected problems.
 
-Solved 289/290 problems.
+Solved 298/298 problems.
 
 ## Database
 
@@ -12,7 +12,16 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/)|[count-of-smaller-numbers-after-self.cc](count-of-smaller-numbers-after-self.cc)|
+|314|[Binary Tree Vertical Order Traversal](https://leetcode.com/problems/binary-tree-vertical-order-traversal/)|[binary-tree-vertical-order-traversal.cc](binary-tree-vertical-order-traversal.cc)|
+|313|[Super Ugly Number](https://leetcode.com/problems/super-ugly-number/)|[super-ugly-number.cc](super-ugly-number.cc)|
+|312|[Burst Balloons](https://leetcode.com/problems/burst-balloons/)|[burst-balloons.cc](burst-balloons.cc)|
+|311|[Sparse Matrix Multiplication](https://leetcode.com/problems/sparse-matrix-multiplication/)|[sparse-matrix-multiplication.cc](sparse-matrix-multiplication.cc)|
+|310|[Minimum Height Trees](https://leetcode.com/problems/minimum-height-trees/)|[minimum-height-trees.cc](minimum-height-trees.cc)|
+|309|[Best Time to Buy and Sell Stock with Cooldown](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/)|[best-time-to-buy-and-sell-stock-with-cooldown.cc](best-time-to-buy-and-sell-stock-with-cooldown.cc)|
+|308|[Range Sum Query 2D - Mutable](https://leetcode.com/problems/range-sum-query-2d-mutable/)|[range-sum-query-2d-mutable.cc](range-sum-query-2d-mutable.cc)|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/)|[range-sum-query-mutable.cc](range-sum-query-mutable.cc)|
+|306|[Additive Number](https://leetcode.com/problems/additive-number/)|[additive-number.cc](additive-number.cc)|
 |305|[Number of Islands II](https://leetcode.com/problems/number-of-islands-ii/)|[number-of-islands-ii.cc](number-of-islands-ii.cc)|
 |304|[Range Sum Query 2D - Immutable](https://leetcode.com/problems/range-sum-query-2d-immutable/)|[range-sum-query-2d-immutable.cc](range-sum-query-2d-immutable.cc)|
 |303|[Range Sum Query - Immutable](https://leetcode.com/problems/range-sum-query-immutable/)|[range-sum-query-immutable.cc](range-sum-query-immutable.cc)|
diff --git a/additive-number.cc b/additive-number.cc
@@ -0,0 +1,45 @@
+// Additive Number
+#define FOR(i, a, b) for (int i = (a); i < (b); i++)
+#define ROF(i, a, b) for (int i = (b); --i >= (a); )
+
+class Solution {
+public:
+  bool isAdditiveNumber(string num) {
+    int n = num.size();
+    ROF(u, 1, n)
+      if (num[u] != '0' || u == n-1)
+        FOR(v, max(0, 2*u-n), u)
+          if (num[v] != '0' || v == u-1) {
+            for (int p = n, q = u, r = v; ; ) {
+              int i = p, j = q, k = r, zero = 0, b = 0;
+              for (; i > q; i--) {
+                int t = num[i-1] - (j > r ? num[--j] : '0') - b;
+                if (t < 0)
+                  t += 10, b = 1;
+                else
+                  b = 0;
+                if (! t)
+                  zero++;
+                else {
+                  for (; zero; zero--)
+                    if (! k || num[--k] != '0')
+                      goto out;
+                  if (! k || num[--k]-'0' != t)
+                    goto out;
+                }
+              }
+              if (k == r && (! k || num[--k] != '0'))
+                goto out;
+              if (! k) {
+                if (j == r) return true;
+                goto out;
+              }
+              p = q;
+              q = r;
+              r = k;
+            }
+out:;
+          }
+    return false;
+  }
+};
diff --git a/best-time-to-buy-and-sell-stock-with-cooldown.cc b/best-time-to-buy-and-sell-stock-with-cooldown.cc
@@ -0,0 +1,17 @@
+// Best Time to Buy and Sell Stock with Cooldown
+#define FOR(i, a, b) for (int i = (a); i < (b); i++)
+
+class Solution {
+public:
+  int maxProfit(vector<int>& prices) {
+    if (prices.empty()) return 0;
+    int f = - prices[0], g = 0, gg = 0;
+    FOR(i, 1, prices.size()) {
+      int t = gg;
+      gg = g;
+      g = max(g, f+prices[i]);
+      f = max(f, t-prices[i]);
+    }
+    return g;
+  }
+};
diff --git a/binary-tree-vertical-order-traversal.cc b/binary-tree-vertical-order-traversal.cc
@@ -0,0 +1,24 @@
+// Binary Tree Vertical Order Traversal
+class Solution {
+public:
+  vector<vector<int>> verticalOrder(TreeNode* root) {
+    vector<vector<int>> r;
+    if (root) {
+      queue<pair<TreeNode*, int>> q;
+      map<int, vector<int>> a;
+      q.emplace(root, 0);
+      while (! q.empty()) {
+        auto x = q.front();
+        q.pop();
+        a[x.second].push_back(x.first->val);
+        if (x.first->left)
+          q.emplace(x.first->left, x.second-1);
+        if (x.first->right)
+          q.emplace(x.first->right, x.second+1);
+      }
+      for (auto &i: a)
+        r.push_back(i.second);
+    }
+    return r;
+  }
+};
diff --git a/burst-balloons.cc b/burst-balloons.cc
@@ -0,0 +1,27 @@
+// Burst Balloons
+#define FOR(i, a, b) for (int i = (a); i < (b); i++)
+#define REP(i, n) for (int i = 0; i < (n); i++)
+#define ROF(i, a, b) for (int i = (b); --i >= (a); )
+
+class Solution {
+public:
+  int maxCoins(vector<int>& nums) {
+    int n = nums.size();
+    if (! n)
+      return 0;
+    vector<vector<int>> dp(n, vector<int>(n, 0));
+    REP(i, n)
+      dp[i][i] = (i ? nums[i-1] : 1) * nums[i] * (i+1 < n ? nums[i+1] : 1);
+    ROF(i, 0, n-1)
+      FOR(j, i+1, n) {
+        int opt = -1, optk;
+        FOR(k, i, j+1) {
+          int t = (k ? dp[i][k-1] : 0) + (k+1 < n ? dp[k+1][j] : 0) + (i ? nums[i-1] : 1) * nums[k] * (j+1 < n ? nums[j+1] : 1);
+          if (t > opt)
+            opt = t;
+        }
+        dp[i][j] = opt;
+      }
+    return dp[0][n-1];
+  }
+};
diff --git a/count-of-smaller-numbers-after-self.cc b/count-of-smaller-numbers-after-self.cc
@@ -0,0 +1,55 @@
+// Count of Smaller Numbers After Self
+// divide and conquer
+typedef pair<int, int> pii;
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+class Solution {
+  vector<pii> a, b;
+  vector<int> c;
+  void f(int l, int r) {
+    if (r-l <= 1)
+      return;
+    int m = l+(r-l)/2;
+    f(l, m);
+    f(m, r);
+    for (int i = l, j = m, k = l; i < m || j < r; )
+      if (j == r || i < m && a[i].first <= a[j].first) {
+        c[a[i].second] += j-m;
+        b[k++] = a[i++];
+      } else
+        b[k++] = a[j++];
+    copy(b.begin()+l, b.begin()+r, a.begin()+l);
+  }
+public:
+  vector<int> countSmaller(vector<int>& nums) {
+    int n = nums.size();
+    a.resize(n);
+    b.resize(n);
+    c.assign(n, 0);
+    REP(i, n)
+      a[i] = pii{nums[i], i};
+    f(0, n);
+    return c;
+  }
+};
+
+// order statistics tree
+
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+using namespace __gnu_pbds;
+
+typedef pair<int, int> pii;
+#define ROF(i, a, b) for (int i = (b); --i >= (a); )
+
+class Solution {
+public:
+  vector<int> countSmaller(vector<int>& nums) {
+    tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> tr;
+    ROF(i, 0, nums.size()) {
+      tr.insert(pii{nums[i], i});
+      nums[i] = tr.order_of_key(pii{nums[i], 0});
+    }
+    return nums;
+  }
+};
diff --git a/minimum-height-trees.cc b/minimum-height-trees.cc
@@ -0,0 +1,78 @@
+// Minimum Height Trees
+
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+class Solution {
+public:
+  vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
+    vector<vector<int>> es(n);
+    vector<int> d(n, 0);
+    vector<bool> removed(n, false);
+    for (auto &e: edges) {
+      es[e.first].push_back(e.second);
+      es[e.second].push_back(e.first);
+      d[e.first]++;
+      d[e.second]++;
+    }
+    vector<int> leaves;
+    REP(i, n)
+      if (d[i] <= 1)
+        leaves.push_back(i);
+    while (n > 2) {
+      vector<int> leaves2;
+      n -= leaves.size();
+      for (int u: leaves) {
+        int p = -1;
+        for (int v: es[u])
+          if (! removed[v])
+            p = v;
+        removed[u] = true;
+        if (--d[p] == 1)
+          leaves2.push_back(p);
+      }
+      leaves.swap(leaves2);
+    }
+    return leaves;
+  }
+};
+
+/// find a diameter
+
+class Solution {
+  vector<vector<int>> es;
+  vector<int> parent;
+  int bfs(int u) {
+    queue<int> q;
+    int last = u;
+    fill(parent.begin(), parent.end(), -1);
+    parent[u] = -2;
+    q.push(u);
+    while (! q.empty()) {
+      u = q.front();
+      q.pop();
+      last = u;
+      for (int v: es[u])
+        if (parent[v] == -1) {
+          parent[v] = u;
+          q.push(v);
+        }
+    }
+    return last;
+  }
+public:
+  vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
+    es.resize(n);
+    parent.resize(n);
+    for (auto &e: edges) {
+      es[e.first].push_back(e.second);
+      es[e.second].push_back(e.first);
+    }
+    vector<int> ancestors;
+    for (int v = bfs(bfs(0)); v != -2; v = parent[v])
+      ancestors.push_back(v);
+    vector<int> ret{ancestors[ancestors.size()/2]};
+    if (ancestors.size() % 2 == 0)
+      ret.push_back(ancestors[ancestors.size()/2-1]);
+    return ret;
+  }
+};
diff --git a/range-sum-query-2d-mutable.cc b/range-sum-query-2d-mutable.cc
@@ -0,0 +1,36 @@
+// Range Sum Query - Mutable
+// 2D Fenwick tree
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+class NumMatrix {
+  int m, n;
+  vector<vector<int>> a;
+  void add(int i, int j, int v) {
+    for (; i < m; i |= i+1)
+      for (int jj = j; jj < n; jj |= jj+1)
+        a[i][jj] += v;
+  }
+  int sum(int i, int j) {
+    int s = 0;
+    for (; i; i &= i-1)
+      for (int jj = j; jj; jj &= jj-1)
+        s += a[i-1][jj-1];
+    return s;
+  }
+public:
+  NumMatrix(vector<vector<int>> &matrix) {
+    m = matrix.size();
+    n = m ? matrix[0].size() : 0;
+    a.assign(m, vector<int>(n, 0));
+    REP(i, m)
+      REP(j, n)
+        add(i, j, matrix[i][j]);
+  }
+  void update(int row, int col, int val) {
+    add(row, col, val - sumRegion(row, col, row, col));
+  }
+  int sumRegion(int row1, int col1, int row2, int col2) {
+    return sum(row2+1, col2+1) - sum(row1, col2+1)
+      - sum(row2+1, col1) + sum(row1, col1);
+  }
+};
diff --git a/sparse-matrix-multiplication.cc b/sparse-matrix-multiplication.cc
@@ -0,0 +1,31 @@
+// Sparse Matrix Multiplication
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+class Solution {
+public:
+  vector<vector<int>> multiply(vector<vector<int>>& A, vector<vector<int>>& B) {
+    int m = A.size(), p = B.size(), n = B[0].size();
+    unordered_map<int, unordered_map<int, int>> a, b;
+    vector<vector<int>> C(m, vector<int>(n, 0));
+    REP(i, m)
+      REP(j, p)
+        if (A[i][j])
+          a[i][j] = A[i][j];
+    REP(i, p)
+      REP(j, n)
+        if (B[i][j])
+          b[j][i] = B[i][j];
+    for (auto &iA: a) {
+      int i = iA.first;
+      auto &rowA = iA.second;
+      for (auto &iB: b) {
+        int j = iB.first;
+        auto &colB = iB.second;
+        for (auto x: rowA)
+          if (colB.count(x.first))
+            C[i][j] += x.second * colB[x.first];
+      }
+    }
+    return C;
+  }
+};
diff --git a/super-ugly-number.cc b/super-ugly-number.cc
@@ -0,0 +1,22 @@
+// Super Ugly Number
+typedef pair<int, int> pii;
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+class Solution {
+public:
+  int nthSuperUglyNumber(int n, vector<int>& primes) {
+    int m = primes.size();
+    vector<int> ugly(n, 1), idx(m, 0);
+    priority_queue<pii, vector<pii>, greater<pii>> pq;
+    REP(i, m)
+      pq.emplace(primes[i], i);
+    for (int i = 1; i < n; ) {
+      pii x = pq.top();
+      pq.pop();
+      if (x.first != ugly[i-1])
+        ugly[i++] = x.first;
+      pq.emplace(ugly[++idx[x.second]] * primes[x.second], x.second);
+    }
+    return ugly[n-1];
+  }
+};
