277/277: http://maskray.me/blog/2015-10-16-leetcode-expression-add-operators

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 273/273 problems.
+Solved 277/277 problems.
 
 ## Database
 
@@ -12,6 +12,10 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|294|[Flip Game II](https://leetcode.com/problems/flip-game-ii/)|[flip-game-ii.cc](flip-game-ii.cc)|
+|293|[Flip Game](https://leetcode.com/problems/flip-game/)|[flip-game.cc](flip-game.cc)|
+|292|[Nim Game](https://leetcode.com/problems/nim-game/)|[nim-game.cc](nim-game.cc)|
+|291|[Word Pattern II](https://leetcode.com/problems/word-pattern-ii/)|[word-pattern-ii.cc](word-pattern-ii.cc)|
 |290|[Word Pattern](https://leetcode.com/problems/word-pattern/)|[word-pattern.cc](word-pattern.cc)|
 |289|[Game of Life](https://leetcode.com/problems/game-of-life/)|[game-of-life.cc](game-of-life.cc)|
 |288|[Unique Word Abbreviation](https://leetcode.com/problems/unique-word-abbreviation/)|[unique-word-abbreviation.cc](unique-word-abbreviation.cc)|

Diff for: expression-add-operators.cc

@@ -1,37 +1,94 @@
 // Expression Add Operators
+
+/// like Earley parser, O(4^n) (string concatenation treated as O(1))
+
+typedef long long ll;
 class Solution {
-private:
-  string num;
-  int target;
-  vector<string> r;
-  void dfs(int k, long v, long p, int sgn, string s) {
-    if (k == num.size()) {
-      if (v+p == target) {
-        s.pop_back();
-        r.push_back(s);
-      }
+  string a;
+  int n, target;
+  vector<string> res;
+  void forward(int k, string s, ll add, ll mul, ll last) {
+    ll sum = add+mul*last;
+    if (k == n) {
+      if (sum == target)
+        res.push_back(s);
+      return;
+    }
+    int x = a[k]-'0';
+    if (last) // no leading zero
+      forward(k+1, s+a[k], add, mul, last*10+x);
+    forward(k+1, s+'*'+a[k], add, mul*last, x);
+    forward(k+1, s+'+'+a[k], sum, 1, x);
+    forward(k+1, s+'-'+a[k], sum, -1, x);
+  }
+public:
+  vector<string> addOperators(string num, int target) {
+    a = num;
+    n = a.size();
+    if (n) {
+      this->target = target;
+      forward(1, string(1, a[0]), 0, 1, a[0]-'0');
+    }
+    return res;
+  }
+};
+
+/// accelerated by meet-in-the-middle, O(4^(n/2)*2^(n/2)) = O(2^(1.5n))
+
+typedef long long ll;
+class Solution {
+  string a;
+  int n, nn, target;
+  vector<multimap<ll, string>> e_plus, e_minus;
+  vector<string> res;
+  void backward(int k, string s, ll add, ll mul, ll last, ll ten) {
+    if (k < nn) return;
+    int x = a[k-1]-'0';
+    ll ten2 = 10*ten, sum = add+mul*last;
+    backward(k-1, string(1, a[k-1])+s, add, mul, last+ten2*x, ten2);
+    if (ten == 1 || last >= ten) { // `last` has no leading zero
+      backward(k-1, string(1, a[k-1])+'*'+s, add, mul*last, x, 1);
+      backward(k-1, string(1, a[k-1])+'+'+s, sum, 1, x, 1);
+      backward(k-1, string(1, a[k-1])+'-'+s, add-mul*last, 1, x, 1);
+      e_plus[k].insert(make_pair(sum, s));
+      e_minus[k].insert(make_pair(add-mul*last, s));
+    }
+  }
+  void forward(int k, string s, ll add, ll mul, ll last) {
+    ll sum = add+mul*last;
+    if (k == n) {
+      if (sum == target)
+        res.push_back(s);
+      return;
+    }
+    int x = a[k]-'0';
+    if (last) // no leading zero
+      forward(k+1, s+a[k], add, mul, last*10+x);
+    forward(k+1, s+'*'+a[k], add, mul*last, x);
+    if (k < nn) {
+      forward(k+1, s+'+'+a[k], sum, 1, x);
+      forward(k+1, s+'-'+a[k], sum, -1, x);
     } else {
-      long x = 0;
-      for (int i = k; i < num.size(); i++) {
-        string ss = s + num.substr(k, i-k+1);
-        x = x * 10 + num[i]-'0';
-        long vv = (sgn ? sgn : p) * x;
-        dfs(i+1, v+vv, 0, 1, ss+'+');
-        if (i+1 < num.size()) {
-          dfs(i+1, v+vv, 0, -1, ss+'-');
-          dfs(i+1, v, vv, 0, ss+'*');
-        }
-        if (num[k] == '0') break;
-      }
+      auto rg = e_plus[k].equal_range(target-sum);
+      for (auto it = rg.first; it != rg.second; ++it)
+        res.push_back(s+'+'+it->second);
+      rg = e_minus[k].equal_range(target-sum);
+      for (auto it = rg.first; it != rg.second; ++it)
+        res.push_back(s+'-'+it->second);
     }
   }
 public:
   vector<string> addOperators(string num, int target) {
-    if (num.size()) {
-      this->num = num;
+    a = num;
+    n = a.size();
+    if (n) {
+      nn = n/2; // 0 < nn < n
       this->target = target;
-      dfs(0, 0, 0, 1, "");
+      e_plus.resize(n);
+      e_minus.resize(n);
+      backward(n-1, string(1, a[n-1]), 0, 1, a[n-1]-'0', 1);
+      forward(1, string(1, a[0]), 0, 1, a[0]-'0');
     }
-    return r;
+    return res;
   }
 };

Diff for: flip-game-ii.cc

@@ -0,0 +1,24 @@
+// Flip Game II
+class Solution {
+public:
+  bool canWin(string s) {
+    vector<int> sg(s.size()+1, 0), t(s.size()+1, 0);
+    int tick = 0;
+    for (int i = 2; i <= s.size(); i++) {
+      tick++;
+      for (int j = i-2; j >= 0; j--)
+        t[sg[j]^sg[i-2-j]] = tick;
+      sg[i] = find_if(t.begin(), t.end(), bind(not_equal_to<int>(), placeholders::_1, tick)) - t.begin();
+    }
+    int sum = 0;
+    for (auto i = s.begin(); i != s.end(); )
+      if (*i == '-')
+        ++i;
+      else {
+        auto j = find(i, s.end(), '-');
+        sum ^= sg[j-i];
+        i = j;
+      }
+    return sum;
+  }
+};

Diff for: flip-game.cc

@@ -0,0 +1,14 @@
+// Flip Game
+class Solution {
+public:
+  vector<string> generatePossibleNextMoves(string s) {
+    vector<string> r;
+    for (int i = 0; i+1 < s.size(); i++)
+      if (s[i] == '+' && s[i+1] == '+') {
+        r.push_back(s);
+        r.back()[i] = '-';
+        r.back()[i+1] = '-';
+      }
+    return r;
+  }
+};

Diff for: nim-game.cc

@@ -0,0 +1,7 @@
+// Nim Game
+class Solution {
+public:
+  bool canWinNim(int n) {
+    return n%4;
+  }
+};

Diff for: word-pattern-ii.cc

@@ -0,0 +1,41 @@
+// Word Pattern II
+class Solution {
+  string p, s;
+  unordered_map<char, string> mp;
+  unordered_set<string> st;
+  vector<int> freq;
+  bool f(int i, int j, int b) {
+    if (i == p.size())
+      return j == s.size();
+    if (b > s.size())
+      return false;
+    if (mp.count(p[i])) {
+      auto &sub = mp[p[i]];
+      if (s.substr(j, sub.size()) == sub && f(i+1, j+sub.size(), b))
+        return true;
+    } else {
+      string sub;
+      for (int l = 1; j+l <= s.size(); l++) {
+        sub += s[j+l-1];
+        if (! st.count(sub)) {
+          st.insert(sub);
+          mp[p[i]] = sub;
+          if (f(i+1, j+l, b+freq[p[i]-'a']*l))
+            return true;
+          mp.erase(p[i]);
+          st.erase(sub);
+        }
+      }
+    }
+    return false;
+  }
+public:
+  bool wordPatternMatch(string pattern, string str) {
+    p = pattern;
+    s = str;
+    freq.resize(26);
+    for (auto c: pattern)
+      freq[c-'a']++;
+    return f(0, 0, 0);
+  }
+};