[动态规划] 石子归并

题目描述

现摆一排 N 堆石子（N ≤ 100），要将石子有次序地合并成一堆。规定每次只能选取相邻的两堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。编一程序，由文件读入堆数 N 及每堆的石子数（ ≤ 20）。选择一种合并石子的方案，使所做 N－1 次合并，得分的总和最小。

关于输入

第一行为石子堆数 N；第二行为每堆石子数，数字之间用一个空格分隔。

关于输出

最小的得分总和。

例子输入

21
17 2 9 20 9 5 2 15 14 20 19 19 1 9 8 8 9 14 9 4 8

例子输出

936

提示信息

求解不当，可能超时。

解题分析

显然，对于本题来说，如果使用暴力的方法去遍历只会导致超时。为了能有更有效的方法去解决本题，很自然地会去考虑动态规划。实际上，本题也是一个典型的区间动态规划的问题。

可以考虑dp数组dp[i][j]，dp[i][j]表示从第i堆石头到第j堆石头进行归并后得到的最小的总分。在这一步中，我们划分了一个区间[i,j]，接下来，我们只需要考虑在这个区间下如何去更新我们的dp数组即可。

显然，我们可以用一个循环去对这个区间进行考虑，不是要求[i,j]区间合并后的最小得分吗？那么这些石头最终必然会变成一整堆，先不去考虑一些细枝末节，我们可以假定比[i,j]更短的区间已经被我们成功地计算出来了（在打表过程中，区间小的数据的答案往往会被先算出来作为打表后续过程的基础），那么，我们只需要考虑一个k，k是在i,j区间中的一个数，我们去判断dp[i][j]和[dp[i][k]+dp[k+1][j]+Nij(i到j堆石头的总数，也就是最后一次合并的得分)]的大小关系，取一个小的数就可以了。

现在，我们很自然地会想到前缀和的算法，可以帮助我们减少很多的计算量。我们可以定义一个前缀和数组prefixsum，prefixsum[i]表示从第1堆石头到第i堆石头到总数，那么，如果我们要计算第i堆石头和第j堆石头到总数呢？很容易，答案就是prefixsum[j]-prefixsum[i]。

至此，本题的解题思路已经十分明显。

 注意区间更新的时候应该用长度来更新，也就是先求出2堆石头区间的，再求出3堆石子区间的...所以循环打表的时候要注意。

代码演示

#include <iostream>
#define INF 1e9
using namespace std;

int N,stones[105];
int stones_sum[105],dp[105][105]={0};

int main(){
	cin>>N;
	for(int i=1;i<=N;i++){
		cin>>stones[i];
		stones_sum[i]=stones_sum[i-1]+stones[i];
	}
	for(int i=1;i<N;i++)
		for(int j=1;j+i<=N;j++){
			int temp=j+i;
			dp[j][temp]=INF;
			for(int k=j;k<=temp;k++){
				dp[j][temp]=min(dp[j][temp],dp[j][k]+dp[k+1][temp]+stones_sum[temp]-stones_sum[j-1]);
			}
		}
	cout<<dp[1][N]<<endl;
	return 0;
}

当然记忆搜索法也不错：

#include <iostream>
#define INF 1e9
using namespace std;

int N,stones[105];
int stones_sum[105],dp[105][105]={0};

int f(int i,int j){
	if(i==j) return 0;
	if(j-i+1==2) return stones_sum[j]-stones_sum[i-1];
	if(dp[i][j]) return dp[i][j];
	dp[i][j]=INF;
	for(int k=i;k<=j;k++){
		dp[i][j]=min(dp[i][j],f(i,k)+f(k+1,j)+stones_sum[j]-stones_sum[i-1]);
	}
	return dp[i][j];
}

int main(){
	cin>>N;
	for(int i=1;i<=N;i++){
		cin>>stones[i];
		stones_sum[i]=stones_sum[i-1]+stones[i];
	}
	cout<<f(1,N)<<endl;
	return 0;
}