426/429

Author: MaskRay

132-pattern.cc

@@ -0,0 +1,20 @@
+// 132 Pattern
+#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:
+  bool find132pattern(vector<int>& nums) {
+    int n = nums.size(), j;
+    vector<int> l(n), mn(n);
+    REP(i, n) {
+      for (j = i-1; j >= 0 && nums[j] <= nums[i]; j = l[j]);
+      l[i] = j;
+      mn[i] = min(nums[i], i ? mn[i-1] : INT_MAX);
+    }
+    REP(i, n)
+      if (l[i] > 0 && mn[l[i]-1] < nums[i])
+        return true;
+    return false;
+  }
+};

4sum-ii.cc

@@ -0,0 +1,18 @@
+// 4Sum II
+class Solution {
+public:
+  int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+    unordered_map<int, int> m;
+    int r = 0;
+    for (int a: A)
+      for (int b: B)
+        m[a+b]++;
+    for (int c: C)
+      for (int d: D) {
+        int t = -c-d;
+        if (m.count(t))
+          r += m[t];
+      }
+    return r;
+  }
+};

README.md

@@ -2,7 +2,7 @@
 
 [LeetCode solutions](http://maskray.me/blog/2014-06-29-leetcode-solutions) gives some thoughts on selected problems.
 
-Solved 418/421 problems.
+Solved 426/429 problems.
 
 ## Database
 
@@ -12,6 +12,14 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|465|[Optimal Account Balancing](https://leetcode.com/problems/optimal-account-balancing)|[optimal-account-balancing.cc](optimal-account-balancing.cc)|
+|464|[Can I Win](https://leetcode.com/problems/can-i-win)|[can-i-win.cc](can-i-win.cc)|
+|463|[Island Perimeter](https://leetcode.com/problems/island-perimeter)|[island-perimeter.cc](island-perimeter.cc)|
+|462|[Minimum Moves to Equal Array Elements II](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii)|[minimum-moves-to-equal-array-elements-ii.cc](minimum-moves-to-equal-array-elements-ii.cc)|
+|459|[Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern)|[repeated-substring-pattern.cc](repeated-substring-pattern.cc)|
+|456|[132 Pattern](https://leetcode.com/problems/132-pattern)|[132-pattern.cc](132-pattern.cc)|
+|455|[Assign Cookies](https://leetcode.com/problems/assign-cookies)|[assign-cookies.cc](assign-cookies.cc)|
+|454|[4Sum II](https://leetcode.com/problems/4sum-ii)|[4sum-ii.cc](4sum-ii.cc)|
 |453|[Minimum Moves to Equal Array Elements](https://leetcode.com/problems/minimum-moves-to-equal-array-elements)|[minimum-moves-to-equal-array-elements.cc](minimum-moves-to-equal-array-elements.cc)|
 |452|[Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons)|[minimum-number-of-arrows-to-burst-balloons.cc](minimum-number-of-arrows-to-burst-balloons.cc)|
 |447|[Number of Boomerangs](https://leetcode.com/problems/number-of-boomerangs)|[number-of-boomerangs.cc](number-of-boomerangs.cc)|

assign-cookies.cc

@@ -0,0 +1,17 @@
+// Assign Cookies
+class Solution {
+public:
+  int findContentChildren(vector<int>& g, vector<int>& s) {
+    sort(g.begin(), g.end());
+    sort(s.begin(), s.end());
+    auto i = s.begin();
+    int r = 0;
+    for (int x: g) {
+      while (i != s.end() && *i < x) ++i;
+      if (i == s.end()) break;
+      ++i;
+      r++;
+    }
+    return r;
+  }
+};

can-i-win.cc

@@ -0,0 +1,22 @@
+// Can I Win
+class Solution {
+  unordered_map<int, bool> memo;
+  int k;
+  bool f(int s, int m) {
+    int t = m*301+s;
+    if (memo.count(t))
+      return memo[t];
+    bool& r = memo[t];
+    for (int i = 0; i < k; i++)
+      if (! (m & 1 << i) && (s-i-1 <= 0 || ! f(s-i-1, m | 1<<i))) {
+        r = true;
+        break;
+      }
+    return r;
+  }
+public:
+  bool canIWin(int maxChoosableInteger, int desiredTotal) {
+    k = maxChoosableInteger;
+    return k*(k+1)/2>= desiredTotal && f(desiredTotal, 0);
+  }
+};

island-perimeter.cc

@@ -0,0 +1,19 @@
+// Island Perimeter
+#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 islandPerimeter(vector<vector<int>>& a) {
+    int m = a.size(), n = a[0].size(), s = 0;
+    REP(i, m)
+      REP(j, n)
+        if (a[i][j]) {
+          if (! i || ! a[i-1][j]) s++;
+          if (i == m-1 || ! a[i+1][j]) s++;
+          if (! j || ! a[i][j-1]) s++;
+          if (j == n-1 || ! a[i][j+1]) s++;
+        }
+    return s;
+  }
+};

minimum-moves-to-equal-array-elements-ii.cc

@@ -0,0 +1,12 @@
+// Minimum Moves to Equal Array Elements II
+class Solution {
+public:
+  int minMoves2(vector<int>& a) {
+    if (a.empty()) return 0;
+    nth_element(a.begin(), a.begin()+a.size()/2, a.end());
+    int s = 0;
+    for (int i: a)
+      s += abs(i-a[a.size()/2]);
+    return s;
+  }
+};

optimal-account-balancing.cc

@@ -0,0 +1,35 @@
+// Optimal Account Balancing
+#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 minTransfers(vector<vector<int>>& t) {
+    unordered_map<int, int> m;
+    int r = 0, c = 0;
+    for (auto& x: t) {
+      m[x[0]] += x[2];
+      m[x[1]] -= x[2];
+    }
+    vector<int> a;
+    for (auto& x: m)
+      if (x.second)
+        a.push_back(x.second);
+    if (a.empty()) return 0;
+    vector<int> dp(1<<a.size(), INT_MAX/2), cir;
+    FOR(i, 1, 1<<a.size()) {
+      int t = 0, c = 0;
+      REP(j, a.size())
+        if (i>>j & 1)
+          t += a[j], c++;
+      if (! t) {
+        dp[i] = c-1;
+        for (int t: cir)
+          if ((i & t) == t)
+            dp[i] = min(dp[i], dp[t]+dp[i-t]);
+        cir.push_back(i);
+      }
+    }
+    return dp.back();
+  }
+};

repeated-substring-pattern.cc

@@ -0,0 +1,13 @@
+// Repeated Substring Pattern
+class Solution {
+public:
+  bool repeatedSubstringPattern(string str) {
+    vector<int> pi(str.size());
+    for (int j = 0, i = 1; i < str.size(); i++) {
+      while (j && str[i] != str[j]) j = pi[j-1];
+      if (str[i] == str[j]) j++;
+      pi[i] = j;
+    }
+    return pi.back() && str.size()%(str.size()-pi.back()) == 0;
+  }
+};