动态规划思想：石子合并问题

描述： 在一个圆形操场的四周摆放着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[N], int n)
8 {
9 // 定义二维数组m[i][j]来记录i到j的合并过成中最少石子数目
10 // 此处赋值为-1
11  
12 int m[N][N];
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 // 当i到j堆石子合并时最后里面的石子数求和得sum
38 for ( int b = i;b <= j;b ++ )
39 sum += p[b];
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 ][n];
57 return min;
58
59
60 }
61
62 /*
63 *求合并过程中
64 *最多合并堆数目
65 * */
66
67 int MatrixChain_max( int p[N], int n)
68 {
69 int m[N][N];
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 ][n];
106 return max;
107
108
109 }
110 int main()
111 {
112 int stone[N];
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[n] = 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 }

 

 

 

转载于:https://www.cnblogs.com/SCAU_que/articles/1893979.html