368/368 喵呜呜呜呜，求NYC住处。何年是归日，雨泪下孤舟。

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 357/357 problems.
+Solved 368/368 problems.
 
 ## Database
 
@@ -12,6 +12,17 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|385|[Mini Parser](https://leetcode.com/problems/mini-parser/)|[mini-parser.cc](mini-parser.cc)|
+|384|[Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/)|[shuffle-an-array.cc](shuffle-an-array.cc)|
+|383|[Ransom Note](https://leetcode.com/problems/ransom-note/)|[ransom-note.cc](ransom-note.cc)|
+|382|[Linked List Random Node](https://leetcode.com/problems/linked-list-random-node/)|[linked-list-random-node.cc](linked-list-random-node.cc)|
+|381|[Insert Delete GetRandom O(1) - Duplicates allowed](https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/)|[insert-delete-getrandom-o1-duplicates-allowed.cc](insert-delete-getrandom-o1-duplicates-allowed.cc)|
+|380|[Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/)|[insert-delete-getrandom-o1.cc](insert-delete-getrandom-o1.cc)|
+|379|[Design Phone Directory](https://leetcode.com/problems/design-phone-directory/)|[design-phone-directory.cc](design-phone-directory.cc)|
+|378|[Kth Smallest Element in a Sorted Matrix](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/)|[kth-smallest-element-in-a-sorted-matrix.cc](kth-smallest-element-in-a-sorted-matrix.cc)|
+|377|[Combination Sum IV](https://leetcode.com/problems/combination-sum-iv/)|[combination-sum-iv.cc](combination-sum-iv.cc)|
+|376|[Wiggle Subsequence](https://leetcode.com/problems/wiggle-subsequence/)|[wiggle-subsequence.cc](wiggle-subsequence.cc)|
+|375|[Guess Number Higher or Lower II](https://leetcode.com/problems/guess-number-higher-or-lower-ii/)|[guess-number-higher-or-lower-ii.cc](guess-number-higher-or-lower-ii.cc)|
 |374|[Guess Number Higher or Lower](https://leetcode.com/problems/guess-number-higher-or-lower/)|[guess-number-higher-or-lower.cc](guess-number-higher-or-lower.cc)|
 |373|[Find K Pairs with Smallest Sums](https://leetcode.com/problems/find-k-pairs-with-smallest-sums/)|[find-k-pairs-with-smallest-sums.cc](find-k-pairs-with-smallest-sums.cc)|
 |372|[Super Pow](https://leetcode.com/problems/super-pow/)|[super-pow.cc](super-pow.cc)|

combination-sum-iv.cc

@@ -0,0 +1,13 @@
+// Combination Sum IV
+class Solution {
+public:
+  int combinationSum4(vector<int>& nums, int target) {
+    vector<int> a(target+1, 0);
+    a[0] = 1;
+    for (int i = 0; i < target; i++)
+      for (int x: nums)
+        if (i+x <= target)
+          a[i+x] += a[i];
+    return a[target];
+  }
+};

design-phone-directory.cc

@@ -0,0 +1,42 @@
+// Design Phone Directory
+class PhoneDirectory {
+  vector<bool> used;
+  vector<int> a;
+  int top = 0;
+public:
+  /** Initialize your data structure here
+    @param maxNumbers - The maximum numbers that can be stored in the phone directory. */
+  PhoneDirectory(int maxNumbers) : a(maxNumbers), used(maxNumbers, false) {
+    iota(a.begin(), a.end(), 0);
+  }
+
+  /** Provide a number which is not assigned to anyone.
+    @return - Return an available number. Return -1 if none is available. */
+  int get() {
+    if (top < a.size()) {
+      used[a[top]] = true;
+      return a[top++];
+    }
+    return -1;
+  }
+
+  /** Check if a number is available or not. */
+  bool check(int number) {
+    return 0 <= number && number < a.size() && ! used[number];
+  }
+
+  /** Recycle or release a number. */
+  void release(int number) {
+    if (0 <= number && number < a.size() && used[number]) {
+      used[a[--top] = number] = false;
+    }
+  }
+};
+
+/**
+ * Your PhoneDirectory object will be instantiated and called as such:
+ * PhoneDirectory obj = new PhoneDirectory(maxNumbers);
+ * int param_1 = obj.get();
+ * bool param_2 = obj.check(number);
+ * obj.release(number);
+ */

guess-number-higher-or-lower-ii.cc

@@ -0,0 +1,20 @@
+// Guess Number Higher or Lower II
+// optimization of 2D dynamic programming: http://artofproblemsolving.com/community/c296841h1273742
+class Solution {
+public:
+  int getMoneyAmount(int n) {
+    vector<vector<int>> a(n+1, vector<int>(n+1, 0));
+    for (int j = 2; j <= n; j++) {
+      deque<pair<int, int>> q;
+      for (int k = j-1, i = j; --i; ) {
+        while (a[i][k-1] > a[k+1][j]) k--;
+        while (q.size() && k < q.front().second) q.pop_front();
+        long t = a[i+1][j]+i;
+        while (q.size() && q.back().first >= t) q.pop_back();
+        q.emplace_back(t, i);
+        a[i][j] = min(q.front().first, a[i][k]+k+1);
+      }
+    }
+    return a[1][n];
+  }
+};

insert-delete-getrandom-o1-duplicates-allowed.cc

@@ -0,0 +1,41 @@
+// Insert Delete GetRandom O(1) - Duplicates allowed
+class RandomizedCollection {
+public:
+  unordered_multimap<int, int> m;
+  vector<pair<int, decltype(m.begin())>> a;
+public:
+  /** Initialize your data structure here. */
+  RandomizedCollection() {
+
+  }
+
+  /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
+  bool insert(int val) {
+    bool r = ! m.count(val);
+    a.emplace_back(val, m.emplace(val, a.size()));
+    return r;
+  }
+
+  /** Removes a value from the collection. Returns true if the collection contained the specified element. */
+  bool remove(int val) {
+    auto it = m.find(val);
+    if (it == m.end()) return false;
+    (a[it->second] = a.back()).second->second = it->second;
+    m.erase(it);
+    a.pop_back();
+    return true;
+  }
+
+  /** Get a random element from the collection. */
+  int getRandom() {
+    return a[rand()%a.size()].first;
+  }
+};
+
+/**
+ * Your RandomizedCollection object will be instantiated and called as such:
+ * RandomizedCollection obj = new RandomizedCollection();
+ * bool param_1 = obj.insert(val);
+ * bool param_2 = obj.remove(val);
+ * int param_3 = obj.getRandom();
+ */

insert-delete-getrandom-o1.cc

@@ -0,0 +1,39 @@
+// Insert Delete GetRandom O(1)
+class RandomizedSet {
+  unordered_map<int, int> m;
+  vector<int> a;
+public:
+  /** Initialize your data structure here. */
+  RandomizedSet() {
+  }
+
+  /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+  bool insert(int val) {
+    if (! m.emplace(val, a.size()).second) return false;
+    a.push_back(val);
+    return true;
+  }
+
+  /** Removes a value from the set. Returns true if the set contained the specified element. */
+  bool remove(int val) {
+    auto it = m.find(val);
+    if (it == m.end()) return false;
+    m[a[it->second] = a.back()] = it->second;
+    m.erase(it);
+    a.pop_back();
+    return true;
+  }
+
+  /** Get a random element from the set. */
+  int getRandom() {
+    return a[rand()%a.size()];
+  }
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet obj = new RandomizedSet();
+ * bool param_1 = obj.insert(val);
+ * bool param_2 = obj.remove(val);
+ * int param_3 = obj.getRandom();
+ */

kth-smallest-element-in-a-sorted-matrix.cc

@@ -0,0 +1,20 @@
+// Kth Smallest Element in a Sorted Matrix
+class Solution {
+public:
+  int kthSmallest(vector<vector<int>>& matrix, int k) {
+    int l = matrix[0][0], h = matrix.back().back();
+    while (l < h) {
+      int x = l+(h-l)/2, c = 0, j = matrix[0].size();
+      for (auto& a: matrix) {
+        while (j && x < a[j-1])
+          j--;
+        c += j;
+      }
+      if (c < k)
+        l = x+1;
+      else
+        h = x;
+    }
+    return l;
+  }
+};

linked-list-random-node.cc

@@ -0,0 +1,29 @@
+// Linked List Random Node
+class Solution {
+  int size;
+  ListNode* head;
+public:
+  /** @param head The linked list's head.
+    Note that the head is guaranteed to be not null, so it contains at least one node. */
+  Solution(ListNode* head) {
+    this->head = head;
+    size = 0;
+    for (; head; head = head->next)
+      size++;
+  }
+
+  /** Returns a random node's value. */
+  int getRandom() {
+    ListNode* x = head;
+    int t = rand() % size;
+    while (t--)
+      x = x->next;
+    return x->val;
+  }
+};
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(head);
+ * int param_1 = obj.getRandom();
+ */

mini-parser.cc

@@ -0,0 +1,26 @@
+// Mini Parser
+class Solution {
+public:
+  NestedInteger deserialize(string s) {
+    if (s[0] != '[')
+      return NestedInteger(stoi(s));
+    NestedInteger r;
+    stack<NestedInteger> st;
+    size_t l;
+    for (size_t i = 0; i < s.size(); i++)
+      if (s[i] == '[') {
+        st.emplace();
+        l = i+1;
+      } else if (s[i] == ',' || s[i] == ']') {
+        if (l < i)
+          st.top().add(NestedInteger(stoi(s.substr(l, i-l))));
+        l = i+1;
+        if (s[i] == ']' && st.size() > 1) {
+          auto x = st.top();
+          st.pop();
+          st.top().add(x);
+        }
+      }
+    return st.top();
+  }
+};

ransom-note.cc

@@ -0,0 +1,15 @@
+// Ransom Note
+class Solution {
+public:
+  bool canConstruct(string ransomNote, string magazine) {
+    long c[256] = {};
+    for (unsigned char i: magazine)
+      c[i]++;
+    for (unsigned char i: ransomNote)
+      c[i]--;
+    for (long i: c)
+      if (i < 0)
+        return false;
+    return true;
+  }
+};

shuffle-an-array.cc

@@ -0,0 +1,24 @@
+// Shuffle an Array
+class Solution {
+  vector<int> a;
+public:
+  Solution(vector<int> nums) : a(nums) {}
+
+  /** Resets the array to its original configuration and return it. */
+  vector<int> reset() { return a; }
+
+  /** Returns a random shuffling of the array. */
+  vector<int> shuffle() {
+    auto r = a;
+    for (size_t i = 1; i < r.size(); i++)
+      swap(r[rand()%(i+1)], r[i]);
+    return r;
+  }
+};
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(nums);
+ * vector<int> param_1 = obj.reset();
+ * vector<int> param_2 = obj.shuffle();
+ */

wiggle-subsequence.cc

@@ -0,0 +1,15 @@
+// Wiggle Subsequence
+class Solution {
+public:
+  int wiggleMaxLength(vector<int>& a) {
+    if (a.empty()) return 0;
+    int r = 1, x = a[0], s = 0;
+    for (int i = 0; i+1 < a.size(); i++) {
+      if (a[i] < a[i+1] && s <= 0)
+        r++, s = 1;
+      if (a[i] > a[i+1] && s >= 0)
+        r++, s = -1;
+    }
+    return r;
+  }
+};