【前缀和】【动态规划】：1000合并石头的最低成本

已于 2024-03-14 08:46:39 修改
阅读量443 收藏 2
点赞数 2
文章标签： c++ 算法 开发语言 前缀和 合并石头 动态规划 测试用例
于 2023-10-21 10:40:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/133958246
版权

本文涉及的基础知识点

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

LeetCode 1000合并石头的最低成本

有 n 堆石头排成一排，第 i 堆中有 stones[i] 块石头。
每次 移动 需要将 连续的 k 堆石头合并为一堆，而这次移动的成本为这 k 堆中石头的总数。
返回把所有石头合并成一堆的最低成本。如果无法合并成一堆，返回 -1 。
示例 1：
输入：stones = [3,2,4,1], K = 2
输出：20
解释：
从 [3, 2, 4, 1] 开始。
合并 [3, 2]，成本为 5，剩下 [5, 4, 1]。
合并 [4, 1]，成本为 5，剩下 [5, 5]。
合并 [5, 5]，成本为 10，剩下 [10]。
总成本 20，这是可能的最小值。
示例 2：
输入：stones = [3,2,4,1], K = 3
输出：-1
解释：任何合并操作后，都会剩下 2 堆，我们无法再进行合并。所以这项任务是不可能完成的。.
示例 3：
输入：stones = [3,5,1,2,6], K = 3
输出：25
解释：
从 [3, 5, 1, 2, 6] 开始。
合并 [5, 1, 2]，成本为 8，剩下 [3, 8, 6]。
合并 [3, 8, 6]，成本为 17，剩下 [17]。
总成本 25，这是可能的最小值。
提示：
n == stones.length
1 <= n <= 30
1 <= stones[i] <= 100
2 <= k <= 30

分析

dp[begin][end]记录stones[begin,end)合并后的最小得分。时间复杂度O(nnn)，状态数:n*n，转移状态时间复杂度O(n)。

状态转移

假定stones[begin,end)是由stone[begin,m)和stone[m,end)合并成的，m取值范围(begin,end)。stone[begin,m)简称左堆，stone[m,end)简称右堆。

左右两堆剩余石头数之和小于kdp[begin][end] = dp[begin][m]+dp[m][end]
左右两堆剩余石头数之和等于于kdp[begin][end] = dp[begin][m]+dp[m][end]+vPreSum[begin][end],石头发生了合并
左右两堆剩余石头数之和大于于k抛弃

左右两堆剩余石头数之和大于于k

抛弃左右两堆剩余石头数之和大于于k，也可以找到最优解。

最后一轮只有k个石头，故不会超过k
倒数第二轮只有2k-1个石头，假定其范围是[i0,j0)，倒数第二轮是[i1,j1)， 那么[i0,j0)会合并，这时两堆石头恰好是k，故不会超过k
……

剩余石头数

每次合并后，石头数减少k-1。所有石头数减1，再对k-1求求余，再加1。
注意：先判断石头数是否是1，不是直接返回-1。

代码

核心代码

class Solution {
public:
	int mergeStones(vector<int>& stones, int K) {
		m_c = stones.size();
		if (1 != RemainLen(m_c,K))
		{
			return -1;
		}
		vector<int> vPreSum = { 0 };
		for (const auto& n : stones)
		{
			vPreSum.emplace_back(n + vPreSum.back());
		}
		vector<vector<int>> dp(m_c,vector<int>(m_c+1));//dp[i][j] 表示合并stones[i,j)的最小成本
		for (int len = 2; len <= m_c; len++)
		{
			for (int begin = 0; begin + len <= m_c; begin++)
			{
				const int end = begin + len;
				int iMin = INT_MAX;
				for (int m = begin + 1; m < end; m++)
				{
					const int iAdd = RemainLen(m - begin, K) + RemainLen(end - m, K);
					if (iAdd > K)
					{
						continue;
					}
					int cur = dp[begin][m] + dp[m][end];
					iMin = min(iMin, cur);
				}
				
				if (1 == RemainLen(len, K))
				{
					iMin += vPreSum[end] - vPreSum[begin];
				}
				dp[begin][end] = iMin;
			}			
		}
		return dp.front().back();
	}
	int RemainLen(int len, int k)
	{
		return 1+(len - 1) % (k - 1);
	}
	int m_c;
};

测试代码

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]);
	}
}

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








int main()
{
	vector<int> stones = { 3,5,1,2,6 };
	int k = 3;
	int res = Solution().mergeStones(stones, k);
	Assert(25, res);

	stones = { 3,2,4,1 };
	 k = 2;
	 res = Solution().mergeStones(stones, k);
	Assert(20, res); 

	stones = { 1,2,3,4,5,6,7 };
	k = 3;
	res = Solution().mergeStones(stones, k);
	Assert(49, res);

	stones = { 1,2,3,4,5,6,7 };
	k = 4;
	res = Solution().mergeStones(stones, k);
	Assert(38, res);

	stones = { 1,2,3,4,5,6,7,8,9 };
	k = 5;
	res = Solution().mergeStones(stones, k);
	Assert(60, res);
	//
	stones = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
	k = 2;
	res = Solution().mergeStones(stones, k);
	Assert(135, res);

	stones = { 9,8,7,6,5,4,3,2,1 };
	k = 3;
	res = Solution().mergeStones(stones, k);
	Assert(87, res);

	stones = { 10,9,8,7,6,5,4,3,2,1 };
	k = 4;
	res = Solution().mergeStones(stones, k);
	Assert(91, res);

	//
	stones = { 5,8,7,6,5,12,13,14,4,3,2,1,2 };
	k = 4;
	res = Solution().mergeStones(stones, k);
	Assert(155, res);

	stones = { 2,8,7,6,5,12,13,14,4,3,2,1,2 };
	k = 5;
	res = Solution().mergeStones(stones, k);
	Assert(119, res);
	//CConsole::Out(res);
}

2024年3月14

转移方程优化：
只需要枚举合并后的第一堆石头，第一堆石头原始堆数len1只能是：1, 1+(k-1) ,1 + 2*(k-1) ⋯ \cdots ⋯
注意：len1 必须小于len

class Solution {
public:
	int mergeStones(vector<int>& stones, int K) {
		m_c = stones.size();
		if (1 != RemainLen(m_c, K))
		{
			return -1;
		}
		vector<int> vPreSum = { 0 };
		for (const auto& n : stones)
		{
			vPreSum.emplace_back(n + vPreSum.back());
		}
		vector<vector<int>> dp(m_c, vector<int>(m_c + 1));//dp[i][j] 表示合并stones[i,j)的最小成本
		for (int len = 2; len <= m_c; len++)
		{
			for (int begin =0 ; begin+len <= m_c ;begin++)
			{
				const int end = begin + len;
				int iMin = INT_MAX;
				for (int len1 = 1; len1 < len; len1 += (K - 1))
				{
					iMin = min(iMin, dp[begin][begin + len1] + dp[begin + len1][end]);
				}
				if (1 == RemainLen(len, K))
				{
					iMin += vPreSum[end] - vPreSum[begin];
				}
				dp[begin][end] = iMin;
			}
		}
		return dp.front().back();
	}
	int RemainLen(int len, int k)
	{
		return 1 + (len - 1) % (k - 1);
	}
	int m_c;
};

旧版代码

 template<class T>
 void MinSelf(T* seft, const T& other)
 {
	 *seft = min(*seft, other);
 }
class Solution {
 public:
	 int mergeStones(vector<int>& stones, int k) {
		 m_k = k;
		 m_c = stones.size();
		 m_dp.assign(m_c + 1, vector<vector<int>>(m_c, vector<int>(k + 1, 1000 * 1000 * 100)));

		 vector<int> vPreSum(1);
		 for (const auto& stone : stones)
		 {
			 vPreSum.push_back(vPreSum.back() + stone);
		 }
		 for (int pos = 0; pos + 1 - 1 < m_c; pos++)
		 {
			 m_dp[1][pos][1] = 0;
		 }
		 for (int len = 2; len <= m_c; len++)
		 {
			 for (int pos = 0; pos+len <= m_c; pos++)
			 {
				 //int iEnd = pos + len - 1;
				 for (int iHeapNum = 2; iHeapNum <= k; iHeapNum++)
				 {
					 for (int iPreLen = 1; iPreLen < len; iPreLen += k - 1)
					 {
						 MinSelf(&m_dp[len][pos][iHeapNum], m_dp[iPreLen][pos][1] + m_dp[len - iPreLen][pos + iPreLen][iHeapNum - 1]);
					 }
				 }
				 m_dp[len][pos][1] = m_dp[len][pos][k] + vPreSum[pos + len] - vPreSum[pos];
			 }			
		 }		

		 return (m_dp[m_c][0][1] >= 1000 * 1000 * 100) ? -1 : m_dp[m_c][0][1];
	 }
	 
	 int m_k;
	 int m_c;
	 vector<vector<vector<int>>> m_dp;
 };

旧版代码2

 template<class T>
 void MinSelf(T* seft, const T& other)
 {
	 *seft = min(*seft, other);
 }

 class Solution {
 public:
	 int mergeStones(vector<int>& stones, int k) {
		 m_k = k;
		 m_c = stones.size();
		 m_dp.assign(m_c + 1, vector<int>(m_c, ( 1000 * 1000 * 100)));

		 if ((m_c-1) % (k - 1) != 0)
		 {
			 return -1;
		 }

		 vector<int> vPreSum(1);
		 for (const auto& stone : stones)
		 {
			 vPreSum.push_back(vPreSum.back() + stone);
		 }
		 for (int pos = 0; pos + 1 - 1 < m_c; pos++)
		 {
			 m_dp[1][pos] = 0;
		 }
		 for (int len = 2; len <= m_c; len++)
		 {
			 for (int pos = 0; pos+len <= m_c; pos++)
			 {
				 for (int iPreLen = 1; iPreLen < len; iPreLen += k - 1)
				 {
					 MinSelf(&m_dp[len][pos], m_dp[iPreLen][pos] + m_dp[len - iPreLen][pos + iPreLen]);
				 }
				 if ((len-1) % (k - 1) == 0)
				 {
					 m_dp[len][pos] +=  vPreSum[pos + len] - vPreSum[pos];
				 }
			 }			
		 }		

		 return (m_dp[m_c][0] >= 1000 * 1000 * 100) ? -1 : m_dp[m_c][0];
	 }
	 
	 int m_k;
	 int m_c;
	 vector<vector<int>> m_dp;
 };

旧版代码三

class Solution {
public:
int mergeStones(vector& stones, int k) {
m_c = stones.size();
if (0 != (m_c - 1) % (k-1))
{
return -1;
}
vector vPreSum(1);
for (const auto& n : stones)
{
vPreSum.emplace_back(vPreSum.back() + n);
}
vector<vector> vLenBegin(m_c + 1, vector(m_c));
for (int len = k; len <= m_c; len++)
{
for (int begin = 0; begin + len - 1 < m_c; begin++)
{
int iMaxPreScore = INT_MAX;
for (int lLen = 1; lLen < len; lLen += (k - 1))
{
int rLen = len - lLen;
iMaxPreScore = min(iMaxPreScore, vLenBegin[lLen][begin] + vLenBegin[rLen][begin + lLen]);
}
if (0 == (len - 1) % (k - 1))
{
iMaxPreScore += vPreSum[begin + len] - vPreSum[begin];
}
vLenBegin[len][begin] = iMaxPreScore ;
}
}
return vLenBegin.back().front();
}
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/C++实现石子合并
12-26
在一个圆形操场上的问题 算法分析经典设计，石子合并课程设计 并外加代码 一套齐全
洛谷P1314 聪明的质监员 二分答案
qq_29904713的博客
03-21 727
题目描述 小T 是一名质量监督员，最近负责检验一批矿产的质量。这批矿产共有 n 个矿石，从 1到n 逐一编号，每个矿石都有自己的重量 wi​ 以及价值vi​ 。检验矿产的流程是： 1 、给定m个区间[Li,Ri]； 2 、选出一个参数W； 3 、对于一个区间[Li,Ri]，计算矿石在这个区间上的检验值Yi​： 这批矿产的检验结果Y 为各个区间的检验值之和。即：Y1+Y2...+Ym ...
C++动态规划经典案例解析之合并石子
y6123236的专栏
08-24 2783
区间类型问题，指求一个数列中某一段区间的值，包括求和、最值等简单或复杂问题。此类问题也适用于动态规划思想。如前缀和就是极简单的区间问题。现给定区间信息[3,6]，求区间内所有数字相加结果。即求如下图位置数字之和。区间至少包括2个属性，起始端和结束端，求和范围包含左端和右端数字。累加数组中0~6区间的值s1。累加数组中0~2区间的值s2。将s1中的值减去s2中的值。得到最终结果。如果对任意区间的求解要求较频繁，会存在大量的重复计算。如分别求区间[2,5]和[1,5]之和时，分析可知区间。
Bailian4101 晶矿的个数【DFS】
海岛Blog
09-04 601
4101:晶矿的个数 总时间限制: 1000ms 内存限制: 65536kB 描述 在某个区域发现了一些晶矿，已经探明这些晶矿总共有分为两类，为红晶矿和黑晶矿。现在要统计该区域内红晶矿和黑晶矿的个数。假设可以用二维地图m[][]来描述该区域，若m[i][j]为#表示该地点是非晶矿地点，若m[i][j]为r表示该地点是红晶矿地点，若m[i][j]为b表示该地点是黑晶矿地点。一个晶矿是由相同类型的并且上下左右相通的晶矿点组成。现在给你该区域的地图，求红晶矿和黑晶矿的个数。 输入 第一行为k，表示有k组测试输入。
【leetcode 4.4每日一题】1000.合并石头的最低成本 图解及代码（C++）
霜-哀的博客
04-04 306
leetcode每日一题系列，图解了动态规划算法的一种题型
动态规划石头合并问题算法C++ 代码
11-07
根据给定文件的信息，本文将围绕“动态规划石头合并问题算法C++代码”这一主题进行深入探讨，并结合标题、描述及部分代码内容，详细介绍该问题的背景、算法原理及其在C++中的实现方法。 ### 一、问题背景 在算法...
C++算法：前缀和基础
10-15
preSum[i]记录子数组[0,i)的和。比如：nums = {1,2,3,4},则preSum = {0,1,3,6,10}。通过preSum，我们可以求任意nums的子数组和。子数组[i,j)等于子数组[0,j)减去[0,i)，也就是子数组[i,j)的和等于preSum[j] – ...
前缀和详解01.zip
03-31
2. **区间查询**：在动态查询某个区间元素之和时，如果预先计算好前缀和，可以在线性时间内完成查询。 3. **求最大/最小值**：配合单调栈或单调队列，可以找到数组中连续子序列的最大或最小和。 4. **区间加减操作**...
前缀和详解22.zip
03-31
前缀和是计算机科学和算法领域中的一个基本概念，尤其在数组处理和动态规划问题中广泛应用。它是指对一个数组（或序列）的所有连续子数组求和，然后存储这些和值的结果。通过前缀和，我们可以快速地查询任意区间内的...
前缀和详解21.zip
03-31
例如，在处理动态变化的数据集时，可以利用前缀和来实现在线求和，即在插入、删除或更新数组元素后快速得到新的和。此外，它还常用于解决区间查询、异或操作、树状数组等问题。 在编程竞赛或面试中，前缀和常常出现...
不能移动的石子合并问题（动态规划/C++实现）
10-29
做如下两个模型的石子合并，如下模型石子都不能移动出列，且合并都仅发生在相邻两堆石子中： （1）第一个模型：一行排列且相邻合并 有n堆石子形成一行(a1,a2,…,an，ai为第i堆石子个数)，相邻两堆可合并，合并的分值为新堆的石子数。求合并为一堆的最低得分和最高得分。 （2）第二个模型：一圈排列且相邻合并 有n堆石子形成首位相连的一个环形(a1,a2,…,an，ai为第i堆石子个数，an和a1相邻)，相邻两堆可合并，合并的分值为新堆的石子数。求合并为一堆的最低得分和最高得分。 例如4堆石子，每堆石子个数：9 4 4 5 若排成一行，最小分值：(4+4)+(8+5)+(9+13)=43，最大分值：(9+4)+(13+4)+(17+5)=52。 若排成圈状，最小分值：(4+4)+(8+5)+(9+13)=43，最大分值：(9+5)+(14+4)+(18+4)=54。 此题以第一模型的最低得分为例，很多同学想着采用总是从最小的相邻两堆下手的思想，最后获得的也就是最低得分。但这个贪心策略是不对的。 如下反例： 石子：9 4 6 1 5 贪心策略： 9 4 6 6 6 9 10 6 10 9 16 16 25 25 得分共计：6+10+16+25=57 但9 4 6 1 5 若如下方式合并： 13 6 1 5 13 13 6 6 6 13 12 12 25 25 13+6+12+25=56 或 9 4 6 6 6 9 4 12 12 13 12 13 25 25 6+12+13+25=56 后两种方式合并出的56都比贪心策略的57来的更低，因为总选择最小的相邻两堆去合并，并不能保证后续每步都可以最小，也许这轮最小导致后续几轮分值较大。 Input 两行。第一行n，第二行a1 a2 … an，每个ai(1<=i<=n)表示第i堆石子的个数，n<=100 Output 两行。第一行是第一个模型的最低得分和最高得分，中间空格相连，第二行是第二个模型的最低得分和最高得分，中间空格相连。 Sample Input 4 9 4 4 5 Sample Output 43 52 43 54 Hint 第一个石子合并模型,和书上3.1节的矩阵连乘问题类似. 假设m[i,j]为合并石子ai…aj, 1≤i≤j≤n，所得到的最小得分，若没有“合并”这个动作，则为0。原问题所求的合并最小值即为m[1,n]。 递推公式如下,其中min表示求最小,sum表示求和. (1) m[i,j]=0, if i=j (2) m[i,j]=min{m[i,k]+m[k+1][j] | for i<=k<j} + sum{a(t) | for i<=t<=j}, if i<j 至于求最大值完全同理. 至于第二个石子合并的环行模型,完全可以转化为第一个模型来求解.
算法设计——石子合并问题
12-21
算法设计题（15分） 在一个直线跑道上摆放着一行共 堆石子。现要将石子有次序地合并成一堆。规定每次只能选相邻的两堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。试设计一个算法，计算出将 堆石子合并成一堆的最小得分。
190、【动态规划】AcWing ——282. 石子合并（C++版本）
STAR GAME
03-04 599
其中(i < k < j)，k为区间的分割点，x为下标i到j之间的总代价和。因为题中要求的就是每次加上合并后的结果，因此加上这段区间之和。dp[i][j] = MAX（i ≠ j），因为求最小值，所以让其取最大。dp[i][i] = 0，区间长度为1时，结果为0.从上至下，从左至右，区间长度有小到大一个一个遍历。进而得出整个大区间上最优解的dp算法。从下标i到下标j之间，最小的代价和。，求解一段区间上的最优解。
石子合并(递归）
2301_79534589的博客
06-15 269
1、选择一种合并石子的方案，使得做 n−1 次合并得分总和最大。2、选择一种合并石子的方案，使得做 n−1 次合并得分总和最小。输入第一行一个整数 n ，表示有 n 堆石子。第二行 n 个整数，表示每堆石子的数量。对于 100的数据，有1≤n≤200。第一行为合并得分总和最小值，第二行为合并得分总和最大值。
【动态规划】石子合并
xuhaoran1的博客
01-14 709
【动态规划】石子合并
C++ 动态规划 区间DP 石子合并
fucheng的博客
02-06 749
C++ 动态规划 区间DP 石子合并
C++题目_石子合并
最新发布
wjl_8616的博客
07-19 300
每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并时由于选择的顺序不同，合并的总代价也不相同。第二步合4 4 ，此时石子为 8 2 5，此时代价为4+（4+4）=12。第三步合2 5 ，此时石子为 8 7，此时代价为12+（2+5）=19。第三步合8 7 ，此时石子为 15，此时代价为19+（8+7）=34。第一步合1 3 ，此时石子为 4 4 2 5，此时代价为1+3=4。问题是:找出一种合理的方法，使总的代价最小，输出最小代价。设有NN堆石子排成一排，其编号为1，2，3，…
石子合并问题（C++语言）
2301_79497461的博客
12-14 683
【代码】石子合并问题（C++语言）
石子合并问题（动态规划）
qq_56101688的博客
04-12 918
如果有n堆石子，需要n-1次合并，可用k进行分隔，分为第1到第k堆和第k+1到第n堆，（k从1取到n-1），两部分分别求合并费用，k取使两部分的合并费用总和最小的那个值，最后再加上所有石子数量总和，即为整体的合并费用。在一条直线上有n堆石子，每堆有一定的数量，每次可以将两堆相邻的石子合并，合并后放在两堆的中间位置，合并的费用为两堆石子的总数。如果有三堆石子，需要两次合并，费用为第1堆和第2堆合并以及第2堆和第3堆合并费用中的较小值，加上三堆石子数量。//dp[i][j]表示从第i堆到第j堆合并的费用。
算法集合：前缀和、动态规划与数据结构解析
"该资源为一个关于算法总结的PPT，涵盖了多种常见算法，包括前缀和、查分、单调栈、并查集、滑动窗口、动态规划、二分查找、字典树、树和二叉树的遍历、深度遍历和剪枝、二维表广度遍历、图的BFS、广度遍历和拓扑...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值