《算法通关之路》-chapter11博弈问题

《算法通关之路》学习笔记，记录一下自己的刷题过程，详细的内容请大家购买作者的书籍查阅。

石子游戏

力扣第877题
Alice 和 Bob 用几堆石子在做游戏。一共有偶数堆石子，排成一行；每堆都有 正 整数颗石子，数目为 piles[i] 。
游戏以谁手中的石子最多来决出胜负。石子的 总数 是 奇数 ，所以没有平局。
Alice 和 Bob 轮流进行，Alice 先开始 。 每回合，玩家从行的 开始 或 结束 处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止，此时手中石子最多的玩家获胜 。
假设 Alice 和 Bob 都发挥出最佳水平，当 Alice 赢得比赛时返回 true ，当 Bob 赢得比赛时返回 false 。

'''
方法一：记忆化递归
时间复杂度：O（n2）
空间复杂度：O（n2）
'''
class Solution:
    def stoneGame(self, piles: list[int]) -> bool:
        
        def find_max(left: int, right: int, piles: list[int], mem: list[list[int]]) -> int:
            if left < 0 or right < 0 or left > right:
                return 0
            if mem[left][right] != 0:
                return mem[left][right]
            if left == right:
                mem[left][right] = piles[left]
                return piles[left]
            
            # 零和博弈：最大化己方收益，最小化对方收益
            max_stone = max(
                piles[left] + min(
                    find_max(left+2, right, piles, mem),
                    find_max(left+1, right-1, piles, mem)
                ),
                piles[right] + min(
                    find_max(left+1, right-1, piles, mem),
                    find_max(left, right-2, piles, mem)
                )
            )
            mem[left][right] = max_stone
            return max_stone
        
        mem = [[0] * len(piles) for _ in range(len(piles))]
        return 2 * find_max(0, len(piles) - 1, piles, mem) > sum(piles)

piles = [5,3,4,5]
solu = Solution()
solu.stoneGame(piles)

预测赢家

力扣第486题
给你一个整数数组 nums 。玩家 1 和玩家 2 基于这个数组设计了一个游戏。
玩家 1 和玩家 2 轮流进行自己的回合，玩家 1 先手。开始时，两个玩家的初始分值都是 0 。每一回合，玩家从数组的任意一端取一个数字（即，nums[0] 或 nums[nums.length - 1]），取到的数字将会从数组中移除（数组长度减 1 ）。玩家选中的数字将会加到他的得分上。当数组中没有剩余数字可取时，游戏结束。
如果玩家 1 能成为赢家，返回 true 。如果两个玩家得分相等，同样认为玩家 1 是游戏的赢家，也返回 true 。你可以假设每个玩家的玩法都会使他的分数最大化。

'''
方法一：记忆化递归
时间复杂度：O（n2）
空间复杂度：O（n2）
'''
class Solution:
    def PredictTheWinner(self, nums: list[int]) -> bool:
        
        def find_max(left: int, right: int, piles: list[int], mem: list[list[int]]) -> int:
            if left < 0 or right < 0 or left > right:
                return 0
            if mem[left][right] != 0:
                return mem[left][right]
            if left == right:
                mem[left][right] = piles[left]
                return piles[left]
            
            # 零和博弈：最大化己方收益，最小化对方收益
            max_num = max(
                piles[left] + min(
                    find_max(left+2, right, piles, mem),
                    find_max(left+1, right-1, piles, mem)
                ),
                piles[right] + min(
                    find_max(left+1, right-1, piles, mem),
                    find_max(left, right-2, piles, mem)
                )
            )
            mem[left][right] = max_num
            return max_num
        
        mem = [[0] * len(nums) for _ in range(len(nums))]
        return 2 * find_max(0, len(nums) - 1, nums, mem) >= sum(nums)

nums = [1,5,2]
solu = Solution()
solu.PredictTheWinner(nums)

'''
方法二：动态规划
时间复杂度：O（n2）
空间复杂度：O（n2）
'''
class Solution:
    def PredictTheWinner(self, nums: list[int]) -> bool:
        n = len(nums)
        dp = [[0] *n for _ in range(n)]

        for i in range(n):
            dp[i][i] = nums[i]
        
        for i in range(n-1, -1, -1):
            for j in range(i+1, n):
                dp[i][j] = max(nums[i] - dp[i+1][j], nums[j]-dp[i][j-1])
        return dp[0][n-1] >= 0

nums = [1,5,2]
solu = Solution()
solu.PredictTheWinner(nums)

'''
方法三：动态规划(滚动数组优化)
时间复杂度：O（n2）
空间复杂度：O（n）
'''
class Solution:
    def PredictTheWinner(self, nums: list[int]) -> bool:
        n = len(nums)
        if n % 2 == 0:
            return True
        dp = [0] *n 
        for i in range(n-1, -1, -1):
            dp[i] = nums[i]
            for j in range(i+1, n):
                dp[j] = max(nums[i] - dp[j], nums[j] - dp[j-1])
        return dp[-1] >= 0

nums = [1,5,2]
solu = Solution()
solu.PredictTheWinner(nums)

Nim 游戏

力扣第292题
你和你的朋友，两个人一起玩 Nim 游戏：
桌子上有一堆石头。
你们轮流进行自己的回合， 你作为先手 。
每一回合，轮到的人拿掉 1 - 3 块石头。
拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false 。

'''
方法一：自底向上（超时）
时间复杂度：O（n）
空间复杂度：O（n）
'''
class Solution:
    def canWinNim(self, n: int) -> bool:
        if n < 4:
            return True
        mem = [True] * (n + 1) # True意味着你的朋友可以赢
        for i in range(4, n+1):
            if not (mem[i-1] and mem[i-2] and mem[i-3]): # 能否找到剩下几个石子可以赢得比赛
                mem[i] = True
            else:
                mem[i]  = False
        return mem[n]

n = 8
solu = Solution()
solu.canWinNim(n)

'''
方法二：优化空间（超时）
时间复杂度：O（n）
空间复杂度：O（1）
'''
class Solution:
    def canWinNim(self, n: int) -> bool:
        a, b, c = True, True, True # True意味着你的朋友可以赢
        for i in range(4, n+1):
            a, b, c = b, c, not (a and b and c)
        return c

n = 8
solu = Solution()
solu.canWinNim(n)

'''
方法三：找规律
时间复杂度：O（1）
空间复杂度：O（1）
'''
class Solution:
    def canWinNim(self, n: int) -> bool:
        return n % 4 != 0

n = 8
solu = Solution()
solu.canWinNim(n)

猜数字大小 II

力扣第375题
我们正在玩一个猜数游戏，游戏规则如下：
我从 1 到 n 之间选择一个数字。
你来猜我选了哪个数字。
如果你猜到正确的数字，就会 赢得游戏 。
如果你猜错了，那么我会告诉你，我选的数字比你的 更大或者更小 ，并且你需要继续猜数。
每当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。如果你花光了钱，就会 输掉游戏 。
给你一个特定的数字 n ，返回能够 确保你获胜 的最小现金数，不管我选择那个数字 。

'''
方法一：暴力法(超时)
时间复杂度：O（n!）
空间复杂度：O（n）
'''
class Solution:
    # 极小极大法：选最好的数字遇最坏的情况
    def getMoneyAmount(self, n: int) -> int:

        def cost(low, high):
            if low >= high:
                return 0
            res = float('inf')
            for i in range(low, high + 1):
                tmp = i + max(cost(low, i-1), cost(i+1, high)) # 遭遇最坏情况
                res = min(res, tmp) # 选花费最少的数字
            return res
        
        return cost(1, n)
    
n = 10
solu = Solution()
solu.getMoneyAmount(n)

'''
方法二：记忆化递归
空间复杂度：O（n2）
'''
class Solution:
    def getMoneyAmount(self, n: int) -> int:
        mem = [[0] * (n+1) for _ in range(n+1)]

        def cost(low, high):
            if low >= high:
                return 0
            if mem[low][high] != 0:
                return mem[low][high]
            res = float('inf')
            for i in range((low+high)//2, high + 1): # 从右侧区域开始查找的开销一定大于左侧
                tmp = i + max(cost(low, i-1), cost(i+1, high)) # 遭遇最坏情况
                res = min(res, tmp) # 选花费最少的数字
            mem[low][high] = res
            return res
        
        return cost(1, n)

n = 10
solu = Solution()
solu.getMoneyAmount(n)

笔记本-Github