续...
[code]
３．动态规划方程和倒推合并过程
对子序列〔i，j〕最后一次合并，其得分为第i堆数起，顺时针数j堆的石子总数t。被合并的两堆石子是由子序列〔i，k〕和〔（i＋k－１）mod n＋１，j－k〕（１≤k≤j－１）经有限次合并形成的。为了求出最佳合并方案中的k值，我们定义一个动态规划方程：
当求最大得分总和时
f〔i，j〕＝max｛f〔i，k〕＋f〔x，j-k〕＋t｝
１≤k≤j－１
c〔i，j〕＝k│ f〔i，j〕＝f〔i，k〕＋f〔x，j-k〕＋t
（２≤ｊ≤ｎ，１≤ｉ≤ｎ）

当求最小得分总和时
f〔i，j〕＝min｛f〔i，k〕＋f〔x，j－k〕＋t｝
１≤k≤j－１
c〔i，j〕＝k│ f〔i，j〕＝f〔i，k〕＋f〔x，j-k〕＋t 
（２≤ｊ≤ｎ，１≤ｉ≤ｎ）
其中x＝（i＋k－１）modn＋１，即第i堆数起，顺时针数k＋１堆的堆序号。

例如对上面例子中的６(３ ４ ６ ５ ４ ２ )堆石子，按动态规划方程顺推最小得分和。 依次得出含二堆石子的６个子序列的合并方案
f〔１，２〕＝７ f〔２，２〕＝１０ f〔３ ，２〕＝１１ 
c〔１，２〕＝１ c〔２，２〕＝１ c〔３，２〕＝１
f〔４，２〕＝９ f〔５，２〕＝６ f〔６，２〕＝５
c〔４，２〕＝１ c〔５， ２〕＝１ c〔６，２〕＝１

含三堆石子的６(３ ４ ６ ５ ４ ２ )个子序列的合并方案
f〔１，３〕＝２０ f〔２，３〕＝２５ f〔３，３〕＝２４ 
c〔１，３〕＝２ c〔２，３〕＝２ c〔３，３〕＝１
f〔４，３〕＝１７ f〔５，３〕＝１４ f〔６，３〕＝１４
c〔４，３〕＝１ c〔５，３〕＝１ c〔６，３〕＝２

含四堆石子的６(３ ４ ６ ５ ４ ２ )个子序列的合并方案
f〔１，４〕＝３６ f〔２，４〕＝３８ f〔３，４〕＝３４
c〔１，４〕＝２ c〔２，４〕＝２ c〔３，４〕＝１
f〔４，４〕＝２８ f〔５，４〕＝２６ f〔６，４〕＝２９
c〔４，４〕＝１ c〔５，４〕＝２ c〔６，４〕＝３

含五堆石子的６(３ ４ ６ ５ ４ ２ )个子序列的合并方案
f〔１，５〕＝５１ f〔２，５〕＝４８ f〔３，５〕＝４５ 
c〔１，５〕＝３ c〔２，５〕＝２ c〔３，５〕＝２ 
f〔４，５〕＝４１ f〔５，５〕＝４３ f〔６，５〕＝４５
c〔４，５〕＝２ c〔５，５〕＝３ c〔６，５〕＝３

含六堆石子的６(３ ４ ６ ５ ４ ２ )个子序列的合并方案
f〔１，６〕＝６１ f〔２，６〕＝６２ f〔３，６〕＝６１ 
c〔１，６〕＝３ c〔２，６〕＝２ c〔３，６〕＝２ 
f〔４，６〕＝６１ f〔５，６〕＝６１ f〔６，６〕＝６２
c〔４，６〕＝３ c〔５，６〕＝４ c〔６，６〕＝３

f〔１，６〕是f〔１，６〕，ｆ〔２，６〕，……f〔６，６〕中的最小值，表明最小得分和是由序列〔１，６〕经５次合并得出的。我们从这个序列出发， 按下述方法倒推合并过程：
由c〔１，６〕＝３可知，第５次合并的两堆石子分别由子序列〔１，３〕和子序列〔４，3〕经４次合并后得出。其中c〔１，３〕＝２可知由子序列〔１，３〕合并成的一堆石子是由子序列〔１，２〕和第三堆合并而来的。而c〔１，２〕＝１，以表明了子序列〔１，２〕的合并方案是第１堆合并第２堆。
由此倒推回去，得出第１，第２次合并的方案，每次合并得分 
第一次合并 ３ ４ ６…… 　　　->７
第二次合并 ７ ６……       ->１３
１３…… 
子序列〔１，３〕经２次合并后合并成１堆， ２次合并的得分和＝７＋１３＝２０。
ｃ〔４，３〕＝１，可知由子序列〔４，３〕合并成的一堆石子是由第４堆和子序列〔５，
２〕合并而来的。而c〔５，２〕＝１，又表明了子序列〔５，２〕的合并方案是第５堆合并第６堆。由此倒推回去，得出第３、第４次合并的方案 
每次合并得分：
第三次合并 ……５４ ２   ->６ 
第四次合并 ……５ ６     ->１１ 
……１１ 
子序列〔４，３〕经２次合并后合并成１堆，２次合并的得分和＝６＋１１＝１７。
第五次合并是将最后两堆合并成１堆，该次合并的得分为２４。
显然，上述５次合并的得分总和为最小
２０＋１７＋２４＝６１

上述倒推过程，可由一个print（〔子序列〕）的递归算法描述
procedure print （〔i，ｊ〕）
begin
if ｊ〈〉１ then ｛继续倒推合并过程
begin 
print（〔i，c〔i，j〕〕；｛倒推子序列１的合并过程｝
print（〔i＋c〔i，j〕－１〕mod n＋１，j－c〔i，j〕）
｛倒推子序列２的合并过程｝
for K：＝１ 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（〔１，６〕）后的结果如下：
              print（〔１，６〕）⑤
                ┌──────┴──────┐
          print（〔１，３〕）②           print（〔４，３〕）④
      ┌─────┴─────┐           ┌─────┴─────┐
  print(〔１，２〕)① print(〔3，1〕)   print(〔4，1〕) print(〔５，２〕)③
┌──────┴──────┐                 ┌──────┴──────┐         
print（〔1,1〕）     print（〔2,1〕）           print（〔5,1〕）       print（〔6,1〕） 
（图6.2-5）
其中回溯至
① 显示 ３ ４６ ５ ４ 
② 显示 ７ ６５ ４ ２ 
③ 显示 １３ ５４ ２
④ 显示 １３５ ６
⑤ 显示 １３ １１
注:调用print过程后，应显示６堆石子的总数作为第５次合并的得分。
[/code]

续...
[code]

Program Stones;
Type
Node = Record{当前序列的合并方案}
c : Longint;{得分和}
d : Byte{子序列1的堆数}
End;
SumType = Array [1..100,1..100] of Longint;
{sumtype[i,j]-子序列[i,j]的石子总数}
Var
List : Array [1..100,1..100] of Node;
{list[i,j]-子序列[i,j]的合并方案}
Date, Dt : Array [1..100] of Integer;
{Date[i]-第i堆石子数,Dt-暂存Date}
Sum : ^SumType;{sum^[i,j]-指向子序列[i,j]的石子总数的指针}
F : Text;{文件变量}
Fn : String;{文件名串}
N, i, j : Integer;{N-石子堆数,i,j-循环变量}

Procedure Print(i, j : Byte);{递归打印子序列[i,j]的合并过程}
Var
k, x : Shortint;{k-循环变量;x-子序列2中首堆石子的序号}
Begin
If j <> 1 Then Begin{继续倒推合并过程}
Print(i, List[i,j].d);{倒推子序列1的合并过程}
x := (i + List[i, j].d - 1) Mod N + 1;{求子序列2中首堆石子的序号}
Print(x, j - List[i, j].d);{倒推子序列2的合并过程}
For k := 1 to N Do{输出当前合并第i堆,第x堆石子的方案}
  If Date[k] > 0 Then Begin
    If (i= k)or(x=k)Then Write(F, - Date[k], ' ')
    Else Write(F, Date[k], ' ')
  End; { Then }
Writeln(F);{输出换行符}
Date[i] := Date[i] + Date[x];{原第i堆和第x堆合并成第ｉ堆}
Date[x] := - Date[x]{将原第x堆从圈内去除}
End { Then }
End; { Print }

Procedure Main(s : Shortint);
Var
i, j, k : Integer;
t, x : Longint;
Begin
For i := 1 to N Do Begin{仅含一堆石子的序列不存在合并}
  List[i, 1].c := 0;
  List[i, 1].d := 0
End; {For}
For j := 2 to N Do{顺推含2堆,含3堆……含N堆石子的各子序列的合并方案}
  For i := 1 to N Do Begin{当前考虑从第i堆数起,顺时针数j堆的子序列}
    If s = 1 Then List[i, j].c := Maxlongint{合并[i,j]子序列的得分和初始化}
    Else List[i, j].c := 0;
    t := Sum^[i, j];{最后一次合并的得分为[i,j]子序列的石子总数}
    For k := 1 to j - 1 Do Begin{子序列1的石子堆数依次考虑1堆……j-1堆}
    x := (i + k - 1) Mod N + 1;{求子序列2首堆序号}
    If (s=1) And (List[i,k].c + List[x,j-k].c+t < List[i, j].c)
Or (s=2) And (List[i,k].c + List[x,j-k].c+t > List[i, j].c)
{ 若该合并方案为目前最佳,则记下}
    Then Begin
      List[i, j].c := List[i, k].c + List[x, j - k].c + t;
      List[i, j].d := k
    End { Then }
    End { For }
End; { For }
{在子序列[1,N],[2,N],……,[N, N]中选择得分总和最小(或最大)的一个子序列}
k := 1; x := List[1, N].c;
For i := 2 to N Do
  If (s = 1) And (List[i, N].c < x) Or (s = 2) And
(List[i, N].c > x) Then Begin
    k := i; x := List[i, N].c
  End; { Then }
Print(k, N);{由此出发,倒推合并过程}
Writeln(F, Sum^[1, N]);{输出最后一次将石子合并成一堆的石子总数}
Writeln(F);
Writeln(list[k, N].c)
End; { Main }

Begin
Write( 'File name = ');{输入文件名串}
Readln(Fn);
Assign(F, Fn);{该文件名串与文件变量连接}
Reset(F);{文件读准备}
Readln(F, N);{读入石子堆数}
For i := 1 to N Do Read(F, Date[i]);{读入每堆石子数}
New(Sum);{求每一个子序列的石子数sum}
For i := 1 to N Do Sum^[i, 1] := Date[i];
For j := 2 to N Do
  For i := 1 to N Do
    Sum^[i, j] := Date[i] + Sum^[i Mod N + 1, j - 1];
Dt := Date;{暂存合并前的各堆石子,结构相同的变量可相互赋值}
Close(F);{关闭输入文件}
Assign(F, 'OUTPUT.TXT ');{文件变量与输出文件名串连接}
Rewrite(F);{文件写准备}
Main(1);{求得分和最小的合并方案}
Date := Dt;{恢复合并前的各堆石子}
Main(2);{求得分和最大的合并方案}
Close(F){关闭输出文件}
End.
[/code]

如果a[i]表示从0堆加到i堆的石子数的话
那好像应该是这样:
if ( i == 0 )
    sum = a[j];  //因为k < n, 所以j = 0 + k < n, 所以不用取j % n
else
    sum = ( j / n ) * a[n - 1] + a[j % n] - a[i - 1];
//sum表示从第i堆到第j堆石子数的和

还有一点i是小于n的不会出现i == n的状况

[quote]
如果a[i]表示从0堆加到i堆的石子数的话
那好像应该是这样:
if ( i == 0 )
    sum = a[j];  //因为k < n, 所以j = 0 + k < n, 所以不用取j % n
else
    sum = ( j / n ) * a[n - 1] + a[j % n] - a[i - 1];
//sum表示从第i堆到第j堆石子数的和

还有一点i是小于n的不会出现i == n的状况[/quote]

谢谢。。。

改为：
[code]
  
        
        for( k = 1,fo=2*n-3 ; k < n ; k ++,fo-- )
        for( i = 0 ; i <= fo ; i ++ )
        {
             j =  i + k ;
            
            
            
            max = 0 ;
            min = INF ;
            if ( i == 0 || i == n)
                        sum = a[j%n] ;
                        else
                        sum = a[j%n]-a[(i-1)%n];
            
           
[/code]

但是我发现书中给的测试数据有误。。。

[quote]
这么网站有更多的算法源码
http://www.sfcode.cn[/quote]

7 8 错...

十几天了，做了一些题，但是本人水平不高，有些问题还是不能解决，但还是有兴趣的，希望作者能把答案和剩下的内容发上去，把整本书发上去更好 谢谢楼主了

谢谢了哦，，哈哈，，，[em12]

书的名字叫什么

[quote]十几天了，做了一些题，但是本人水平不高，有些问题还是不能解决，但还是有兴趣的，希望作者能把答案和剩下的内容发上去，把整本书发上去更好 谢谢楼主了[/quote]

[color=FF00FF]很抱歉!!!
最近忙于做论坛,所以没时间,不过再过几天,我会弄上来的......[/color]

谢谢楼主，期待着，以后有不懂的希望楼主帮我们或者大家一起解决哦