293_Flip_Game

294_Flip_Game_II

Author: qiyuangong

README.md

@@ -96,6 +96,8 @@
 | 280 | [Wiggle Sort](https://leetcode.com/problems/wiggle-sort/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/280_Wiggle_Sort.py) &hearts; | 1. Sort and insert (n - 1) / 2 from tail to correct position, O(nlogn) and O(1)<br>2. Sort and swap(i, i + 1) from 1 to n - 1, O(nlogn)<br>3. Iteratively check order and reverse order, if not satisfied, then swap i with i + 1, O(n) |
 | 286 | [Walls and Gates](https://leetcode.com/problems/walls-and-gates/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/286_Walls_and_Gates.py) | BFS with queue, O(mn) and O(mn) |
 | 288 | [Unique Word Abbreviation](https://leetcode.com/problems/unique-word-abbreviation/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/288_Unique_Word_Abbreviation.py) | hash |
+| 293 | [Flip Game](https://leetcode.com/problems/flip-game/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/293_Flip_Game.py) | Python string slicing |
+| 294 | [Flip Game II](https://leetcode.com/problems/flip-game-ii/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/294_Flip_Game_II.py) | 1. Backtracking to ensure that next step is False, O(n!!) and O(n!!)<br>2. Backtracking with memo, O(n!!) and O(n!)<br>3. DP based on [Sprague-Grundy Function](https://discuss.leetcode.com/topic/27282/theory-matters-from-backtracking-128ms-to-dp-0ms) |
 | 296 | [Best Meeting Point](https://leetcode.com/problems/best-meeting-point/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/296_Best_Meeting_Point.py) | Think hard about Manhattan Distance in 1D case. Sort and find mean, O(mnlogmn) and O(1) |
 | 298 | [Binary Tree Longest Consecutive Sequence](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/298_Binary_Tree_Longest_Consecutive_Sequence.py) | Bottom-up or top-down recursion, O(n) and O(n) |
 | 305 | [Number of Islands II](https://leetcode.com/problems/number-of-islands-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/305_Number_of_Islands_II.py) | Quick union find with weights, O(nlogn) and O(n) |
@@ -106,7 +108,7 @@
 | 346 | [Moving Average from Data Stream](https://leetcode.com/problems/moving-average-from-data-stream/) &hearts; | 
 [Python](https://github.com/qiyuangong/leetcode/blob/master/python/346_Moving_Average_from_Data_Stream.py) | fix-sized queue or dequeue, O(1) and O(n) |
 | 351 | [Android Unlock Patterns](https://leetcode.com/problems/android-unlock-patterns/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/351_Android_Unlock_Patterns.py) | Backtracking, O(n!) and O(n) |
-| 359 | [Logger Rate Limiter](https://leetcode.com/problems/logger-rate-limiter/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/359_Logger_Rate_Limiter.py) | 1. hash which stores the latest timestamp, O(1) and O(n)<br>2. Using Priority queue to remove older logs, O(n) and O(n)|
+| 359 | [Logger Rate Limiter](https://leetcode.com/problems/logger-rate-limiter/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/359_Logger_Rate_Limiter.py) | 1. hash which stores the latest timestamp, O(1) and O(n)<br>2. Using Priority queue to remove older logs, O(n) and O(n) |
 | 368 | [Largest Divisible Subset](https://leetcode.com/problems/largest-divisible-subset/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/368_Largest_Divisible_Subset.py) | Sort and generate x subset with previous results, O(n^2) and O(n^2) |
 | 370 | [Range Addition](https://leetcode.com/problems/range-addition/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/370_Range_Addition.py) | Interval problem with cumulative sums, O(n + k) and O(n) |
 | 384 | [Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/384_Shuffle_an_Array.py) | Fisher–Yates shuffle, O(n) and O(n) |

python/293_Flip_Game.py

@@ -0,0 +1,15 @@
+class Solution(object):
+    def generatePossibleNextMoves(self, s):
+        """
+        :type s: str
+        :rtype: List[str]
+        """
+        # return [s[:i] + "--" + s[i+2:] for i in range(len(s) - 1) if s[i] == s[i + 1] == "+"]
+        res = []
+        if s is None or len(s) == 0:
+            return res
+        ls = len(s)
+        for i in range(ls - 1):
+            if s[i] == '+' and s[i + 1] == '+':
+                res.append(s[:i] + '--' + s[i + 2:])
+        return res

python/294_Flip_Game_II.py

@@ -0,0 +1,84 @@
+class Solution(object):
+    # def canWin(self, s):
+    #     """
+    #     :type s: str
+    #     :rtype: bool
+    #     """
+    #     if s is None or len(s) < 2:
+    #         return False
+    #     for i in range(len(s) - 1):
+    #         if s[i:i + 2] == '++':
+    #             if not self.canWin(s[:i] + '--' + s[i + 2:]):
+    #                 return True
+    #     return False
+
+    def canWin(self, s):
+        if s is None or len(s) < 2:
+            return False
+        list_s = list(s)
+        return self.canWin_helper(list_s)
+
+    def canWin_helper(self, s):
+        for i in range(len(s) - 1):
+            if s[i] == '+' and s[i + 1] == '+':
+                s[i] = '-'
+                s[i + 1] = '-'
+                res = self.canWin_helper(s)
+                s[i] = '+'
+                s[i + 1] = '+'
+                if not res:
+                    return True
+        return False
+
+    # def canWin(self, s):
+    #     # backtracking with memo
+    #     memo = {}
+
+    #     def can(s):
+    #         if s not in memo:
+    #             memo[s] = any(s[i:i + 2] == '++' and not can(s[:i] + '-' + s[i + 2:])
+    #                           for i in range(len(s)))
+    #         return memo[s]
+    #     return can(s)
+    # https://discuss.leetcode.com/topic/27282/theory-matters-from-backtracking-128ms-to-dp-0ms/3
+    # def canWin(self, s):
+    #     g, G = [0], 0
+    #     for p in map(len, re.split('-+', s)):
+    #         while len(g) <= p:
+    #             g += min(set(range(p)) - {a^b for a, b in zip(g, g[-2::-1])}),
+    #         G ^= g[p]
+    #     return G > 0
+
+    # def canWin(self, s):
+    #     currlen, maxlen = 0, 0
+    #     board_ini_state = []
+    #     for i in range(len(s)):
+    #         if s[i] == '+':
+    #             currlen += 1
+    #         if i + 1 == len(s) or s[i] == '-':
+    #             if currlen >= 2:
+    #                 board_ini_state.append(currlen)
+    #             maxlen = max(maxlen, currlen)
+    #             currlen = 0
+    #     g = [0] * (maxlen + 1)
+    #     for l in range(2, maxlen + 1):
+    #         gsub = set()
+    #         for len_first_game in range(l / 2):
+    #             len_second_game = l - len_first_game - 2
+    #             gsub.add(g[len_first_game] ^ g[len_second_game])
+    #         g[l] = firstMissingNumber(gsub)
+    #     g_final = 0
+    #     for state in board_ini_state:
+    #         g_final ^= g[state]
+    #     return g_final != 0
+
+    # def firstMissingNumber(lut):
+    #     ls = len(lut)
+    #     for i in range(ls):
+    #         if i not in lut:
+    #             return i
+    #     return ls
+
+if __name__ == '__main__':
+    s = Solution()
+    print s.canWin("++++")