石子合并问题

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



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

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





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



 

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

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



#include <iostream>  

#include <string.h>  

#include <stdio.h>  

  

using namespace std;  

const int INF = 1 << 30;  

const int N = 205;  

  

int dp

;  

int sum
;  

int a
;  

  

int getMinval(int a[],int n)  

{  

    for(int i=0;i<n;i++)  

        dp[i][i] = 0;  

    for(int v=1;v<n;v++)  

    {  

        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)!=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];  

        printf("%d\n",getMinval(a,n));  

    }  

    return 0;  

}  

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

#include <iostream>  

#include <string.h>  

#include <stdio.h>  

  

using namespace std;  

const int INF = 1 << 30;  

const int N = 1005;  

  

int dp

;  

int p

;  

int sum
;  

int n;  

  

int getMinval()  

{  

    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]
;  

}  

  

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",getMinval());  

    }  

    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

;  

int maxs

;  

int sum
,a
;  

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;  

}  

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