题目

描述
有N堆石子排成一排，每堆石子有一定的数量。现要将N堆石子并成为一堆。合并的过程只能每次将相邻的两堆石子堆成一堆，每次合并花费的代价为这两堆石子的和，经过N-1次合并后成为一堆。求出总的代价最小值。
输入
有多组测试数据，输入到文件结束。
每组测试数据第一行有一个整数n，表示有n堆石子。
接下来的一行有n（0< n <200）个数，分别表示这n堆石子的数目，用空格隔开
输出
输出总代价的最小值，占单独的一行

样例输入

3
1 2 3
7
13 7 8 16 21 4 18

样例输出

9
239

思路

如果该题没有要求相邻合并，那么该问题就是典型的哈夫曼编码思想，先把数量小的石子合并，数量大的石子最后合并，这样最后的代价就是最小的。对应的就是哈夫曼树的构建过程，该算法保证了二叉树的权值最优性。

但是题目特意要求了相邻合并，那么该问题变为为经典区间动态规划问题。区间动态规划问题的典型特征为：要求一个大区间的最优解，而大区间是由小区间组合而来，所以只要小区间为最优解，那么组成的大区间也必然为最优解。
比如我们要求[1,3]之间的最优合并，那么[1,3]可以有[1,1]和[2,3]，或者[1,2]和[3,3]合并而来，所以只要求这两种情况最小值即可。 所以可以得出我们的状态转移方程为：

dp[i][j]=0,i=j d p [ i ] [ j ] = 0 , i = j

dp[i][j]=min{dp[i][j],dp[i][k]+dp[k+1][j]+sum[i,j]} d p [ i ] [ j ] = m i n { d p [ i ] [ j ] , d p [ i ] [ k ] + d p [ k + 1 ] [ j ] + s u m [ i , j ] }

上面sum[i,j]表示区间i到j的石子的数量总量。
因为合并石子的时候，代价 = 两个区间各自的代价 + 这两个区间石子的总量（也就是合并后，i到j的石子的总量）
显示这里有3层for循环，外层控制区间的长度，第二层控制区间的起始位置，最内层控制分割的位置即可。

代码

package com.special.NYOJ;

import java.util.*;
/** * Created by Special on 2018/5/31 8:34 */
public class NYOJ0737 {

    static final int MAX = (int) 1e6;

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while(input.hasNext()){
            int n = input.nextInt();
            int[] num = new int[n + 1];
            int[] sum = new int[n + 1];
            int[][] dp = new int[n + 1][n + 1];
            for(int i = 0; i < n + 1; i++) {
                Arrays.fill(dp[i], MAX);
            }
            for(int i = 1; i <= n; i++){
                num[i] = input.nextInt();
                sum[i] = sum[i - 1] + num[i];
                dp[i][i] = 0;
            }
            int temp = 0;
            for(int len = 1; len < n; len++){
                for(int i = 1; i + len <= n; i++){
                    int j = i + len;
                    temp = sum[j] - sum[i - 1];
                    for(int k = i; k < j; k++){
                        dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k + 1][j] + temp);
                    }
                }
            }
            System.out.println(dp[1][n]);
        }
    }
}

拓展

• 还有就是公式加括号跟这个四楼类似
• 如果石子堆是围着一个圈呢，思路一样的。