2023-01-12 17:39阅读: 124评论: 0推荐: 0

【动态规划】博弈问题

1.【动态规划】最长公共子序列2022-11-15 2.【动态规划】最长递增子序列2022-11-19 3.【动态规划】子串、子序列问题2023-07-06 4.【动态规划】股票买卖问题2023-01-11 5.【动态规划】背包问题的应用2023-01-09 6.【动态规划】背包问题2023-01-03 7.【动态规划】矩阵2023-02-28 8.【动态规划】压缩状态2023-02-27 9.【动态规划】高楼扔鸡蛋问题2023-01-17 10.【动态规划】打家劫舍2023-01-16

11.【动态规划】博弈问题2023-01-12

12.【动态规划】编辑距离2022-12-26 13.【动态规划】正则表达式2024-01-22 14.【动态规划】矩阵2024-01-24 15.【动态规划】最长公共子串2024-02-05

博弈问题

简介

具有竞争或对抗性质的行为称为博弈行为，在这类行为中，参加斗争或竞争的各方各自具有不同的目标或利益。博弈论是二人在平等的对局中各自利用对方的策略变换自己的对抗策略，达到取胜的目的。

为了达到各自的目标和利益，各方必须考虑对手的各种可能的行动方案，并力图选取对自己最为有利或最为合理的方案，比如日常生活中的下棋，打牌等。博弈论就是研究博弈行为中斗争各方是否存在着最合理的行为方案，以及如何找到这个合理的行为方案的数学理论和方法。

应用

应用1：Leetcode.486

题目

486. 预测赢家

方法一：动态规划（自底向上）

解题思路

设 $d p [i] [j]$ 表示从子数组 $n u m s [i], \dots, n u m s [j]$ 中做选择，当前玩家与另一个玩家的分数差值的最大值。

同时，我们假设数组 $n u m s$ 的长度为 $n$ ，因为两位选手是轮流选择的，我们只关心最终的状态，也就是 $d p [0] [n - 1]$ 的状态，所以，我们只需要通过状态转移记录每次选择的方案就行了。

$d p [0] [n - 1]$ 对应的状态，就是数组 $n u m s$ 的初始状态，即对应先手玩家的分数。

因此，当所有的状态枚举完了之后，如果 $d p [0] [n - 1]$ 的值大于零，那么当前玩家（先手的玩家）的分数大于另一个玩家的得分，则先手赢，否则，后手赢。

边界条件

显然， $i$ , $j$ 需要满足：

\begin{aligned} 0 \leq i \leq n - 1 \\ 0 \leq j \leq n - 1 \end{aligned}

并且，当 $i = j$ 时，即子数组的长度为 $1$ 时，当前玩家只能选择这个数字，两人的分数差值的最大值就是当前的数字，即

d p [i] [i] = n u m s [i], 0 \leq i \leq n - 1

也就是说，如果只有一个数字，先手的玩家始终会成为赢家。

状态转移

假设子数组中的元素大于等于两个时，那么，状态 $d p [i] [j]$ 对应的子数组中的元素可以表示为：

n u m s [i], n u m s [i + 1], \dots, n u m s [j - 1], n u m s [j]

此时，对于当前玩家，他有两种选择，他可以选择 $n u m s [i]$ 或者 $n u m s [j]$ ：

如果当前玩家选择 $n u m s [i]$ ，那么，当前两者分数的差值，就是当前选择的数字 $n u m s [i]$ 减去上一个状态的差值，即 $n u m s [i] - d p [i + 1] [j]$ ;
如果当前玩家选择 $n u m s [j]$ ，那么，当前两者分数的差值，就是当前选择的数字 $n u m s [j]$ 减去上一个状态的差值，即 $n u m s [j] - d p [i] [j - 1]$ ;

在两种方案中，当前玩家一定会选择最优的方案，使得自己的分数最大化，即上述两种选择之中的最大值，因此，状态转移方程：

d p [i] [j] = max (n u m s [i] - d p [i + 1] [j], n u m s [j] - d p [i] [j - 1]), 0 \leq i < j \leq n - 1

这里，我们不用考虑某个位置是谁在做选择，因为每个位置，对应的玩家都会做最优选择。

我们只需要考虑最终状态状态 $d p [0] [n - 1]$ 就行了，因为只有先手的玩家会对应状态 $d p [0] [n - 1]$ 。

注意，枚举 $i$ 和 $j$ 的时候，需要注意枚举的方向，需要从边界条件（只有单个元素的时候）开始，依次增加子数组的长度。

代码实现

逆序枚举：

 class Solution {
    public boolean predictTheWinner(int[] nums) {
        int n = nums.length;
        int [][] dp = new int [n][n];
        for (int i = 0; i < n; i++) {
            dp[i][i] = nums[i];
        }
 
        for (int i = n - 2; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
            }
        }
        return dp[0][n - 1] >= 0;
    }
}

顺序枚举也是一样的，代码实现如下：

 class Solution {
    public boolean predictTheWinner(int[] nums) {
        int n = nums.length;
        int [][] dp = new int [n][n];
        for (int i = 0; i < n; i++) {
            dp[i][i] = nums[i];
        }
 
        for (int j = 1; j < n; j++) {
            for (int i = j - 1; i >= 0; i--) {
                dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
            }
        }
        return dp[0][n - 1] >= 0;
    }
}

枚举的方向并不重要，核心思想在于：从边界条件开始，依次顺序枚举完所有的子数组即可。

方法二：动态规划（自顶向下）

解题思路

这里我们利用分治的思想：通过定义一个带返回值的递归函数，将问题分解为子问题（子树），通过递归推导出答案。

这里，我们定义一个play(nums, left, right, memory)函数，表示当从子数组 $n u m s [l e f t]$ , $\dots$ , $n u m s [r i g h t]$ 中做选择时，当前玩家与另一个玩家的分数差值的最大值，其中， $m e m o r y$ 用于记录已经搜索过的结果，避免重复计算。

递归的终止条件就是子数组长度为零时，即 $l e f t > r i g h t$ ，两者分数的差值为零。

代码实现

 class Solution:
    def PredictTheWinner(self, nums: List[int]) -> bool:
        n = len(nums)
        memory = [ [None for _ in range(n) ]  for _ in range(n)]
        return self.play(nums, 0, n - 1, memory) >= 0
 
    def play(self, nums: List[int], left: int, right: int, memory: List[List[int]]) -> int:
        if left > right:
            return 0
 
        if memory[left][right] is not None:
            return memory[left][right]
 
        plan_a = nums[left] - self.play(nums, left + 1, right, memory)
        plan_b = nums[right] - self.play(nums, left, right - 1, memory)
 
        result = max(plan_a, plan_b)
        memory[left][right] = result
 
        return result

方法三：动态规划

解题思路

这里我们定一个了一个对象 $S c o r e$ ，它有两个属性 $f i r s t$ 、 $s e c o n d$ ，分别表示先手和后手玩家的分数，用于辅助记录状态转移过程。

设 $d p [i] [j]$ 表示从子数组 $n u m s [i], \dots, n u m s [j]$ 中做选择，两个玩家可以获取的分数的最大值，即：

$d p [i] [j] . f i r s t$ 表示先手玩家的最大分数；
$d p [i] [j] . s e c o n d$ 表示后手玩家的最大分数。

因此，当所有的状态枚举完了之后，如果 $d p [0] [n - 1] . f i r s t$ 的值大于 $d p [0] [n - 1] . s e c o n d$ ，则先手赢，否则，后手赢。

边界条件

显然， $i$ , $j$ 需要满足：

\begin{aligned} 0 \leq i \leq n - 1 \\ 0 \leq j \leq n - 1 \end{aligned}

并且，当 $i = j$ 时，即子数组的长度为 $1$ 时，先手玩家只能选择这个数字，那么先手玩家的分数就是 $n u m s [i]$ ，后手玩家的分数就是零，即

d p [i] [i] = S c o r e (n u m s [i], 0), 0 \leq i \leq n - 1

也就是说，如果只有一个数字，先手的玩家始终会成为赢家。

状态转移

假设子数组中的元素大于等于两个时，那么，状态 $d p [i] [j]$ 对应的子数组中的元素可以表示为：

n u m s [i], n u m s [i + 1], \dots, n u m s [j - 1], n u m s [j]

此时，对于这一轮选择，当前玩家就是先手玩家，他有两种选择，他可以选择 $n u m s [i]$ 或者 $n u m s [j]$ ：

如果当前玩家选择 $n u m s [i]$ ，那么：
- 他可以获取的大分数 $y_{1}$ ，就是上一个状态的他分数 $d p [i + 1] [j] . s e c o n d$ 加上当前的数字 $n u m s [i]$ ，即 $y_{1} = n u m s [i] + d p [i + 1] [j] . s e c o n d$ ；
- 另一个玩家的分数保持不变，即还是上一个状态的分数 $d p [i + 1] [j] . f i r s t$ 。
如果当前玩家选择 $n u m s [j]$ ，那么：
- 他可以获取的大分数 $y_{2}$ ，就是上一个状态的他分数 $d p [i] [j - 1] . s e c o n d$ 加上当前的数字 $n u m s [i]$ ，即 $y_{2} = n u m s [i] + d p [i] [j - 1] . s e c o n d$ ；
- 另一个玩家的分数保持不变，即还是上一个状态的分数 $d p [i] [j - 1] . f i r s t$ 。

因此，对于当前的这一轮选择，当前玩家一定会选择对自己有利的方案，即选择 $y_{1}$ 和 $y_{2}$ 较大的方案，那么

d p [i] [j] = {\begin{cases} S c o r e (n u m s [i] + d p [i + 1] [j] . s e c o n d, d p [i + 1] [j] . f i r s t), & y_{1} > y_{2} \\ S c o r e (n u m s [i] + d p [i] [j - 1] . s e c o n d, d p [i] [j - 1] . f i r s t), & y_{1} \leq y_{2} \end{cases}

注意，对于当前的这一轮选择，当前玩家就是先手玩家，显然，在上一轮他就是后手玩家。

代码实现

 class Score(object):
    def __init__(self, first: int = 0, second: int = 0):
        self.first = first  # 先手玩家获得的分数
        self.second = second  # 后手玩家获取的分数
 
    def diff(self):
        return self.first - self.second
 
 
class Solution:
    def PredictTheWinner(self, nums: List[int]) -> bool:
        n = len(nums)
        dp = [ [Score() for _ in range(n)]  for _ in range(n)]
 
        for i in range(n):
            dp[i][i] = Score(nums[i], 0)
 
        for i in range(n - 2, -1, -1):
            for j in range(i + 1, n):
                plan_a = nums[i] + dp[i + 1][j].second
                plan_b = nums[j] + dp[i][j - 1].second
                # 先手玩家选择对其有利的方案，后手玩家的分数不变，还是上一个状态的分数
                if plan_a > plan_b:
                    dp[i][j].first = plan_a
                    dp[i][j].second = dp[i + 1][j].first
                else:
                    dp[i][j].first = plan_b
                    dp[i][j].second = dp[i][j - 1].first
 
        return dp[0][n - 1].diff() >= 0

应用2：Leetcode.877

题目

877. 石子游戏

分析

这道题可以直接套用前面的结论，这里就不再重复分析了，我们直接给出代码实现。

另外，这道题可以通过数学结论，直接返回结果，即当数组长度为偶数时，先手玩家必获胜。由于数学解法不具有通用性，就不在此深入分析了。

感兴趣的话，可以参考力扣官方题解：石子游戏

代码实现

 class Solution:
    def stoneGame(self, piles: List[int]) -> bool:
        n = len(piles)
        dp = [ [0] * n for _ in range(n)]
        for i in range(n):
            dp[i][i] = piles[i]
        # 枚举所有的状态
        for i in range(n - 2, -1, -1):
            for j in range(i + 1, n):
                dp[i][j] = max(piles[i] - dp[i + 1][j], piles[j] - dp[i][j - 1])
        return dp[0][n - 1] >= 0

 class Score(object):
    def __init__(self, first: int = 0, second: int = 0):
        self.first = first  # 先手玩家获得的分数
        self.second = second  # 后手玩家获取的分数
 
    def diff(self):
        return self.first - self.second
 
class Solution:
    def stoneGame(self, piles: List[int]) -> bool:
        n = len(piles)
        dp = [ [Score() for _ in range(n)]  for _ in range(n)]
 
        for i in range(n):
            dp[i][i] = Score(piles[i], 0)
 
        for i in range(n - 2, -1, -1):
            for j in range(i + 1, n):
                plan_a = piles[i] + dp[i + 1][j].second
                plan_b = piles[j] + dp[i][j - 1].second
                # 先手玩家选择对其有利的方案，后手玩家的分数不变，还是上一个状态的分数
                if plan_a > plan_b:
                    dp[i][j].first = plan_a
                    dp[i][j].second = dp[i + 1][j].first
                else:
                    dp[i][j].first = plan_b
                    dp[i][j].second = dp[i][j - 1].first
 
        return dp[0][n - 1].diff() >= 0

参考：

本文作者：LARRY1024

本文链接：https://www.cnblogs.com/larry1024/p/17047356.html

posted @ 2023-01-12 17:39 LARRY1024 阅读(124) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称：LARRY1024 园龄：11年9个月粉丝：16 关注：3

昵称： LARRY1024
园龄： 11年9个月
粉丝： 16
关注： 3

+加关注

Talk is cheap, show|

2025年3月

日

一

二

三

四

五

六

LARRY1024

【动态规划】博弈问题

博弈问题

简介

应用

应用1：Leetcode.486

题目

方法一：动态规划（自底向上）

解题思路

边界条件

状态转移

代码实现

方法二：动态规划（自顶向下）

解题思路

代码实现

方法三：动态规划

解题思路

边界条件

状态转移

代码实现

应用2：Leetcode.877

题目

分析

代码实现

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

合集 (8)

随笔分类 (155)

随笔档案 (139)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	class Solution {
	public boolean predictTheWinner(int[] nums) {
	int n = nums.length;
	int [][] dp = new int [n][n];
	for (int i = 0; i < n; i++) {
	dp[i][i] = nums[i];
	}

	for (int i = n - 2; i >= 0; i--) {
	for (int j = i + 1; j < n; j++) {
	dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
	}
	}
	return dp[0][n - 1] >= 0;
	}
	}

	class Solution:
	def PredictTheWinner(self, nums: List[int]) -> bool:
	n = len(nums)
	memory = [ [None for _ in range(n) ] for _ in range(n)]
	return self.play(nums, 0, n - 1, memory) >= 0

	def play(self, nums: List[int], left: int, right: int, memory: List[List[int]]) -> int:
	if left > right:
	return 0

	if memory[left][right] is not None:
	return memory[left][right]

	plan_a = nums[left] - self.play(nums, left + 1, right, memory)
	plan_b = nums[right] - self.play(nums, left, right - 1, memory)

	result = max(plan_a, plan_b)
	memory[left][right] = result

	return result

	class Score(object):
	def __init__(self, first: int = 0, second: int = 0):
	self.first = first # 先手玩家获得的分数
	self.second = second # 后手玩家获取的分数

	def diff(self):
	return self.first - self.second


	class Solution:
	def PredictTheWinner(self, nums: List[int]) -> bool:
	n = len(nums)
	dp = [ [Score() for _ in range(n)] for _ in range(n)]

	for i in range(n):
	dp[i][i] = Score(nums[i], 0)

	for i in range(n - 2, -1, -1):
	for j in range(i + 1, n):
	plan_a = nums[i] + dp[i + 1][j].second
	plan_b = nums[j] + dp[i][j - 1].second
	# 先手玩家选择对其有利的方案，后手玩家的分数不变，还是上一个状态的分数
	if plan_a > plan_b:
	dp[i][j].first = plan_a
	dp[i][j].second = dp[i + 1][j].first
	else:
	dp[i][j].first = plan_b
	dp[i][j].second = dp[i][j - 1].first

	return dp[0][n - 1].diff() >= 0

	class Solution:
	def stoneGame(self, piles: List[int]) -> bool:
	n = len(piles)
	dp = [ [0] * n for _ in range(n)]
	for i in range(n):
	dp[i][i] = piles[i]
	# 枚举所有的状态
	for i in range(n - 2, -1, -1):
	for j in range(i + 1, n):
	dp[i][j] = max(piles[i] - dp[i + 1][j], piles[j] - dp[i][j - 1])
	return dp[0][n - 1] >= 0