数学法 | 动态规划：力扣1025. 除数博弈

1、题目描述：

2、题解：

方法1：数学法
思路1：

1、数字N如果是奇数，它的约数必然都是奇数；若为偶数，则其约数可奇可偶。
2、无论N初始为多大的值，游戏最终只会进行到N=2时结束，那么谁轮到N=2时谁就会赢。
3、因为爱丽丝先手，N初始若为偶数，爱丽丝则只需一直选1，使鲍勃一直面临N为奇数的情况，这样爱丽丝稳赢；
N初始若为奇数，那么爱丽丝第一次选完之后N必为偶数，那么鲍勃只需一直选1就会稳赢。
综述，判断N是奇数还是偶数，即可得出最终结果！

思路2：

当然也可以找规律：
N = 1 的时候，Alice必败
N = 2时，Alice只能拿1，N变成1，Bob无法操作，Alice胜
N = 3时，Alice只能拿1，此时N = 2，根据N = 2的结论，则Alice败
N = 4时，Alice可拿1或2，拿2时，N = 2，根据N = 2的结论，Alice败；Alice拿1，那么根据N = 3的结论，Alice输
N = 5时，Alice只能拿1，根据N = 4的结论 ，Alice败
...
N为奇数 ，Alice败
N为偶数，Alice胜

思路3：归纳法

Alice先手，N为奇数，Alice败；N为偶数，Alice胜
1、N = 1 和N = 2时结论成立
2、当N > 2 时，假设N <= k时结论成立，则 N = k +1时：
    若k为偶数，则k+1为奇数，又因x 是k+1的因数，则x只能为奇数，奇-奇=偶，又k+1-x <= k，所以到Bob时，都是偶数，Bob胜，Alice败
    若k为奇数，则k+1为偶数，又因x是k+1的因数，则x可以为奇数，也可以为偶数，若Alice选奇数，则偶-奇=奇，又k+1-x <= k，轮到Bob时
    是奇数，Bob败，Alice胜

Python代码如下：

class Solution:
    def divisorGame(self, N: int) -> bool:
        return N % 2 == 0

方法2：动态规划
动态规划问题，弄清楚三点：
1、重复子问题；
2、最优子结构；
3、无后效性。

动态规划：
1、状态定义；
2、状态转移方程；
3、初始化；base case
4、输出；
5、思考状态压缩。

可以用递归去求，但是会存在重叠子问题，加个备忘录可以解决重复问题。
记忆化递归：

class Solution:
    def divisorGame(self, N: int) -> bool:
        #记忆化递归
        visited = {}
        def dfs(N):
            if N == 1: 
                visited[1] = False
                return False
            # if N  == 2: return True
            if N in visited:
                return visited[N]
            for i in range(1,N // 2 + 1):
                if N % i == 0 and dfs(N - i) == False:#如果i是N的因数，并且dfs(N - i)为假，则当前为真
                    visited[N] = True
                    return True
            visited[N] = False
            return visited[N]
        return dfs(N)

动态规划：

状态定义：
dp[i] 为数字为i时Alice的输赢情况，有True 和False 两个值（分别对应赢和输的情况）
状态转移方程：
dp[i] = not dp[i - x] 解释：在Alice 选x时，只要dp[i - x]有一个为False，那么dp[i]就为True
初始化 base case:
dp[1] = False
dp[2] = True

Python代码如下：

class Solution:
    def divisorGame(self, N: int) -> bool:
        #动态规划
        dp = [False] * (N + 1)
        if N <= 1 :return False
        dp [2] = True
        for i in range(3,N + 1):
            for j in (1,i//2):
                if i % j == 0 and dp[i - j] == False:
                    dp[i] = True
                    break
        return dp[N]

3、复杂度分析：

方法1：
时间复杂度：O(1)
空间复杂度：O(1)
方法2：
时间复杂度：O(N^2)
空间复杂度：O(N)