你和你的朋友，两个人一起玩 Nim 游戏：

桌子上有一堆石头。

你们轮流进行自己的回合，你作为先手。

每一回合，轮到的人拿掉 1 - 3 块石头。

拿掉最后一块石头的人就是获胜者。

假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false 。

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

这道题需要判断是否能赢，而不需要考虑怎么赢，同时包含了重叠的子问题，因此可以考虑动态规划

先手我们可以拿走 1 块、2 块 或者 3 块，石头数量变成 n-1块、n-2 块 或者 n-3 块。此时相当于对手先手拿n-1块、n-2 块 或者 n-3 块，若对手必胜，对于我们必败；若对手有可能败，我们“每一步都是最优解”，我们必胜。

状态转移方程：dp[i] = !(dp[i - 1] && dp[i - 2] && dp[i - 3])

public class Solution {
    public boolean canWinNim(int n) {
        if (n < 4) return true;
        boolean[] dp = new boolean[n + 1];
        dp[1] = true;
        dp[2] = true;
        dp[3] = true;
        for (int i = 4; i <= n; i++) {
            dp[i] = !(dp[i - 1] && dp[i - 2] && dp[i - 3]);
        }
        return dp[n];
    }
}

超出内存限制，优化空间

public class Solution {
    public boolean canWinNim(int n) {
        if(n<=3)return true;
        boolean a=true,b=true,c=true;
        boolean temp;
        for (int i = 4; i <= n; i++) {
            temp = !(a&&b&&c);
            a = b;
            b = c;
            c = temp;
        }
        return c;
    }
}

超出时间限制，动态规划行不通，换递归，也是同样的思路

class Solution {
    public boolean canWinNim(int n) {
        if (n < 4) return true;
        return !(canWinNim(n - 1) && canWinNim(n - 2) && canWinNim(n - 3));
    }
}

也超出时间限制，找规律，可以发现当先手拿到的是4或4的倍数时，必输

因为“每一步都是最优解”，对手可以不断将每回合拿的石头数组合成4，形成必赢的局面

class Solution {
    public boolean canWinNim(int n) {
        return n % 4!=0;
    }
}

知识点：无

总结：无