[LeetCode] Flip Game II

Problem Description:

You are playing the following Flip Game with your friend: Given a string that contains only these two characters: + and -, you and your friend take turns to flip two consecutive "++" into "--". The game ends when a person can no longer make a move and therefore the other person will be the winner.

Write a function to determine if the starting player can guarantee a win.

For example, given s = "++++", return true. The starting player can guarantee a win by flipping the middle "++" to become "+--+".

Follow up:
Derive your algorithm's runtime complexity.

---

The simplest solution that I have found is here (refer to the first paragraph for explanations of the idea and the Java code). I rewrite it in C++.

The idea is very straightforward: if you can make s non-winnable by a move, then you will win.

class Solution {
public:
    bool canWin(string s) {
        for (int i = -1; (i = s.find("++", i + 1)) >= 0; )
            if (!canWin(s.substr(0, i) + '-' + s.substr(i+2)))
                return true;
        return false;
    }
};

If you are interested to learn more, this post shares a more sophisticated solution using game theory (it reduces the running time to 0 seconds!). The code is restructured as below.

class Solution {
public:
    bool canWin(string s) {
        vector<int> states = gameStates(s);
        if (states.empty()) return false;
         return spragueGrundy(states) != 0;
    }
private:
    vector<int> gameStates(string& s) {
        vector<int> states;
        int n = s.length(), c = 0;
        for (int i = 0; i < n; i++) {
            if (s[i] == '+') c++;
            if (i == n - 1 || s[i] == '-') {
                if (c >= 2) states.push_back(c);
                c = 0;
            }
        }
        return states;
    }
    int firstMissingNumber(unordered_set<int>& st) {
        int m = st.size();
        for (int i = 0; i < m; i++)
            if (!st.count(i)) return i;
        return m;
    }
    int spragueGrundy(vector<int>& states) {
        int m = *max_element(states.begin(), states.end());
        vector<int> sg(m + 1, 0);
        for (int l = 2; l <= m; l++) {
            unordered_set<int> st;
            for (int l1 = 0; l1 < l / 2; l1++) {
                int l2 = l - l1 - 2;
                st.insert(sg[l1] ^ sg[l2]);
            }
            sg[l] = firstMissingNumber(st);
        }
        int v = 0;
        for (int state : states) v ^= sg[state];
        return v;
    }
};