石子合并问题

石子合并问题是最经典的DP问题。首先它有如下3种题型：

(1)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。

分析：当然这种情况是最简单的情况，合并的是任意两堆，直接贪心即可，每次选择最小的两堆合并。本问题实际上就是哈夫曼的变形。

(2)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。

 

分析：我们熟悉矩阵连乘，知道矩阵连乘也是每次合并相邻的两个矩阵，那么石子合并可以用矩阵连乘的方式来解决。

设dp[i][j]表示第i到第j堆石子合并的最优值，sum[i][j]表示第i到第j堆石子的总数量。那么就有状态转移公式：

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6. const int INF = 1 << 30;  
7. const int N = 205;  
8.   
9. int dp[N][N];  
10. int sum[N];  
11. int a[N];  
12.   
13. int getMinval(int a[],int n)  
14. {  
15.     for(int i=0;i<n;i++)  
16.         dp[i][i] = 0;  
17.     for(int v=1;v<n;v++)  
18.     {  
19.         for(int i=0;i<n-v;i++)  
20.         {  
21.             int j = i + v;  
22.             dp[i][j] = INF;  
23.             int tmp = sum[j] - (i > 0 ? sum[i-1]:0);  
24.             for(int k=i;k<j;k++)  
25.                 dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j] + tmp);  
26.         }  
27.     }  
28.     return dp[0][n-1];  
29. }  
30.   
31. int main()  
32. {  
33.     int n;  
34.     while(scanf("%d",&n)!=EOF)  
35.     {  
36.         for(int i=0;i<n;i++)  
37.             scanf("%d",&a[i]);  
38.         sum[0] = a[0];  
39.         for(int i=1;i<n;i++)  
40.             sum[i] = sum[i-1] + a[i];  
41.         printf("%d\n",getMinval(a,n));  
42.     }  
43.     return 0;  
44. }  

直线取石子问题的平行四边形优化：

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6. const int INF = 1 << 30;  
7. const int N = 1005;  
8.   
9. int dp[N][N];  
10. int p[N][N];  
11. int sum[N];  
12. int n;  
13.   
14. int getMinval()  
15. {  
16.     for(int i=1; i<=n; i++)  
17.     {  
18.         dp[i][i] = 0;  
19.         p[i][i] = i;  
20.     }  
21.     for(int len=1; len<n; len++)  
22.     {  
23.         for(int i=1; i+len<=n; i++)  
24.         {  
25.             int end = i+len;  
26.             int tmp = INF;  
27.             int k = 0;  
28.             for(int j=p[i][end-1]; j<=p[i+1][end]; j++)  
29.             {  
30.                 if(dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1] < tmp)  
31.                 {  
32.                     tmp = dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1];  
33.                     k = j;  
34.                 }  
35.             }  
36.             dp[i][end] = tmp;  
37.             p[i][end] = k;  
38.         }  
39.     }  
40.     return dp[1][n];  
41. }  
42.   
43. int main()  
44. {  
45.     while(scanf("%d",&n)!=EOF)  
46.     {  
47.         sum[0] = 0;  
48.         for(int i=1; i<=n; i++)  
49.         {  
50.             int val;  
51.             scanf("%d",&val);  
52.             sum[i] = sum[i-1] + val;  
53.         }  
54.         printf("%d\n",getMinval());  
55.     }  
56.     return 0;  
57. }  

(3)问题(2)的是在石子排列是直线情况下的解法，如果把石子改为环形排列，又怎么做呢？

分析：状态转移方程为：

其中有：

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6. const int INF = 1 << 30;  
7. const int N = 205;  
8.   
9. int mins[N][N];  
10. int maxs[N][N];  
11. int sum[N],a[N];  
12. int minval,maxval;  
13. int n;  
14.   
15. int getsum(int i,int j)  
16. {  
17.     if(i+j >= n) return getsum(i,n-i-1) + getsum(0,(i+j)%n);  
18.     else return sum[i+j] - (i>0 ? sum[i-1]:0);  
19. }  
20.   
21. void Work(int a[],int n)  
22. {  
23.     for(int i=0;i<n;i++)  
24.         mins[i][0] = maxs[i][0] = 0;  
25.     for(int j=1;j<n;j++)  
26.     {  
27.         for(int i=0;i<n;i++)  
28.         {  
29.             mins[i][j] = INF;  
30.             maxs[i][j] = 0;  
31.             for(int k=0;k<j;k++)  
32.             {  
33.                 mins[i][j] = min(mins[i][j],mins[i][k] + mins[(i+k+1)%n][j-k-1] + getsum(i,j));  
34.                 maxs[i][j] = max(maxs[i][j],maxs[i][k] + maxs[(i+k+1)%n][j-k-1] + getsum(i,j));  
35.             }  
36.         }  
37.     }  
38.     minval = mins[0][n-1];  
39.     maxval = maxs[0][n-1];  
40.     for(int i=0;i<n;i++)  
41.     {  
42.         minval = min(minval,mins[i][n-1]);  
43.         maxval = max(maxval,maxs[i][n-1]);  
44.     }  
45. }  
46.   
47. int main()  
48. {  
49.     while(scanf("%d",&n)!=EOF)  
50.     {  
51.         for(int i=0;i<n;i++)  
52.             scanf("%d",&a[i]);  
53.         sum[0] = a[0];  
54.         for(int i=1;i<n;i++)  
55.             sum[i] = sum[i-1] + a[i];  
56.         Work(a,n);  
57.         printf("%d %d\n",minval,maxval);  
58.     }  
59.     return 0;  
60. }  

可以看出，上面的(2)(3)问题的时间复杂度都是O(n^3)，由于过程满足平行四边形法则，故可以进一步优化到O(n^2)。