石子合併問題是最經典的DP問題。首先它有如下3種題型：

PPT講解：點選開啟連結

(1)有N堆石子，現要將石子有序的合併成一堆，規定如下：每次只能移動任意的2堆石子合併，合併花費為新合成的一堆石子的數量。求將這N堆石子合併成一堆的總花費最小（或最大）。

分析：當然這種情況是最簡單的情況，合併的是任意兩堆，直接貪心即可，每次選擇最小的兩堆合併。本問題實際上就是霍夫曼的變形。

例題連結：點選開啟連結

(2)有N堆石子，現要將石子有序的合併成一堆，規定如下：每次只能移動相鄰的2堆石子合併，合併花費為新合成的一堆石子的數量。求將這N堆石子合併成一堆的總花費最小（或最大）。

分析：我們熟悉矩陣連乘，知道矩陣連乘也是每次合併相鄰的兩個矩陣，那麼石子合併可以用矩陣連乘的方式來解決。

設dp[i][j]表示第i到第j堆石子合併的最優值，sum[i][j]表示第i到第j堆石子的總數量。那麼就有狀態轉移公式：

#include <bits/stdc++.h>
#define pr(x) cout << #x << "= " << x << "  "
#define pl(x) cout << #x << "= " << x << endl;
#define Memset(x, a) memset(x, a, sizeof(x))
#define ll __int64
using  namespace  std;
 
const int inf=0x3f3f3f3f;
const int N=205;
int a[N];
int sum[N];
int dp[N][N];
 
int getans(int a[],int n){
    for(int i=0; i<n; i++){
        dp[i][i]=0;
    }
    for(int v=1; v<n; v++){//i,j之間的間距
        for(int i=0; i<n-v; i++){
            int j=i+v;
            dp[i][j]=inf;
            int tmp=sum[j]-(i>0?sum[i-1]:0);
            for(int k=i; k<j; k++)
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+tmp);
        }
    }
    return  dp[0][n-1];
}
 
int  main(){
    int  n;
    while(~scanf("%d",&n)){
        for(int i=0; i<n; i++){
            scanf("%d",&a[i]);
        }
        sum[0]=a[0];
        for(int  i=1; i<n; i++){
            sum[i]=sum[i-1]+a[i];
        }
        printf("%d\n",getans(a,n));
    }
    return 0;
}
 

直線取石子問題的平行四邊形優化（用一個p【i】【j】=k 表示區間 i---j 從k點分開才是最優的，這樣的話我們就可以優化掉一層複雜度，變為O（n^2） ）

#include <bits/stdc++.h>
using namespace std;
 
const int inf = 0x3f3f3f3f;
const int N = 1005;
 
int dp[N][N];
int p[N][N];
int sum[N];
int n;
 
int getans(){
    for(int i=1; i<=n; i++){
        dp[i][i] = 0;
        p[i][i] = i;
    }
    for(int len=1; len<n; len++){
        for(int i=1; i+len<=n; i++){
            int end = i+len;
            int tmp = inf;
            int k = 0;
            for(int j=p[i][end-1]; j<=p[i+1][end]; j++)
            {
                if(dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1] < tmp)
                {
                    tmp = dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1];
                    k = j;
                }
            }
            dp[i][end] = tmp;
            p[i][end] = k;
        }
    }
    return dp[1][n];
}
 
int main()
{
    while(scanf("%d",&n)!=EOF){
        sum[0] = 0;
        for(int i=1; i<=n; i++){
            int val;
            scanf("%d",&val);
            sum[i] = sum[i-1] + val;
        }
        printf("%d\n",getans());
    }
    return 0;
}
 

(3)問題(2)的是在石子排列是直線情況下的解法，如果把石子改為環形排列，又怎麼做呢？

分析：狀態轉移方程為：

其中有：

#include <iostream>
#include <string.h>
#include <stdio.h>
 
using namespace std;
const int INF = 1 << 30;
const int N = 205;
 
int mins[N][N];
int maxs[N][N];
int sum[N],a[N];
int minval,maxval;
int n;
 
int getsum(int i,int j)
{
    if(i+j >= n) return getsum(i,n-i-1) + getsum(0,(i+j)%n);
    else return sum[i+j] - (i>0 ? sum[i-1]:0);
}
 
void Work(int a[],int n)
{
    for(int i=0;i<n;i++)
        mins[i][0] = maxs[i][0] = 0;
    for(int j=1;j<n;j++)
    {
        for(int i=0;i<n;i++)
        {
            mins[i][j] = INF;
            maxs[i][j] = 0;
            for(int k=0;k<j;k++)
            {
                mins[i][j] = min(mins[i][j],mins[i][k] + mins[(i+k+1)%n][j-k-1] + getsum(i,j));
                maxs[i][j] = max(maxs[i][j],maxs[i][k] + maxs[(i+k+1)%n][j-k-1] + getsum(i,j));
            }
        }
    }
    minval = mins[0][n-1];
    maxval = maxs[0][n-1];
    for(int i=0;i<n;i++)
    {
        minval = min(minval,mins[i][n-1]);
        maxval = max(maxval,maxs[i][n-1]);
    }
}
 
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        sum[0] = a[0];
        for(int i=1;i<n;i++)
            sum[i] = sum[i-1] + a[i];
        Work(a,n);
        printf("%d %d\n",minval,maxval);
    }
    return 0;
}

可以看出，上面的(1)(3)問題的時間複雜度都是O(n^3)，由於過程滿足平行四邊形法則，故可以進一步優化到O(n^2)。

轉自這裡