194/203

Author: MaskRay

Diff for: README.md

@@ -2,7 +2,7 @@
 
 [LeetCode solutions](http://maskray.me/blog/2014-06-29-leetcode-solutions) gives some thoughts on selected problems.
 
-Solved 191/207 problems.
+Solved 194/203 problems.
 
 ## Database
 
@@ -12,6 +12,18 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|219|[Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/)|[contains-duplicate-ii.cc](contains-duplicate-ii.cc)|
+|218|[The Skyline Problem](https://leetcode.com/problems/the-skyline-problem/)|[the-skyline-problem.cc](the-skyline-problem.cc)|
+|217|[Contains Duplicate](https://leetcode.com/problems/contains-duplicate/)|[contains-duplicate.cc](contains-duplicate.cc)|
+|216|[Combination Sum III](https://leetcode.com/problems/combination-sum-iii/)|[combination-sum-iii.cc](combination-sum-iii.cc)|
+|215|[Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/)|[kth-largest-element-in-an-array.cc](kth-largest-element-in-an-array.cc)|
+|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)|
 |207|[Course Schedule](https://leetcode.com/problems/course-schedule/)|[course-schedule.cc](course-schedule.cc)|
 |206|[Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/)|[reverse-linked-list.cc](reverse-linked-list.cc)|
 |205|[Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/)|[isomorphic-strings.cc](isomorphic-strings.cc)|

Diff for: add-and-search-word-data-structure-design.cc

@@ -0,0 +1,52 @@
+// Add and Search Word - Data structure design
+class WordDictionary {
+public:
+  class TrieNode {
+  public:
+    // Initialize your data structure here.
+    bool has;
+    TrieNode *c[26];
+    TrieNode() : has(false) {
+      fill_n(c, 26, nullptr);
+    }
+  } *root;
+
+  WordDictionary() : root(new TrieNode) {}
+
+  // Adds a word into the data structure.
+  void addWord(string word) {
+    auto x = root;
+    for (auto c: word) {
+      if (! x->c[c-'a'])
+        x->c[c-'a'] = new TrieNode;
+      x = x->c[c-'a'];
+    }
+    x->has = true;
+  }
+
+  // Returns if the word is in the data structure. A word could
+  // contain the dot character '.' to represent any one letter.
+  bool search(string word) {
+    return search(word, 0, root);
+  }
+
+  bool search(const string &word, string::size_type i, TrieNode *x) {
+    for (; i < word.size(); i++) {
+      if (word[i] == '.') {
+        for (int j = 0; j < 26; j++)
+          if (x->c[j] && search(word, i+1, x->c[j]))
+            return true;
+        return false;
+      }
+      if (! x->c[word[i]-'a'])
+        return false;
+      x = x->c[word[i]-'a'];
+    }
+    return x->has;
+  }
+};
+
+// Your WordDictionary object will be instantiated and called as such:
+// WordDictionary wordDictionary;
+// wordDictionary.addWord("word");
+// wordDictionary.search("pattern");

Diff for: binary-tree-right-side-view.cc

@@ -1,3 +1,4 @@
+// Binary Tree Right Side View
 // pre-order
 
 class Solution {

Diff for: bitwise-and-of-numbers-range.cc

@@ -1,3 +1,4 @@
+// Bitwise AND of Numbers Range
 // __builtin_clz
 
 class Solution {

Diff for: combination-sum-iii.cc

@@ -0,0 +1,21 @@
+// Combination Sum III
+class Solution {
+public:
+  vector<vector<int>> combinationSum3(int k, int n) {
+    vector<int> a;
+    vector<vector<int>> r;
+    f(k, n, a, r);
+    return r;
+  }
+  void f(int k, int n, vector<int> &a, vector<vector<int>> &r) {
+    if (n < 0) return;
+    if (! k)
+      n || (r.push_back(a), 0);
+    else
+      for (int i = a.empty() ? 1 : a.back()+1; i <= 9; i++) {
+        a.push_back(i);
+        f(k-1, n-i, a, r);
+        a.pop_back();
+      }
+  }
+};

Diff for: contains-duplicate-ii.cc

@@ -0,0 +1,13 @@
+// Contains Duplicate II
+class Solution {
+public:
+  bool containsNearbyDuplicate(vector<int>& a, int k) {
+    map<int, int> m;
+    for (size_t i = 0; i < a.size(); i++) {
+      if (m.count(a[i]) && i-m[a[i]] <= k)
+        return true;
+      m[a[i]] = i;
+    }
+    return false;
+  }
+};

Diff for: contains-duplicate.cc

@@ -0,0 +1,9 @@
+// Contains Duplicate
+class Solution {
+public:
+  bool containsDuplicate(vector<int>& a) {
+    auto i = a.end();
+    sort(a.begin(), a.end());
+    return unique(a.begin(), a.end()) != i;
+  }
+};

Diff for: count-primes.cc

@@ -1,3 +1,4 @@
+// Count Primes
 // c(n,m) = c(n,m-1) - (c(n/m,m-1)-cnt(m-1))
 // cnt(m) = c(m, sqrt(m))
 

Diff for: course-schedule-ii.cc

@@ -0,0 +1,29 @@
+// Course Schedule II
+class Solution {
+public:
+  vector<int> findOrder(int n, vector<pair<int, int>>& a) {
+    vector<int> d(n, 0), ret;
+    for (auto &x: a) {
+      swap(x.first, x.second);
+      d[x.second]++;
+    }
+    sort(a.begin(), a.end());
+    int top = -1;
+    for (int i = 0; i < n; i++)
+      if (! d[i])
+        d[i] = top, top = i;
+    while (top != -1) {
+      int x = top;
+      top = d[x];
+      ret.push_back(x);
+      auto i = lower_bound(a.begin(), a.end(), make_pair(x, 0)),
+           ii = lower_bound(a.begin(), a.end(), make_pair(x, n));
+      for (; i != ii; ++i)
+        if (! --d[i->second])
+          d[i->second] = top, top = i->second;
+    }
+    if (ret.size() < n)
+      ret.clear();
+    return ret;
+  }
+};

Diff for: course-schedule.cc

@@ -1,3 +1,4 @@
+// Course Schedule
 #define FOR(i, a, b) for (decltype(b) i = (a); i < (b); i++)
 #define REP(i, n) FOR(i, 0, n)
 

Diff for: happy-number.cc

@@ -1,3 +1,4 @@
+// Happy Number
 class Solution {
 public:
   bool isHappy(int n) {

Diff for: house-robber-ii.cc

@@ -0,0 +1,15 @@
+// House Robber II
+class Solution {
+public:
+  int rob(vector<int>& a) {
+    int n = (int)a.size(), t, x = 0, y = 0;
+    if (n == 1) return a[0];
+    for (int i = 0; i < n-1; i++)
+      t = x, x = max(x, y+a[i]), y = t;
+    int r = x;
+    x = y = 0;
+    for (int i = 1; i < n; i++)
+      t = x, x = max(x, y+a[i]), y = t;
+    return max(r, x);
+  }
+};

Diff for: house-robber.cc

@@ -1,3 +1,4 @@
+// House Robber
 class Solution {
 public:
   int rob(vector<int> &a) {

Diff for: implement-trie-prefix-tree.cc

@@ -0,0 +1,59 @@
+// Implement Trie (Prefix Tree)
+class TrieNode {
+public:
+  // Initialize your data structure here.
+  bool has;
+  TrieNode *c[26];
+  TrieNode() : has(false) {
+    fill_n(c, 26, nullptr);
+  }
+};
+
+class Trie {
+public:
+  Trie() {
+    root = new TrieNode();
+  }
+
+  // Inserts a word into the trie.
+  void insert(string s) {
+    auto x = root;
+    for (auto c: s) {
+      if (! x->c[c-'a'])
+        x->c[c-'a'] = new TrieNode;
+      x = x->c[c-'a'];
+    }
+    x->has = true;
+  }
+
+  // Returns if the word is in the trie.
+  bool search(string key) {
+    auto x = root;
+    for (auto c: key) {
+      if (! x->c[c-'a'])
+        return false;
+      x = x->c[c-'a'];
+    }
+    return x->has;
+  }
+
+  // Returns if there is any word in the trie
+  // that starts with the given prefix.
+  bool startsWith(string prefix) {
+    auto x = root;
+    for (auto c: prefix) {
+      if (! x->c[c-'a'])
+        return false;
+      x = x->c[c-'a'];
+    }
+    return true;
+  }
+
+private:
+  TrieNode* root;
+};
+
+// Your Trie object will be instantiated and called as such:
+// Trie trie;
+// trie.insert("somestring");
+// trie.search("key");

Diff for: isomorphic-strings.cc

@@ -1,3 +1,4 @@
+// Isomorphic Strings
 class Solution {
 public:
   bool isIsomorphic(string s, string t) {

Diff for: kth-largest-element-in-an-array.cc

@@ -0,0 +1,8 @@
+// Kth Largest Element in an Array
+class Solution {
+public:
+  int findKthLargest(vector<int>& a, int k) {
+    nth_element(a.begin(), a.end()-k, a.end());
+    return *(a.end()-k);
+  }
+};

Diff for: minimum-size-subarray-sum.cc

@@ -0,0 +1,15 @@
+// Minimum Size Subarray Sum
+class Solution {
+public:
+  int minSubArrayLen(int s, vector<int>& a) {
+    int n = (int)a.size(), c = n+1;
+    for (int i = 0, j = 0; i < n; i++) {
+      for (; j < n && s > 0; j++)
+        s -= a[j];
+      if (s > 0) break;
+      c = min(c, j-i);
+      s += a[i];
+    }
+    return c > n ? 0 : c;
+  }
+};

Diff for: number-of-islands.cc

@@ -1,3 +1,4 @@
+// Number of Islands
 #define FOR(i, a, b) for (decltype(b) i = (a); i < (b); i++)
 #define REP(i, n) FOR(i, 0, n)
 

Diff for: remove-linked-list-elements.cc

@@ -1,3 +1,4 @@
+// Remove Linked List Elements
 class Solution {
 public:
   ListNode* removeElements(ListNode* x, int val) {

Diff for: reverse-linked-list.cc

@@ -1,3 +1,4 @@
+// Reverse Linked List
 class Solution {
 public:
   ListNode* reverseList(ListNode* x) {

Diff for: shortest-palindrome.cc

@@ -0,0 +1,23 @@
+// Shortest Palindrome
+class Solution {
+public:
+  string shortestPalindrome(string s) {
+    int n = s.size();
+    vector<int> border(n, 0);
+    int j = 0;
+    for (int i = 1; i < n; i++) {
+      while (j >= 0 && s[i] != s[j])
+        j = j ? border[j-1] : -1;
+      border[i] = ++j;
+    }
+    j = 0;
+    for (int i = 0; i < n; i++) {
+      while (j >= 0 && s[n-1-i] != s[j])
+        j = j ? border[j-1] : -1;
+      j++;
+    }
+    string ss = s.substr(j, n-j);
+    reverse(ss.begin(), ss.end());
+    return ss+s;
+  }
+};

Diff for: the-skyline-problem.cc

@@ -0,0 +1,61 @@
+// The Skyline Problem
+class Solution {
+public:
+  vector<pair<int, int>> getSkyline(vector<vector<int>>& a) {
+    int n = a.size(), xx = -1, x, yy = 0, y = 0;
+    priority_queue<pair<int, int>> pq; // order by first, second is insignificant
+    vector<pair<int, int>> r;
+    for (int i = 0; i < n || pq.size(); ) {
+      if (pq.empty() || i < n && a[i][0] < pq.top().second) {
+        x = a[i][0];
+        pq.emplace(a[i][2], a[i][1]);
+        i++;
+      } else {
+        x = pq.top().second;
+        while (pq.size() && pq.top().second <= x)
+          pq.pop();
+      }
+      if (x != xx && y != yy) {
+        r.emplace_back(xx, y);
+        yy = y;
+      }
+      xx = x;
+      y = pq.empty() ? 0 : pq.top().first;
+    }
+    if (y != yy)
+      r.emplace_back(xx, y);
+    return r;
+  }
+};
+
+///
+
+class Solution {
+public:
+  vector<pair<int, int>> getSkyline(vector<vector<int>>& a) {
+    vector<pair<int, int>> ev;
+    for (auto &e: a) {
+      ev.emplace_back(e[0], e[2]);
+      ev.emplace_back(e[1], - e[2]);
+    }
+    sort(ev.begin(), ev.end());
+    int x = -1, y = 0, yy = 0;
+    multiset<int> h;
+    vector<pair<int, int>> r;
+    for (auto e: ev) {
+      if (e.second > 0)
+        h.insert(e.second);
+      else
+        h.erase(h.find(- e.second));
+      if (e.first != x && yy != y) {
+        r.emplace_back(x, y);
+        yy = y;
+      }
+      x = e.first;
+      y = h.empty() ? 0 : *h.rbegin();
+    }
+    if (yy != y)
+      r.emplace_back(x, y);
+    return r;
+  }
+};