319/319 notably, reconstruct-itinerary: Hierholzer's algorithm; palindrome-pairs: manacher

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 314/314 problems.
+Solved 319/319 problems.
 
 ## Database
 
@@ -12,6 +12,11 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|336|[Palindrome Pairs](https://leetcode.com/problems/palindrome-pairs/)|[palindrome-pairs.cc](palindrome-pairs.cc)|
+|335|[Self Crossing](https://leetcode.com/problems/self-crossing/)|[self-crossing.cc](self-crossing.cc)|
+|334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/)|[increasing-triplet-subsequence.cc](increasing-triplet-subsequence.cc)|
+|333|[Largest BST Subtree](https://leetcode.com/problems/largest-bst-subtree/)|[largest-bst-subtree.cc](largest-bst-subtree.cc)|
+|332|[Reconstruct Itinerary](https://leetcode.com/problems/reconstruct-itinerary/)|[reconstruct-itinerary.cc](reconstruct-itinerary.cc)|
 |331|[Verify Preorder Serialization of a Binary Tree](https://leetcode.com/problems/verify-preorder-serialization-of-a-binary-tree/)|[verify-preorder-serialization-of-a-binary-tree.cc](verify-preorder-serialization-of-a-binary-tree.cc)|
 |330|[Patching Array](https://leetcode.com/problems/patching-array/)|[patching-array.cc](patching-array.cc)|
 |329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)|[longest-increasing-path-in-a-matrix.cc](longest-increasing-path-in-a-matrix.cc)|

increasing-triplet-subsequence.cc

@@ -0,0 +1,16 @@
+// Increasing Triplet Subsequence
+class Solution {
+public:
+  bool increasingTriplet(vector<int>& nums) {
+    int a = INT_MAX, b = INT_MAX;
+    for (int x: nums) {
+      if (x <= a)
+        a = x;
+      else if (x <= b)
+        b = x;
+      else
+        return true;
+    }
+    return false;
+  }
+};

largest-bst-subtree.cc

@@ -0,0 +1,28 @@
+// Largest BST Subtree
+class Solution {
+  bool postorder(TreeNode *x, long &mn, long &mx, long &size) {
+    if (! x) {
+      mn = LONG_MAX;
+      mx = LONG_MIN;
+      size = 0;
+      return true;
+    }
+    long lmn, lmx, ls, rmn, rmx, rs;
+    bool lvalid = postorder(x->left, lmn, lmx, ls),
+         rvalid = postorder(x->right, rmn, rmx, rs);
+    if (lvalid && rvalid && lmx < x->val && x->val < rmn) {
+      mn = ls ? lmn : x->val;
+      mx = rs ? rmx : x->val;
+      size = ls+1+rs;
+      return true;
+    }
+    size = max(ls, rs);
+    return false;
+  }
+public:
+  int largestBSTSubtree(TreeNode* root) {
+    long mn, mx, size;
+    postorder(root, mn, mx, size);
+    return size;
+  }
+};

palindrome-pairs.cc

@@ -0,0 +1,51 @@
+// Palindrome Pairs
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+class Solution {
+  string a;
+  vector<int> z;
+  void manacher(int n) {
+    z.resize(n);
+    z[0] = 1;
+    for (int f, g = 1, i = 1; i < n; i++)
+      if (i < g && z[2*f-i] != g-i)
+        z[i] = min(z[2*f-i], g-i);
+      else {
+        g = max(g, f = i);
+        for (; g < n && 2*f-g >= 0 && a[2*f-g] == a[g]; g++);
+        z[f] = g-f;
+      }
+  }
+public:
+  vector<vector<int>> palindromePairs(vector<string>& words) {
+    unordered_multimap<string, int> ls, rs;
+    REP(i, words.size()) {
+      string &w = words[i];
+      int n = w.size(), nn = 2*n+1;
+      a = string(nn, '.');
+      REP(j, n)
+        a[2*j+1] = w[j];
+      manacher(nn);
+      REP(j, nn) {
+        if (z[j] == j+1)
+          ls.emplace(w.substr((j+z[j])/2), i);
+        if (j+z[j] == nn)
+          rs.emplace(w.substr(0, (j-z[j]+1)/2), i);
+      }
+    }
+    vector<vector<int>> ret;
+    REP(i, words.size()) {
+      string w = words[i], ww = w;
+      reverse(ww.begin(), ww.end());
+      auto its = ls.equal_range(ww);
+      for (auto it = its.first; it != its.second; ++it)
+        if (it->second != i)
+          ret.push_back(vector<int>{i, it->second});
+      its = rs.equal_range(ww);
+      for (auto it = its.first; it != its.second; ++it)
+        if (w.size() < words[it->second].size())
+          ret.push_back(vector<int>{it->second, i});
+    }
+    return ret;
+  }
+};

reconstruct-itinerary.cc

@@ -0,0 +1,50 @@
+// Reconstruct Itinerary
+/// Hierholzer's algorithm
+
+class Solution {
+  unordered_map<string, multiset<string>> m;
+  vector<string> ret;
+  void hierholzer(string x) {
+    while (! m[x].empty()) {
+      string y = *m[x].begin();
+      m[x].erase(m[x].begin());
+      hierholzer(y);
+    }
+    ret.push_back(x);
+  }
+public:
+  vector<string> findItinerary(vector<pair<string, string>> tickets) {
+    for (auto &x: tickets)
+      m[x.first].insert(x.second);
+    hierholzer("JFK");
+    reverse(ret.begin(), ret.end());
+    return ret;
+  }
+};
+
+/// non-recursive Hierholzer's algorithm
+
+class Solution {
+public:
+  vector<string> findItinerary(vector<pair<string, string>> tickets) {
+    unordered_map<string, multiset<string>> m;
+    for (auto &x: tickets)
+      m[x.first].insert(x.second);
+    stack<string> st;
+    vector<string> ret;
+    st.push("JFK");
+    while (! st.empty()) {
+      auto &x = st.top();
+      if (m[x].empty()) {
+        ret.push_back(x);
+        st.pop();
+      } else {
+        auto it = m[x].begin();
+        st.push(*it);
+        m[x].erase(it);
+      }
+    }
+    reverse(ret.begin(), ret.end());
+    return ret;
+  }
+};

self-crossing.cc

@@ -0,0 +1,26 @@
+// Self Crossing
+/* https://leetcode.com/discuss/88153/another-python
+            b                              b
+   +----------------+             +----------------+
+   |                |             |                |
+   |                |             |                | a
+ c |                |           c |                |
+   |                | a           |                |    f
+   +----------->    |             |                | <----+
+            d       |             |                |      | e
+                    |             |                       |
+                                  +-----------------------+
+                                               d
+ */
+class Solution {
+public:
+  bool isSelfCrossing(vector<int>& x) {
+    int a = 0, b = 0, c = 0, d = 0, e = 0;
+    for (int f: x) {
+      if (c && d <= f && e <= c || b && b <= d && d <= b+f && e <= c && c <= a+e)
+        return true;
+      a = b, b = c, c = d, d = e, e = f;
+    }
+    return false;
+  }
+};