问题:
在一个园形操场的四周摆放N堆石子(N≤100),现要将石子有次序地合并成一堆。规定
每次只能选相邻的两堆合并成新的一堆,并将新的一堆的石子数,记为该次合并的得分。
编一程序,由文件读入堆数N及每堆的石子数(≤20),
①选择一种合并石子的方案,使得做N-1次合并,得分的总和最小;
②选择一种合并石子的方案,使得做N-1次合并,得分的总和最大。
今天在网上看到了这道题,觉得跟我们系去年的算法比赛的一道题很像,仔细看完题以后才发现原来区别还是很大的。那道题跟这道题最大的差别在于没有要求必须选择相邻的两堆,所以用贪心+最大(小)堆就可以搞定了。
f(i,j)表示从i起共合并j堆的最大(小)得分,通过分析可知该问题具有动态规划所要求的两个性质:
1 最优子结构性质
如果f(i,j)是从i起的共j个堆的最大(小)得分,那必定存在k(i<=k<=j),使得f(i,k)和f(i+k,j-k)的得分分别是是最大(小)的。
2 重叠子问题性质
计算f(i,j) 时可以利用已经计算的结果简化计算步骤。
f(i,j)=max{f(i,k)+f(i+k,j-k)}最后从f(1,n),f(2,n)……f(n,n)中选出值最小的一个即是该问题的解。
一.试题
在一个园形操场的四周摆放N堆石子(N≤100),现要将石子有次序地合并成一堆。规定
每次只能选相邻的两堆合并成新的一堆,并将新的一堆的石子数,记为该次合并的得分。
编一程序,由文件读入堆数N及每堆的石子数(≤20),
①选择一种合并石子的方案,使得做N-1次合并,得分的总和最小;
②选择一种合并石子的方案,使得做N-1次合并,得分的总和最大。
例如,所示的4堆石子,每堆石子数(从最上面的一堆数起,顺时针数)依
次为4594。则3次合并得分总和最小的方案:8+13+22=43
得分最大的方案为:14+18+22=54
输入数据:
文件名由键盘输入,该文件内容为:
第一行为石子堆数N;
第二行为每堆的石子数,每两个数之间用一个空格符分隔。
输出数据:
输出文件名为output.txt
从第1至第N行为得分最小的合并方案。第N+1行是空行。从第N+2行到第2N+1行是得
分最大合并方案。
每种合并方案用N行表示,其中第i行(1≤i≤N)表示第i 次合并前各堆的石子数(依
顺时针次序输出,哪一堆先输出均可)。 要求将待合并的两堆石子数以相应的负数表示,以便标识。
输入输出范例:
输入文件内容:
4
4 59 4
输出文件内容:
-4 5 9 -4
-8-5 9
-13 -9
22
4 -5 -9 4
4 -14 -4
-4-18
22
二.算法分析
竞赛中多数选手都不约而同地采用了尽可能逼近目标的贪心法来逐次合并:从最上面
的一堆开始,沿顺时针方向排成一个序列。 第一次选得分最小(最大)的相邻两堆合并,
形成新的一堆;接下来,在N-1堆中选得分最小(最大)的相邻两堆合并……,依次类推,
直至所有石子经N-1次合并后形成一堆。
例如有6堆石子,每堆石子数(从最上面一堆数起,顺时针数)依次为3 46 5 4 2
要求选择一种合并石子的方案,使得做5次合并,得分的总和最小。
按照贪心法,合并的过程如下:
每次合并得分
第一次合并 3 4 6 5 4 2 ->5
第二次合并 5 4 6 5 4 ->9
第三次合并 9 6 5 4 ->9
第四次合并 9 6 9 ->15
第五次合并 15 9 ->24
24
总得分=5+9+9+15+24=62
但是当我们仔细琢磨后,可得出另一个合并石子的方案:
每次合并得分
第一次合并 3 4 6 5 4 2 ->7
第二次合并 7 6 5 4 2 ->13
第三次合并 13 5 4 2 ->6
第四次合并 13 5 6 ->11
第五次合并 13 11 ->24
24
总得分=7+6+11+13+24=61
显然,后者比贪心法得出的合并方案更优。 题目中的示例故意造成一个贪心法解题的
假像,诱使读者进入“陷阱”。为了帮助读者从这个“陷阱”里走出来, 我们先来明确一个问题:
1.最佳合并过程符合最佳原理
使用贪心法至所以可能出错,
是因为每一次选择得分最小(最大)的相邻两堆合并,不一定保证余下的合并过程能导致最优解。聪明的读者马上会想到一种理想的假设:如果N-1次合并的全局最优解包含了每一次合并的子问题的最优解,那么经这样的N-1次合并后的得分总和必然是最优的。
例如上例中第五次合并石子数分别为13和11的相邻两堆。
这两堆石头分别由最初的第1,2,3堆(石头数分别为3,4,6)和第4,5,6堆(石头数分别为5,4,2)经4次合并后形成的。于是问题又归结为如何使得这两个子序列的N-2
次合并的得分总和最优。为了实现这一目标,我们将第1个序列又一分为二:第1、2堆构成子序列1,
第3堆为子序列2。第一次合并子序列1中的两堆,得分7;
第二次再将之与子序列2的一堆合并,得分13。显然对于第1个子序列来说,这样的合并方案是最优的。同样,我们将第2个子序列也一分为二;第4堆为子序列1,第5,6堆构成子序列2。第三次合并子序列2中的2堆,得分6;第四次再将之与子序列1中的一堆合并,得分13。显然对于第二个子序列来说,这样的合并方案也是最优的。
由此得出一个结论──6堆石子经
过这样的5次合并后,得分的总和最小。我们把每一次合并划分为阶段,当前阶段中计算出的得分和作为状态,
如何在前一次合并的基础上定义一个能使目前得分总和最大的合并方案作为一次决策。很显然,某阶段的状态给定后,则以后各阶段的决策不受这阶段以前各段状态的影响。
这种无后效性的性质符最佳原理,因此可以用动态规划的算法求解。
2.动态规划的方向和初值的设定
采用动态规划求解的关键是确定所有石子堆子序列的最佳合并方案。 这些石子堆子序列包括:
{第1堆、第2堆}、{第2堆、第3堆}、……、{第N堆、第1堆};
{第1堆、第2堆、第3堆}、{第2堆、第3堆、第4堆}、……、{第N堆、第1堆、第2堆};……
{第1堆、……、第N堆}{第1堆、……、第N堆、第1堆}……{第N堆、第1堆、……、第N-1堆}
为了便于运算,我们用〔i,j〕表示一个从第i堆数起,顺时针数j堆时的子序列{第i堆、第i+1堆、……、第(i+j-1)mod n堆}
它的最佳合并方案包括两个信息:
①在该子序列的各堆石子合并成一堆的过程中,各次合并得分的总和;
②形成最佳得分和的子序列1和子序列2。由于两个子序列是相邻的, 因此只需记住子序列1的堆数;
设
f〔i,j〕──将子序列〔i,j〕中的j堆石子合并成一堆的最佳得分和;
c〔i,j〕──将〔i,j〕一分为二,其中子序列1的堆数;
(1≤i≤N,1≤j≤N)
显然,对每一堆石子来说,它的
f〔i,1〕=0
c〔i,1〕=0 (1≤i≤N)
对于子序列〔i,j〕来说,若求最小得分总和,f〔i,j〕的初始值为∞; 若求最大得分总和,f〔i,j〕的初始值为0。(1≤i≤N,2≤j≤N)。
动态规划的方向是顺推(即从上而下)。先考虑含二堆石子的N个子序列(各子序列分别从第1堆、第2堆、……、第N堆数起,顺时针数2堆)的合并方案
f〔1,2〕,f〔2,2〕,……,f〔N,2〕
c〔1,2〕,c〔2,2〕,……,c〔N,2〕
然后考虑含三堆石子的N个子序列(各子序列分别从第1堆、第2堆、……、第N堆数起,顺时针数3堆)的合并方案
f〔1,3〕,f〔2,3〕,……,f〔N,3〕
c〔1,3〕,c〔2,3〕,……,c〔N,3〕
……
依次类推,直至考虑了含N堆石子的N个子序列(各子序列分别从第1堆、第2堆、 ……、第N堆数起,顺时针数N堆)的合并方案
f〔1,N〕,f〔2,N〕,……,f〔N,N〕
c〔1,N〕,c〔2,N〕,……,c〔N,N〕
最后,在子序列〔1,N〕,〔2,N〕,……,〔N,N〕中,选择得分总和(f值)最小(或最大)的一个子序列〔i,N〕(1≤i≤N),由此出发倒推合并过程。
3.动态规划方程和倒推合并过程
对子序列〔i,j〕最后一次合并,其得分为第i堆数起,顺时针数j堆的石子总数t。被合并的两堆石子是由子序列〔i,k〕和〔(i+k-1)mod
n+1,j-k〕(1≤k≤j-1)经有限次合并形成的。为了求出最佳合并方案中的k值,我们定义一个动态规划方程:
当求最大得分总和时
f〔i,j〕=max{f〔i,k〕+f〔x,j-k〕+t}
1≤k≤j-1
c〔i,j〕=k│ f〔i,j〕=f〔i,k〕+f〔x,j-k〕+t
(2≤j≤n,1≤i≤n)
当求最小得分总和时
f〔i,j〕=min{f〔i,k〕+f〔x,j-k〕+t}
1≤k≤j-1
c〔i,j〕=k│ f〔i,j〕=f〔i,k〕+f〔x,j-k〕+t
(2≤j≤n,1≤i≤n)
其中x=(i+k-1)modn+1,即第i堆数起,顺时针数k+1堆的堆序号。
例如对上面例子中的6(3 4 6 5 4 2 )堆石子,按动态规划方程顺推最小得分和。 依次得出含二堆石子的6个子序列的合并方案
f〔1,2〕=7 f〔2,2〕=10 f〔3 ,2〕=11
c〔1,2〕=1 c〔2,2〕=1 c〔3,2〕=1
f〔4,2〕=9 f〔5,2〕=6 f〔6,2〕=5
c〔4,2〕=1 c〔5, 2〕=1 c〔6,2〕=1
含三堆石子的6(3 4 6 5 4 2 )个子序列的合并方案
f〔1,3〕=20 f〔2,3〕=25 f〔3,3〕=24
c〔1,3〕=2 c〔2,3〕=2 c〔3,3〕=1
f〔4,3〕=17 f〔5,3〕=14 f〔6,3〕=14
c〔4,3〕=1 c〔5,3〕=1 c〔6,3〕=2
含四堆石子的6(3 4 6 5 4 2 )个子序列的合并方案
f〔1,4〕=36 f〔2,4〕=38 f〔3,4〕=34
c〔1,4〕=2 c〔2,4〕=2 c〔3,4〕=1
f〔4,4〕=28 f〔5,4〕=26 f〔6,4〕=29
c〔4,4〕=1 c〔5,4〕=2 c〔6,4〕=3
含五堆石子的6(3 4 6 5 4 2 )个子序列的合并方案
f〔1,5〕=51 f〔2,5〕=48 f〔3,5〕=45
c〔1,5〕=3 c〔2,5〕=2 c〔3,5〕=2
f〔4,5〕=41 f〔5,5〕=43 f〔6,5〕=45
c〔4,5〕=2 c〔5,5〕=3 c〔6,5〕=3
含六堆石子的6(3 4 6 5 4 2 )个子序列的合并方案
f〔1,6〕=61 f〔2,6〕=62 f〔3,6〕=61
c〔1,6〕=3 c〔2,6〕=2 c〔3,6〕=2
f〔4,6〕=61 f〔5,6〕=61 f〔6,6〕=62
c〔4,6〕=3 c〔5,6〕=4 c〔6,6〕=3
f〔1,6〕是f〔1,6〕,f〔2,6〕,……f〔6,6〕中的最小值,表明最小得分和是由序列〔1,6〕经5次合并得出的。我们从这个序列出发,
按下述方法倒推合并过程:
由c〔1,6〕=3可知,第5次合并的两堆石子分别由子序列〔1,3〕和子序列〔4,3〕经4次合并后得出。其中c〔1,3〕=2可知由子序列〔1,3〕合并成的一堆石子是由子序列〔1,2〕和第三堆合并而来的。而c〔1,2〕=1,以表明了子序列〔1,2〕的合并方案是第1堆合并第2堆。
由此倒推回去,得出第1,第2次合并的方案,每次合并得分
第一次合并 3 4 6…… ->7
第二次合并 7 6…… ->13
13……
子序列〔1,3〕经2次合并后合并成1堆, 2次合并的得分和=7+13=20。
c〔4,3〕=1,可知由子序列〔4,3〕合并成的一堆石子是由第4堆和子序列〔5,
2〕合并而来的。而c〔5,2〕=1,又表明了子序列〔5,2〕的合并方案是第5堆合并第6堆。由此倒推回去,得出第3、第4次合并的方案
每次合并得分:
第三次合并 ……54 2 ->6
第四次合并 ……5 6 ->11
……11
子序列〔4,3〕经2次合并后合并成1堆,2次合并的得分和=6+11=17。
第五次合并是将最后两堆合并成1堆,该次合并的得分为24。
显然,上述5次合并的得分总和为最小
20+17+24=61
上述倒推过程,可由一个print(〔子序列〕)的递归算法描述
procedure print (〔i,j〕)
begin
if j〈〉1 then {继续倒推合并过程
begin
print(〔i,c〔i,j〕〕;{倒推子序列1的合并过程}
print(〔i+c〔i,j〕-1〕mod n+1,j-c〔i,j〕)
{倒推子序列2的合并过程}
for K:=1 to N do{输出当前被合并的两堆石子}
if (第K堆石子未从圈内去除)
then begin
if(K=i)or(K=X)then置第K堆石子待合并标志
else第K堆石子未被合并;
end;{then}
第i堆石子数←第i堆石子数+第X堆石子数;
将第X堆石子从圈内去除;
end;{then}
end;{print}
例如,调用print(〔1,6〕)后的结果如下:
print(〔1,6〕)⑤
┌──────┴──────┐
print(〔1,3〕)② print(〔4,3〕)④
┌─────┴─────┐ ┌─────┴─────┐
print(〔1,2〕)① print(〔3,1〕) print(〔4,1〕) print(〔5,2〕)③
┌──────┴──────┐ ┌──────┴──────┐
print(〔1,1〕) print(〔2,1〕) print(〔5,1〕)
print(〔6,1〕)
(图6.2-5)
其中回溯至
① 显示 3 46 5 4
② 显示 7 65 4 2
③ 显示 13 54 2
④ 显示 135 6
⑤ 显示 13 11
注:调用print过程后,应显示6堆石子的总数作为第5次合并的得分。
代码:
#include <iostream>
#include <string>
#include <fstream>
#define MAX 100
#define MAXint 1000
using namespace std;
int i,j;//循环用的
ifstream in("in.txt");
ofstream out ("out.txt");
int f[MAX][MAX];//f[i][j]表示从i起取j堆的最大值
int sum[MAX][MAX];//sum[i][j]表示从i起取j堆的和
int num[MAX];
int main()
{
int n;
in>>n;
for(i=1;i<=n;i++)
{
in >>num[i];
sum[i][1]=num[i];
f[i][1]=0;
}//end for
for (j=2;j<=n;++j)
{
cout<<endl<<j<<endl<<endl;
for(i=1;i<=n;++i)
{
cout <<(sum[i][j]=num[i]+sum[i%n+1][j-1])<<endl;
}//end for i
}//end for j
int k,x,t;
for (j=2;j<=n;j++)
{
for(i=1;i<=n;i++)
{
f[i][j]=MAXint;
t=sum[i][j];
for(k=1;k<=j-1;k++)
{
x=(i+k-1)%n+1;
if(f[i][k]+f[x][j-k]+t<f[i][j])
f[i][j]=f[i][k]+f[x][j-k]+t;
}//end for k
cout <<f[i][j]<<endl;
}//end for i
}//end for j
int tmp=f[1][n];
for(j=1;j<=n;++j)
{
if (f[j][n]<tmp)
tmp=f[j][n];
}//end for
cout<<tmp<<endl;
return 0;
}//end main
首先,该问题具有最优子结构性质。即可以用二分的思想来解决。求编号为1到n的最小值,可认为是求1到k的最小值,加上k+1到n的最小值,再加上将这两堆已合并好的的石子再进行合并的步数,最后取不同k下的最小值。从这个分析可以看出,该问题与完全加括号问题和多边形的最优剖分问题基本相同。
根据以上的分析,设c[i][j]表示从编号为i到编号为j的石子堆进行合并的最小值,则可得如下递推公式:
C[i][j]=min{c[i][k]+c[k+1][j]+sum[i][j]}, i=<k<j
代码如下:
#include<iostream>
using namespace std;
const int MAXINT=100000;
int c[101][101];
int sum[101];
int a[101];
int n;
int main(void)
{
scanf("%d",&n);
for (int i=1;i<=n;i++)
scanf("%d",&a[i]);
sum[0]=0;
for (int i=1;i<=n;i++)
sum[i]=sum[i-1]+a[i];
for (int l=1;l<n;l++)
for (int i=1;i<n;i++)
{
int j=i+l;
c[i][j]=MAXINT;
for (int k=i;k<j;k++)
c[i][j]=c[i][j]>c[i][k]+c[k+1][j]+sum[j]-sum[i]? c[i][k]+c[k+1][j]+sum[j]-sum[i-1] : c[i][j];
}
printf("%d\n",c[1][n]);
return 0;
}
石子合并问题还可以求得分的最大值,这时只需将上述递推公式中的min改为max即可。