【ACM】区间DP（石子合并）

石子合并是经典的动态规划，有以下3种题型。
1.有N堆石子，现在要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费是新合成的一堆石子的数量。现在求将这N堆石子合并为一堆的总花费最小（或最大）。

分析：贪心算法，每次选择最小（或最大）的两堆合并，实际上是哈夫曼的变形。

2.有N堆石子，现在要将石子有序的合并成一堆，规定如下：每次只能合并相邻的2堆石子，合并花费是新合成的一堆石子的数量。现在求将这N堆石子合并为一堆的总花费最小（或最大）。
下面先给出代码，然后加以分析。

#include <cstdio>

using namespace std;
const int maxn = 1000;
const int INF = 0x3f3f3f3f;
int dp[maxn][maxn];
int a[maxn];
int sum[maxn][maxn]={0};
int min(int x,int y)
{
    return x<y?x:y;
}

int main()
{
   int n;
   while(scanf("%d",&n) == 1)
   {

       for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
       for(int i=1;i<=n;i++)
       {
           dp[i][i] = 0;
           sum[i][i] = a[i];
           for(int j=i+1;j<=n;j++)
           {
               sum[i][j] = sum[i][j-1]+a[j];
           }
       }
       for(int len=2;len<=n;len++)
       {
           for(int i=1;i<=n-len+1;i++)
           {
               int j = i + len -1;
               dp[i][j] = INF;
               for(int k=i;k<j;k++)
               {
                   dp[i][j] = min(dp[i][j] , dp[i][k] + dp[k+1][j] + sum[i][j]);
               }
           }
       }
       printf("%d\n",dp[1][n]);
   }
   return 0;
}

dp[i][j]表示从第i堆石子到第j堆石子的花费之和，sum[i][j]表示从第i堆到第j堆得石子数的和。
dp[i][j]可以分解为子问题dp[i][k]+dp[k+1][j]+sum[i][j]，只需要遍历i到j的所有整数k就可已找到最优子结构。dp[i][k]表示i到k的花费，dp[k+1][j]表示k+1到j的花费，而从i到j，最后一次合并的花费一定是i到j的总和即sum[i][j]，上一步的花费为dp[i][k]+dp[k+1][j],这两步加起来就是花费之和。

3.有n堆石子排成一圈，每次选择相邻的两堆石子，将其合并为一堆，记录该次合并的花费为两堆石子个数之和。已知每堆石子的石子个数，求当所有石子合并为一堆时，总花费最小（或最大）。

这个与上一个的区别就是变成了环形，因此可以进行变形，成为2的同类问题。