Add 1874~1897

Author: MaskRay

README.md

@@ -2,7 +2,7 @@
 
 [LeetCode solutions](http://maskray.me/blog/2014-06-29-leetcode-solutions) gives some thoughts on selected problems.
 
-Solved 482/559 problems.
+Solved 489/1771 problems.
 
 ## Database
 
@@ -12,6 +12,16 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|1897|[Maximize Palindrome Length From Subsequences](https://leetcode.com/problems/maximize-palindrome-length-from-subsequences)|[maximize-palindrome-length-from-subsequences.cc](maximize-palindrome-length-from-subsequences.cc)|
+|1896|[Maximum Score from Performing Multiplication Operations](https://leetcode.com/problems/maximum-score-from-performing-multiplication-operations)|[maximum-score-from-performing-multiplication-operations.cc](maximum-score-from-performing-multiplication-operations.cc)|
+|1895|[Minimum Number of Operations to Move All Balls to Each Box](https://leetcode.com/problems/minimum-number-of-operations-to-move-all-balls-to-each-box)|[minimum-number-of-operations-to-move-all-balls-to-each-box.cc](minimum-number-of-operations-to-move-all-balls-to-each-box.cc)|
+|1894|[Merge Strings Alternately](https://leetcode.com/problems/merge-strings-alternately)|[merge-strings-alternately.cc](merge-strings-alternately.cc)|
+|1876|[Map of Highest Peak](https://leetcode.com/problems/map-of-highest-peak)|[map-of-highest-peak.cc](map-of-highest-peak.cc)|
+|1875|[Tree of Coprimes](https://leetcode.com/problems/tree-of-coprimes)|[tree-of-coprimes.cc](tree-of-coprimes.cc)|
+|1874|[Form Array by Concatenating Subarrays of Another Array](https://leetcode.com/problems/form-array-by-concatenating-subarrays-of-another-array)|[form-array-by-concatenating-subarrays-of-another-array.cc](form-array-by-concatenating-subarrays-of-another-array.cc)|
+|916|[Decoded String at Index](https://leetcode.com/problems/decoded-string-at-index)|[decoded-string-at-index.cc](decoded-string-at-index.cc)|
+|830|[Largest Triangle Area](https://leetcode.com/problems/largest-triangle-area)|[largest-triangle-area.cc](largest-triangle-area.cc)|
+|673|[Number of Longest Increasing Subsequence](https://leetcode.com/problems/number-of-longest-increasing-subsequence)|[number-of-longest-increasing-subsequence.cc](number-of-longest-increasing-subsequence.cc)|
 |635|[Design Log Storage System](https://leetcode.com/problems/design-log-storage-system)|[design-log-storage-system.cc](design-log-storage-system.cc)|
 |634|[Find the Derangement of An Array](https://leetcode.com/problems/find-the-derangement-of-an-array)|[find-the-derangement-of-an-array.cc](find-the-derangement-of-an-array.cc)|
 |633|[Sum of Square Numbers](https://leetcode.com/problems/sum-of-square-numbers)|[sum-of-square-numbers.cc](sum-of-square-numbers.cc)|
@@ -149,7 +159,6 @@ See [database.md](database.md)
 |366|[Find Leaves of Binary Tree](https://leetcode.com/problems/find-leaves-of-binary-tree)|[find-leaves-of-binary-tree.cc](find-leaves-of-binary-tree.cc)|
 |365|[Water and Jug Problem](https://leetcode.com/problems/water-and-jug-problem)|[water-and-jug-problem.cc](water-and-jug-problem.cc)|
 |364|[Nested List Weight Sum II](https://leetcode.com/problems/nested-list-weight-sum-ii)|[nested-list-weight-sum-ii.cc](nested-list-weight-sum-ii.cc)|
-|363|[Max Sum of Rectangle No Larger Than K](https://leetcode.com/problems/max-sum-of-sub-matrix-no-larger-than-k)|[max-sum-of-sub-matrix-no-larger-than-k.cc](max-sum-of-sub-matrix-no-larger-than-k.cc)|
 |362|[Design Hit Counter](https://leetcode.com/problems/design-hit-counter)|[design-hit-counter.cc](design-hit-counter.cc)|
 |361|[Bomb Enemy](https://leetcode.com/problems/bomb-enemy)|[bomb-enemy.cc](bomb-enemy.cc)|
 |360|[Sort Transformed Array](https://leetcode.com/problems/sort-transformed-array)|[sort-transformed-array.cc](sort-transformed-array.cc)|
@@ -300,7 +309,6 @@ See [database.md](database.md)
 |214|[Shortest Palindrome](https://leetcode.com/problems/shortest-palindrome)|[shortest-palindrome.cc](shortest-palindrome.cc)|
 |213|[House Robber II](https://leetcode.com/problems/house-robber-ii)|[house-robber-ii.cc](house-robber-ii.cc)|
 |212|[Word Search II](https://leetcode.com/problems/word-search-ii)|[word-search-ii.cc](word-search-ii.cc)|
-|211|[Add and Search Word - Data structure design](https://leetcode.com/problems/add-and-search-word-data-structure-design)|[add-and-search-word-data-structure-design.cc](add-and-search-word-data-structure-design.cc)|
 |210|[Course Schedule II](https://leetcode.com/problems/course-schedule-ii)|[course-schedule-ii.cc](course-schedule-ii.cc)|
 |209|[Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum)|[minimum-size-subarray-sum.cc](minimum-size-subarray-sum.cc)|
 |208|[Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree)|[implement-trie-prefix-tree.cc](implement-trie-prefix-tree.cc)|
@@ -460,7 +468,6 @@ See [database.md](database.md)
 |37|[Sudoku Solver](https://leetcode.com/problems/sudoku-solver)|[sudoku-solver.cc](sudoku-solver.cc)|
 |36|[Valid Sudoku](https://leetcode.com/problems/valid-sudoku)|[valid-sudoku.cc](valid-sudoku.cc)|
 |35|[Search Insert Position](https://leetcode.com/problems/search-insert-position)|[search-insert-position.cc](search-insert-position.cc)|
-|34|[Search for a Range](https://leetcode.com/problems/search-for-a-range)|[search-for-a-range.cc](search-for-a-range.cc)|
 |33|[Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array)|[search-in-rotated-sorted-array.cc](search-in-rotated-sorted-array.cc)|
 |32|[Longest Valid Parentheses](https://leetcode.com/problems/longest-valid-parentheses)|[longest-valid-parentheses.cc](longest-valid-parentheses.cc)|
 |31|[Next Permutation](https://leetcode.com/problems/next-permutation)|[next-permutation.cc](next-permutation.cc)|

form-array-by-concatenating-subarrays-of-another-array.cc

@@ -0,0 +1,25 @@
+// Form Array by Concatenating Subarrays of Another Array
+class Solution {
+public:
+  bool canChoose(vector<vector<int>>& gs, vector<int>& a) {
+    int n = a.size(), f = 0;
+    vector<int> pi(n);
+    for (auto &g : gs) {
+      int m = g.size();
+      for (int j = 0, i = 1; i < m; i++) {
+        while (j && g[i] != g[j]) j = pi[j-1];
+        if (g[i] == g[j]) j++;
+        pi[i] = j;
+      }
+      int j = 0;
+      while (f < n) {
+        while (j && a[f] != g[j]) j = pi[j-1];
+        if (a[f++] == g[j] && ++j == m)
+          break;
+      }
+      if (j != m)
+        return false;
+    }
+    return true;
+  }
+};

fraction-addition-and-subtraction.cc

@@ -1,5 +1,11 @@
 // Fraction Addition and Subtraction
 class Solution {
+  int gcd(int a, int b) {
+    int t;
+    while (b)
+      t = a%b, a = b, b = t;
+    return a;
+  }
 public:
   string fractionAddition(string s) {
     int p = 0, q = 1, p1, q1, t;
@@ -10,9 +16,10 @@ class Solution {
       int x = stol(s.substr(i, k-i)), y = stol(s.substr(k+1, j));
       p1 = p*y+q*x;
       q1 = q*y;
-      t = __gcd(abs(p1), q1);
+      t = gcd(p1, q1);
       p = p1/t;
       q = q1/t;
+      if (q < 0) p *= -1, q *= -1;
     }
     return to_string(p)+"/"+to_string(q);
   }

map-of-highest-peak.cc

@@ -0,0 +1,23 @@
+// Map of Highest Peak
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  vector<vector<int>> highestPeak(vector<vector<int>>& a) {
+    int m = a.size(), n = a[0].size(), r, c;
+    vector<pair<int, int>> q;
+    REP(i, m) REP(j, n)
+      if (a[i][j]--)
+        q.emplace_back(i, j);
+    REP(i, q.size()) {
+      tie(r, c) = q[i];
+      int t = max(a[r][c]+1, 1);
+      if (r && a[r-1][c]<0) a[r-1][c]=t, q.emplace_back(r-1, c);
+      if (r+1 < m && a[r+1][c]<0) a[r+1][c]=t, q.emplace_back(r+1, c);
+      if (c && a[r][c-1]<0) a[r][c-1]=t, q.emplace_back(r, c-1);
+      if (c+1 < n && a[r][c+1]<0) a[r][c+1]=t, q.emplace_back(r, c+1);
+    }
+    return a;
+  }
+};

maximize-palindrome-length-from-subsequences.cc

@@ -0,0 +1,24 @@
+// Maximize Palindrome Length From Subsequences
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define ROF(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (b); --i >= (a); )
+
+class Solution {
+public:
+  int longestPalindrome(string a, string b) {
+    string c = a+b;
+    int n = c.size(), na = a.size(), ans = 0;
+    vector<vector<int>> s(n, vector<int>(n));
+    ROF(i, 0, n) {
+      s[i][i] = 1;
+      FOR(j, i+1, n) {
+        if (c[i] == c[j]) {
+          s[i][j] = s[i+1][j-1]+2;
+          if (i < na && na <= j)
+            ans = max(ans, s[i][j]);
+        } else
+          s[i][j] = max(s[i+1][j], s[i][j-1]);
+      }
+    }
+    return ans;
+  }
+};

maximum-score-from-performing-multiplication-operations.cc

@@ -0,0 +1,12 @@
+// Maximum Score from Performing Multiplication Operations
+class Solution {
+public:
+  int maximumScore(vector<int>& a, vector<int>& b) {
+    int n = a.size(), m = b.size();
+    vector<vector<int>> f(m+1, vector<int>(m+1));
+    for (int i = m; i--; )
+      for (int j = m-i; --j >= 0; )
+        f[i][j] = max(f[i+1][j]+a[i]*b[i+j], f[i][j+1]+a[n-1-j]*b[i+j]);
+    return f[0][0];
+  }
+};

merge-strings-alternately.cc

@@ -0,0 +1,11 @@
+// Merge Strings Alternately
+class Solution {
+public:
+  string mergeAlternately(string a, string b) {
+    string s;
+    int n = min(a.size(), b.size());
+    for (int i = 0; i < n; i++)
+      (s += a[i]) += b[i];
+    return s+a.substr(n)+b.substr(n);
+  }
+};

minimum-number-of-operations-to-move-all-balls-to-each-box.cc

@@ -0,0 +1,19 @@
+// Minimum Number of Operations to Move All Balls to Each Box
+class Solution {
+public:
+  vector<int> minOperations(string b) {
+    int n = b.size(), ff = 0, gg = 0;
+    vector<int> f(n+1), g(n+1);
+    for (int i = n; i--; ) {
+      f[i] = f[i+1]+i*(b[i]-'0');
+      g[i] = g[i+1]+(b[i]-'0');
+    }
+    for (int i = 0; i < n; i++) {
+      f[i] = f[i+1]-g[i+1]*i + gg*i-ff;
+      ff += i*(b[i]-'0');
+      gg += b[i]-'0';
+    }
+    f.pop_back();
+    return f;
+  }
+};

number-of-longest-increasing-subsequence.cc

@@ -0,0 +1,35 @@
+
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+    int cutOffTree(vector<vector<int>>& g) {
+      int m = g.size(), n = g[0].size(), r = 0, sx = 0, sy = 0, x, y;
+      int d[50][50];
+      pair<int, int> q[2500];
+      for(;;) {
+        int tx = -1, ty = -1;
+        REP(i, m) REP(j, n)
+          if (g[i][j] > 1 && (tx<0 || g[i][j] < g[tx][ty]))
+            tx = i, ty = j;
+        if (tx < 0) break;
+        REP(i, m)
+          fill_n(d[i], n, -1);
+        d[sx][sy] = 0;
+        q[0] = make_pair(sx, sy);
+        for (int l = 0, h = 1; l < h && d[tx][ty] < 0; l++) {
+          tie(x, y) = q[l];
+          if (x && g[x-1][y] && d[x-1][y] < 0) d[x-1][y] = d[x][y]+1, q[h++] = {x-1, y};
+          if (x+1 < m && g[x+1][y] && d[x+1][y] < 0) d[x+1][y] = d[x][y]+1, q[h++] = {x+1, y};
+          if (y && g[x][y-1] && d[x][y-1] < 0) d[x][y-1] = d[x][y]+1, q[h++] = {x, y-1};
+          if (y+1 < n && g[x][y+1] && d[x][y+1] < 0) d[x][y+1] = d[x][y]+1, q[h++] = {x, y+1};
+        }
+        if (d[tx][ty] < 0) return -1;
+        g[tx][ty] = 1;
+        r += d[tx][ty];
+        sx = tx, sy = ty;
+      }
+      return r;
+    }
+};

tree-of-coprimes.cc

@@ -0,0 +1,37 @@
+// Tree of Coprimes
+class Solution {
+  vector<int> co[51];
+  vector<pair<int, int>> st[51];
+  vector<int> nums, ans;
+  vector<vector<int>> e;
+  void dfs(int u, int dep, int p) {
+    int x = nums[u], maxd = -1;
+    for (int y : co[x]) {
+      auto &c = st[y];
+      if (c.size() && c.back().first > maxd)
+        tie(maxd, ans[u]) = c.back();
+    }
+    st[x].emplace_back(dep, u);
+    for (int v : e[u])
+      if (v != p)
+        dfs(v, dep+1, u);
+    st[x].pop_back();
+  }
+public:
+  vector<int> getCoprimes(vector<int>& nums, vector<vector<int>>& edges) {
+    this->nums = nums;
+    ans.assign(nums.size(), -1);
+    e.resize(nums.size());
+    set<int> n(nums.begin(), nums.end());
+    for (int a : n)
+      for (int b : n)
+        if (__gcd(a, b) == 1)
+          co[a].push_back(b);
+    for (auto &i : edges) {
+      e[i[0]].push_back(i[1]);
+      e[i[1]].push_back(i[0]);
+    }
+    dfs(0, 0, -1);
+    return ans;
+  }
+};