组合游戏系列1: Leetcode中的Minimax 和 Alpha Beta剪枝

本系列，我们来看看在一种常见的组合游戏——回合制棋盘类游戏中，如何用算法来解决问题。首先，我们会介绍并解决搜索空间较小的问题，引入经典的博弈算法和相关理论，最终实现在大搜索空间中的Deep RL近似算法。在此基础上可以理解AlphaGo的原理和工作方式。
本系列的第一篇，我们介绍3个Leetcode中的零和回合制游戏，从最初的暴力解法，到动态规划最终演变成博弈论里的经典算法： minimax 以及 alpha beta 剪枝。

• 第一篇 Leetcode中的Minimax 和 Alpha Beta剪枝

• 第二篇: 一些组合游戏的理论

• 第三篇: 连接N个点 的OpenAI Gym GUI环境

• 第四篇: 蒙特卡洛树搜索（MCTS）和时间差分学习（TD learning）

Leetcode 292 Nim Game (简单)

简单题 Leetcode 292 Nim Game。

你和你的朋友，两个人一起玩 Nim游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。
你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。

示例:
输入: 4
输出: false
解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。

定义 $f(n)$ 为有$n$个石头并采取最优策略的游戏结果， $f(n)$的值只有可能是赢或者输。考察前几个结果：$f(1)=f(2)=f(3)=Win$，然后来计算$f(4)$。因为玩家采取最优策略（只要有一种走法让对方必输，玩家获胜），对于4来说，玩家能走的可能是拿掉1块、2块或3块，但是无论剩余何种局面，对方都是必赢，因此，4就是必输。总的说来，递归关系如下：
$$f(n)=\neg (f(n-1)\wedge f(n-2)\wedge f(n-3))$$

这个递归式可以直接翻译成Python 3代码

# TLE
# Time Complexity: O(exponential)
class Solution_BruteForce:

    def canWinNim(self, n: int) -> bool:
        if n <= 3:
            return True
        for i in range(1, 4):
            if not self.canWinNim(n - i):
                return True
        return False

以上的递归公式和代码很像fibonacci数的递归定义和暴力解法，因此对应的时间复杂度也是指数级的，提交代码以后会TLE。下图画出了当n=7时的递归调用，注意 5 被扩展向下重复执行了两次，4重复了4次。

292 Nim Game 暴力解法调用图 n=7

我们采用和fibonacci一样的方式来优化算法：缓存较小n的结果以此来计算较大n的结果。 Python 中，我们可以只加一行lru_cache decorator，来取得这种动态规划效果，下面的代码将复杂度降到了 $O(N)$。

# RecursionError: maximum recursion depth exceeded in comparison n=1348820612
# Time Complexity: O(N)
class Solution_DP:
    from functools import lru_cache
    @lru_cache(maxsize=None)
    def canWinNim(self, n: int) -> bool:
        if n <= 3:
            return True
        for i in range(1, 4):
            if not self.canWinNim(n - i):
                return True
        return False

再来画出调用图：这次5和4就不再被展开重复计算，图中绿色的节点表示缓存命中。

292 Nim Game 动归解法调用图 n=7

但还是没有AC，因为当n=1348820612时，这种方式会导致栈溢出。再改成下面的循环版本，可惜还是TLE。

# TLE for 1348820612
# Time Complexity: O(N)
class Solution:
    def canWinNim(self, n: int) -> bool:
        if n <= 3:
            return True
        last3, last2, last1 = True, True, True
        for i in range(4, n+1):
            this = not (last3 and last2 and last1)
            last3, last2, last1 = last2, last1, this
        return last1

由此看来，AC 版本需要低于$O(n)$的算法复杂度。上面的写法似乎暗示输赢有周期性的规律。事实上，如果将输赢按照顺序画出来，就马上得出规律了：只要$n\mathrm{m}\mathrm{o}\mathrm{d}4=0$ 就是输，否则赢。原因如下：当面临不能被4整除的数量时 $4k+i(i=1,2,3)$ ，一方总是可以拿走 $i$ 个，将$4k$ 留给对手，而对方下轮又将返回不能被4整除的数，如此循环往复，直到这一方有1, 2, 3 个，最终获胜。

输赢分布

最终AC版本，只有一句语句。

# AC
# Time Complexity: O(1)
class Solution:
    def canWinNim(self, n: int) -> bool:
        return no