动态规划：石子合并问题

描述： 在一个圆形操场的四周摆放着n 堆石子。现要将石子有次序地合并成一堆。 规定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。 试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。

开始以为通过贪心算法可能很快解决问题，可是是行不通的。

首先我们可以把这么堆石子看成一列

我们假如5堆的石子，其中石子数分别为7，6，5，7，100

•按照贪心法，合并的过程如下：

每次合并得分

第一次合并 7 6 5 7 100 =11

　 第二次合并 7 11 7 100=18

　 第三次合并 18 7 100 =25

第四次合并 25 100 =125

总得分＝11＋18＋25+125＝179

•另一种合并方案

每次合并得分

　 　第一次合并 7 6 5 7 100 ->13

第二次合并 13 5 7 100->12

第三次合并 13 12 100 ->25

第四次合并 25 100 ->125

总得分＝13＋12＋25+125＝175

显然利用贪心来做是错误的，贪心算法在子过程中得出的解只是局部最优,而不能保证使得全局的值最优。

　　　

如果N－1次合并的全局最优解包含了每一次合并的子问题的最优解，那么经这样的N－1次合并后的得分总和必然是最优的。

　　 因此我们需要通过动态规划算法来求出最优解。

在此我们假设有n堆石子，一字排开，合并相邻两堆的石子，每合并两堆石子得到一个分数，最终合并后总分数最少的。

　　　我们设m(i,j)定义为第i堆石子到第j堆石子合并后的最少总分数。a(i)为第i堆石子得石子数量。

　　　当合并的石子堆为1堆时，很明显m(i,i)的分数为0;

　　 当合并的石子堆为2堆时，m(i,i+1)的分数为a(i)+a(i+1);

　　 当合并的石子堆为3堆时，m(i,i+2)的分数为MIN((m(i,i)+m(i+1,i+2)+sum(i,i+2)),(m(i,i+1)+m(i+2,i+2)+sum(i,i+2));

　　　当合并的石子堆为4堆时......

代码实现如下：

1 #include<stdio.h>
2  #define N 100
3  /*
4  *求合并过程中
5  *最少合并堆数目
6  **/
7  int MatrixChain_min(int p
,int n)
8 {
9         //定义二维数组m[i][j]来记录i到j的合并过成中最少石子数目
10         //此处赋值为-1
11
12         int m

;
13          for(int x=1;x<=n;x++)
14         for(int z=1;z<=n;z++)
15         {
16             m[x][z]=-1;
17         }
18
19      int min=0;
20
21                                                           //当一个单独合并时，m[i][i]设为0，表示没有石子
22      for(int g = 1;g<=n;g++) m[g][g]=0;
23
24                                                           //当相邻的两堆石子合并时，此时的m很容易可以看出是两者之和
25      for(int i=1;i<=n-1;i++)
26     {
27         int j=i+1;
28         m[i][j]=p[i]+p[j];
29     }
30
31                                                           //当相邻的3堆以及到最后的n堆时，执行以下循环
32     for(int r=3; r<=n;r++)
33          for(int i=1;i<=n-r+1;i++)
34          {
35              int j = i+r-1;                               //j总是距离i+r-1的距离
36              int sum=0;
37
38              for(int b=i;b<=j;b++)
39                  sum+=p[b]; //当i到j堆石子合并时最后里面的石子数求和得sum
40
41              // 此时m[i][j]为i~j堆石子间以m[i][i]+m[i+1][j]+sum结果，这是其中一种可能，不一定是最优
42              //要与下面的情况相比较，唉，太详细了
43
44              m[i][j] = m[i+1][j]+sum;
45
46              //除上面一种组合情况外的其他组合情况
47              for(int k=i+1;k<j;k++)
48              {
49                  int t=m[i][k]+m[k+1][j]+sum;
50                  if(t<m[i][j])
51                      m[i][j] = t;
52
53              }
54          }
55           //最终得到最优解
56          min=m[1]
;
57          return min;
58
59
60 }
61
62 /*
63  *求合并过程中
64  *最多合并堆数目
65  **/
66
67   int  MatrixChain_max(int p
,int n)
68 {
69        int m

;
70          for(int x=1;x<=n;x++)
71         for(int z=1;z<=n;z++)
72         {
73             m[x][z]=-1;
74         }
75
76
77      int max=0;
78      //一个独自组合时
79     for(int g = 1;g<=n;g++) m[g][g]=0;
80     //两个两两组合时
81     for(int i=1;i<=n-1;i++)
82     {
83         int j=i+1;
84         m[i][j]=p[i]+p[j];
85     }
86
87     for(int r=3; r<=n;r++)
88          for(int i=1;i<=n-r+1;i++)
89          {
90              int j = i+r-1;
91              int sum=0;
92              for(int b=i;b<=j;b++)
93                  sum+=p[b];
94              m[i][j] = m[i+1][j]+sum;
95
96              for(int k=i+1;k<j;k++)
97              {
98                  int t=m[i][k]+m[k+1][j]+sum;
99                  if(t>m[i][j])
100                      m[i][j] = t;
101
102              }
103          }
104
105          max=m[1]
;
106          return max;
107
108
109 }
110 int main()
111 {
112       int stone
;
113       int min=0;
114       int max=0;
115       int n;
116       scanf("%d",&n);
117       for(int i=1;i<=n;i++)
118           scanf("%d",&stone[i]);
119
120       min= MatrixChain_min(stone,n);
121       max= MatrixChain_max(stone,n);
122
123       //因为题目要求圆的原因，要把所有情况都要考虑到，总共有n种情况。
124       for(int j=1;j<=n-1;j++)
125       {
126            int min_cache=0;
127            int max_cache=0;
128            int cache= stone[1];
129            for(int k=2;k<=n;k++)
130            {
131                stone[k-1]=stone[k];
132            }
133            stone
=cache;
134            min_cache= MatrixChain_min(stone,n);
135            max_cache= MatrixChain_max(stone,n);
136            if(min_cache<min)
137                min=min_cache;
138            if(max_cache>max)
139                max=max_cache;
140       }
141
142     printf("%d\n",min);
143     printf("%d\n",max);
144
145     return 1;
146
147 }