C++前缀和算法的应用：石头游戏 VIII 原理源码测试用例

news2025/1/14 19:45:29

本文涉及的基础知识点

C++算法：前缀和、前缀乘积、前缀异或的原理、源码及测试用例包括课程视频

题目

Alice 和 Bob 玩一个游戏，两人轮流操作， Alice 先手。
总共有 n 个石子排成一行。轮到某个玩家的回合时，如果石子的数目大于 1 ，他将执行以下操作：
选择一个整数 x > 1 ，并且移除最左边的 x 个石子。
将移除的石子价值之和累加到该玩家的分数中。
将一个新的石子放在最左边，且新石子的值为被移除石子值之和。
当只剩下一个石子时，游戏结束。
Alice 和 Bob 的分数之差为 (Alice 的分数 - Bob 的分数) 。 Alice 的目标是最大化分数差，Bob 的目标是最小化分数差。
给你一个长度为 n 的整数数组 stones ，其中 stones[i] 是从左边起第 i 个石子的价值。请你返回在双方都采用最优策略的情况下，Alice 和 Bob 的分数之差。
示例 1：
输入：stones = [-1,2,-3,4,-5]
输出：5
解释：

Alice 移除最左边的 4 个石子，得分增加 (-1) + 2 + (-3) + 4 = 2 ，并且将一个价值为 2 的石子放在最左边。stones = [2,-5] 。
Bob 移除最左边的 2 个石子，得分增加 2 + (-5) = -3 ，并且将一个价值为 -3 的石子放在最左边。stones = [-3] 。
两者分数之差为 2 - (-3) = 5 。
示例 2：
输入：stones = [7,-6,5,10,5,-2,-6]
输出：13
解释：
Alice 移除所有石子，得分增加 7 + (-6) + 5 + 10 + 5 + (-2) + (-6) = 13 ，并且将一个价值为 13 的石子放在最左边。stones = [13] 。
两者分数之差为 13 - 0 = 13 。
示例 3：
输入：stones = [-10,-12]
输出：-22
解释：
Alice 只有一种操作，就是移除所有石子。得分增加 (-10) + (-12) = -22 ，并且将一个价值为 -22 的石子放在最左边。stones = [-22] 。
两者分数之差为 (-22) - 0 = -22 。
参数范围：
n == stones.length
2 <= n <= 105
-104 <= stones[i] <= 104

分析

思路

dp[i]表示剩余i个石头时，(先手方分数-后手方分数)的最大值。计算dp[i]时，假定移除石头后，还剩j个,也就是总共（包括之前移除）移除m_c-j个。至少移除一个旧石头，故j的取值范围[0,i) 。cur = stones[0,m_c-j)个石头的价值和 - dp[j]。dp[i]等于cur的最大值。

x > 1

初始状态下，只能移除2个，不能移除1个。
非初始状态下，由于必定会移除新石头，所以移除一个旧石头就可以了。
也就是dp[m_c]时m_c-j不能等于1，也就是j不能m_c-1。j无此限制的取值范围是[0,m_c)，加上此限制后就变成[0,m_c-1),即i < m_c-1

注意

题意：包括新石头，只剩一个石头的时候结束。我的理解：不包括新石头，没石头的时候结束。初始状态外，一定有新石头，所以两种等价。初始状态，且石头大于1时，两者等价，都是未结束。一个石头，两者不等价。但本题石头数>=2。所以在本题范围内等价。

怀疑

这个题目可能出错了，可能是不放新石头。这样需要技巧合并i。

代码

错误代码

错误原因：忽略了x>1。
class Solution {
public:
int stoneGameVIII(vector& stones) {
m_c = stones.size();
vector dp(m_c + 1);//dp[i]表示剩余i个石头时，(先手方分数-后手方分数)的最大值
//计算dp[i]时，假定移除石头后，还剩j个,也就是移除m_c-j个
// cur = stones[0,m_c-j)个石头的价值和 - dp[j]
vector vSum = { 0 };
for (const auto& n : stones)
{
vSum.emplace_back(n + vSum.back());
}
int iMax = vSum[m_c - 0]-dp[0];
for (int i = 1; i <= m_c; i++)
{
dp[i] = iMax;
iMax = max(iMax, vSum[m_c - i] - dp[i]);
}
return dp.back();
}
int m_c;
};

修正缺陷后

解决方法

class Solution {
public:
	int stoneGameVIII(vector<int>& stones) {
		m_c = stones.size();
		//dp[i]表示剩余i个石头时，(先手方分数-后手方分数)的最大值
		m_dp.resize(m_c + 1);
		//计算dp[i]时，假定移除石头后，还剩j个,也就是移除m_c-j个
		// j的取值范围[0,i) 且m_c-j>1
		// cur = stones[0,m_c-j)个石头的价值和 - dp[j]
		vector<int> vSum = { 0 };
		for (const auto& n : stones)
		{
			vSum.emplace_back(n + vSum.back());
		}
		int iMax = vSum[m_c - 0]-m_dp[0];
		for (int i = 1; i <= m_c; i++)
		{
			m_dp[i] = iMax;
			if (m_c - i > 1)
			{
				iMax = max(iMax, vSum[m_c - i] - m_dp[i]);
			}
		}
		return m_dp.back();
	}
	int m_c;
	vector<int> m_dp;//dp[i]表示剩余i个石头时，(先手方分数-后手方分数)的最大值
};

测试用例

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

template
void Assert(const T& t1, const T& t2)
{
assert(t1 == t2);
}

int main()
{
Solution slu;
vector stones;
int res = 0;
stones = { -1, 2, -3, 4, -5, 6 };
res = slu.stoneGameVIII(stones);
Assert(3, res);
Assert(vector{0, 3, 3, 3, 3, 3, 3}, slu.m_dp);
stones = { -3,-5,3 };
res = slu.stoneGameVIII(stones);
Assert(-3, res);
Assert(vector{0, -5,-3,-3}, slu.m_dp);
stones = { -1, 2, -3, 4, -5 };
res = slu.stoneGameVIII(stones);
Assert(5, res);
Assert(vector{0, -3, 5, 5, 5, 5}, slu.m_dp);
stones = { -10,-12 };
res = slu.stoneGameVIII(stones);
Assert(-22, res);
Assert(vector{0, -22,-22}, slu.m_dp);

//CConsole::Out(res);

}

2023年2月旧代码

class Solution {
public:
int stoneGameVIII(vector& stones) {
m_c = stones.size();
vector preSum;
int iSum = 0;
for (const auto& s : stones)
{
iSum += s;
preSum.push_back(iSum);
}
vector dp(m_c);
dp.back() = preSum.back();
for (int i = m_c - 2; i >= 1; i–)
{
dp[i] = max(dp[i + 1], preSum[i] - dp[i + 1]);
}
return dp[1];
}
int m_c;
};