【C++ 博弈论 动态规划】1563 石子游戏 V|2087

本文涉及知识点

动态规划汇总
数学

LeetCoce:1563 石子游戏 V

几块石子 排成一行 ，每块石子都有一个关联值，关联值为整数，由数组 stoneValue 给出。
游戏中的每一轮：Alice 会将这行石子分成两个 非空行（即，左侧行和右侧行）；Bob 负责计算每一行的值，即此行中所有石子的值的总和。Bob 会丢弃值最大的行，Alice 的得分为剩下那行的值（每轮累加）。如果两行的值相等，Bob 让 Alice 决定丢弃哪一行。下一轮从剩下的那一行开始。
只 剩下一块石子 时，游戏结束。Alice 的分数最初为 0 。
返回 Alice 能够获得的最大分数 。
示例 1：
输入：stoneValue = [6,2,3,4,5,5]
输出：18
解释：在第一轮中，Alice 将行划分为 [6，2，3]，[4，5，5] 。左行的值是 11 ，右行的值是 14 。Bob 丢弃了右行，Alice 的分数现在是 11 。
在第二轮中，Alice 将行分成 [6]，[2，3] 。这一次 Bob 扔掉了左行，Alice 的分数变成了 16（11 + 5）。
最后一轮 Alice 只能将行分成 [2]，[3] 。Bob 扔掉右行，Alice 的分数现在是 18（16 + 2）。游戏结束，因为这行只剩下一块石头了。
示例 2：
输入：stoneValue = [7,7,7,7,7,7,7]
输出：28
示例 3：
输入：stoneValue = [4]
输出：0
提示：
1 <= stoneValue.length <= 500
1 <= stoneValue[i] <= 10⁶

动态规划

原理

石头数相等，和大的不一定更优。比如：{1,19}劣于{8,8}。
n堆石头在右边增加一堆后，不一定更优。比如：{16,1,8,8} $\to$ {8,8} $\to$ {8} 总共24分。
{16,1,8,8,2} $\to$ {16,1} $\to$ {1} 总共17 分。

动态规划的状态表示

dp[i][j] 表示stonevalue[i,j]的最大得分
状态数:O(nn)，故空间复杂度:O(nn)

动态规划的转移方程

如果暴力转移，总时间复杂度是O(n³)。
dp2[i][j] = $ma{x}_{m:i}^j$(dp[i][m]+sum[i,m])
dp3[i][j=]$ma{x}_{m:j}^i$(dp[m][j]+sum[m,j])
转移dp[i][j]时，分三种情况：
左边小于右边：通过dp2转移。
两者相等，直接计算。
左边大于右边，通过dp3转移。

动态规划的初始值

全部为0。

动态规划的填表顺序

第一层循环，枚举长度len，从2到大。第二层循环枚举i。

动态规划的返回值

dp[0].back()

博弈论 动态规划

动态规划的状态表示

dp[i][j]表示 stones[i…j]能获取的最大分数。
dp2[i][j]表示dp[i…x]+stone[i…x]之和的最大值, x$\in [i,j]。dp3[i][j]表示dp[x...j]+stone[x...j]之和的最大值x$\in[i,j]。
空间复杂度：O(nn)

动态规划的转移方程

stones[i…x] <= stones[x+1,j] x的最大解为x1
stones[i…x-1] >= stones[x,j]，x的最小解为x2
dp[i][j] = max(dp1[i][x1],dp2[x2][j])
更新后dp后，马上更新dp1,dp2。dp1[i][j] = max(dp1[i][j-1],stones[i…j]之和+dp[i][j])。
时间复杂度：O(nn)

动态规划的初始值

dp dp1,dp2全为0。

动态规划的填报顺序

len = 2 To n
i=0 To n-1
j = i+len-1

动态规划的返回值

dp[0]. back

代码

核心代码

`
``cpp
class Solution{
public:
int stoneGameV(vector&stoneValue) {
m_c = stoneValue.size();
vector <vector> dp(m_c, vector(m_c)), dp2(m_c, vector(m_c)), dp3(m_c, vector(m_c));
for (int i = 0; i < m_c; i++)
{
dp2[i][i] = dp3[i][i] = stoneValue[i];
}
for (int len = 2; len <= m_c; len++)
{
int leftSum = 0;
int totalSum = std::accumulate(stoneValue.begin(), stoneValue.begin() + len,0);
for (int i = 0,i1=0; i + len <= m_c; i++)
{更新dp leftSum = stone[i,i1)之和 totalSum= stone[i,j]之和
const int j = i + len - 1;
if (i1 < i)
{
i1++;
}
while ((leftSum + stoneValue[i1]) * 2 < totalSum)
{
leftSum += stoneValue[i1++];
}
auto& cur = dp[i][j];
if (i1-1 >= i )
{
cur = dp2[i][i1-1];
}
int j1 = i1;
if ((leftSum + stoneValue[i1]) * 2 == totalSum)
{
cur = max(cur, dp[i][i1]+ totalSum/2);
cur = max(cur, dp[i1 + 1][j] + totalSum / 2);
j1++;
}
if (j >= j1+1)
{
cur = max(cur, dp3[j1 + 1][j]);
}
//更新dp2
dp2[i][j] = max(dp2[i][j-1], cur + totalSum);
//更新dp3
dp3[i][j] = max(dp3[i+1][j],cur + totalSum);
if (i1 > i)
{
leftSum -= stoneValue[i];
}
totalSum -= stoneValue[i];
if (i + len < m_c)
{
totalSum += stoneValue[i + len];
}
}
}
return dp[0].back();
}
int m_c;
};

## 测试用例

```cpp
template<class T>
void Assert(const T& t1, const T& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}

}

int main()
{	
	vector<int> stoneValue;
	{
		Solution sln;
		stoneValue = { 4 };
		auto res = sln.stoneGameV(stoneValue);
		Assert(res, 0);
	}
	{
		Solution sln;
		stoneValue = { 2,1,1 };
		auto res = sln.stoneGameV(stoneValue);
		Assert(res, 3);
	}
	{
		Solution sln;
		stoneValue = { 7,7,7 };
		auto res = sln.stoneGameV(stoneValue);
		Assert(res, 7);
	}
	{
		Solution sln;
		stoneValue = { 7,7,7,7,7,7,7 };
		auto res = sln.stoneGameV(stoneValue);
		Assert(res, 28);
	}
	
	{
		Solution sln;
		stoneValue = { 6, 2, 3, 4, 5, 5 };
		auto res = sln.stoneGameV(stoneValue);
		Assert(res, 18);
	}
	{
		Solution sln;
		stoneValue = { 98,77,24,49,6,12,2,44,51,96 };
		auto res = sln.stoneGameV(stoneValue);
		Assert(res, 330);
	}
}

2023年2月

class Solution {
public:
int stoneGameV(const vector& stoneValue) {
m_stoneValue = stoneValue;
m_c = m_stoneValue.size();
m_vSums.push_back(0);
for (int i = 0; i < m_c; i++)
{
m_vSums.push_back(m_vSums[i] + stoneValue[i]);
}
m_vMaxValue.assign(m_c, vector(m_c,-1));
return dfs(0, m_c - 1);
}
int dfs(const int iBegin, const int iEnd)
{
if (-1 != m_vMaxValue[iBegin][iEnd])
{
return m_vMaxValue[iBegin][iEnd];
}
if (iBegin == iEnd)
{
return m_vMaxValue[iBegin][iEnd] = 0;
}
int iTotal = m_vSums[iEnd + 1] - m_vSums[iBegin];
int iLeftSumMul2SumTotal = -iTotal;
int iMaxValue = 0;
for (int i = iBegin; i < iEnd; i++)
{
iLeftSumMul2SumTotal += m_stoneValue[i] * 2;
const int iLeftAdd = m_vSums[i + 1] - m_vSums[iBegin];
const int iRightAdd = m_vSums[iEnd + 1] - m_vSums[i+1];
if (iLeftSumMul2SumTotal <= 0)
{
iMaxValue = max(iMaxValue, dfs(iBegin, i) + iLeftAdd );
}
if ( iLeftSumMul2SumTotal >= 0)
{
iMaxValue = max(iMaxValue, dfs(i + 1, iEnd) + iRightAdd);
}
}
return m_vMaxValue[iBegin][iEnd] = iMaxValue;
}
int m_c;
vector m_vSums;
std::vector<vector> m_vMaxValue;
vector m_stoneValue;
};

2023年7月

class Solution {
public:
int stoneGameV(vector& stoneValue) {
m_c = stoneValue.size();
vector<vector> vLeftRight(m_c, vector(m_c + 1));//左闭右开
vector<vector> vLeftPre(m_c, vector(m_c )), vRightPre(m_c, vector(m_c));//左闭右闭
for (int i = 0; i < m_c; i++)
{
vLeftPre[i][i] = vRightPre[i][i] = stoneValue[i];
}
for (int left = m_c-1 ; left >=0 ; left–)
{
int i = left ;
int iLeftSum = 0;//记录[left,i)总石头数量
int iSum = stoneValue[left];//记录[left,right)的总石头数量
for (int right = left + 2; right <= m_c; right++)
{
iSum += stoneValue[right-1];
//确保[left,i)的石头数小于等于[i,right) [i,right)不为空 的前提下，i的最大值
while ((i < right) && ((iLeftSum + stoneValue[i]) * 2 <= iSum))
{
iLeftSum += stoneValue[i];
i++;
}
if (iLeftSum * 2 == iSum)
{
vLeftRight[left][right] = max( vLeftPre[left][i - 1], vRightPre[i][right - 1]);
}
else
{
const int iRightI = i + 1;
vLeftRight[left][right] = max((i == left ) ? 0 : vLeftPre[left][i - 1], (iRightI >= right) ? 0 : vRightPre[iRightI][right - 1]);
}
vLeftPre[left][right - 1] = max(vLeftRight[left][right]+iSum, vLeftPre[left][right - 2]);
vRightPre[left][right-1] = max(vLeftRight[left][right] +iSum, (0==left)?0:vRightPre[left+1][right - 1]);
}
}
return vLeftRight.front().back();
}
int m_c;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关

下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 **C+

+17**
如无特殊说明，本算法用**C++**实现。