计蒜客 沙子的质量 区间dp（Java版）

题目链接：https://nanti.jisuanke.com/t/254
设有N堆沙子排成一排，其编号为1，2，3，…，N（N< =300）。每堆沙子有一定的数量，可以用一个整数来描述，现在要将这N堆沙子合并成为一堆，每次只能合并相邻的两堆，合并的代价为这两堆沙子的数量之和，合并后与这两堆沙子相邻的沙子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同，如有4堆沙子分别为 1 3 5 2 我们可以先合并1、2堆，代价为4，得到4 5 2 又合并 1，2堆，代价为9，得到9 2 ，再合并得到11，总代价为4+9+11=24，如果第二步是先合并2，3堆，则代价为7，得到4 7，最后一次合并代价为11，总代价为4+7+11=22；

问题是：找出一种合理的方法，使总的代价最小。输出最小代价。

输入格式：

第一行一个数N表示沙子的堆数N。 第二行N个数，表示每堆沙子的质量。 < =1000

输出格式：

合并的最小代价
样例输入
4
1 3 5 2
样例输出
22
队友在做动态规划的题，我也来凑凑热闹，他一下子ac了，说这是区间动态规划，然后我去百度区间dp的基础，看了这篇博客，挺不错的https://blog.csdn.net/Ronaldo7_ZYB/article/details/81087952
区间DP，其实求的就是一个区间内的最优值.
一般这种题目，在设置状态的时候，都可以设f[i][j]为区间i-j的最优值
而f[i][j]的最优值，这有两个小区间合并而来的，为了划分这两个更小的区间，我们则需用用一个循环变量k来枚举，而一般的状态转移方程便是：
f[i][j]=max/min(f[i][j],f[i][k]+f[k][j]+something)
f[i][j]=max/min(f[i][j],f[i][k]+f[k][j]+something)
我们则需要根据这个题目的实际含义进行变通即可.
而区间dp的大致模板是：

for (int len=2;len<=n;len++)
    for (int i=1;i+len-1<=n;i++)
    {
        int j=i+len-1;
        for (int k=i;k<=j;k++)
            f[i][j]=max/min(f[i][j],f[i][k]+f[k][j]+something)
    }

len枚举区间的长度，i和j分别是区间的起点和终点，k的作用是用来划分区间.
AC代码：

import java.util.Scanner;
/*
 * 区间动态规划模版题
 */
public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int a[]=new int[n+1];
		int sum[]=new int[n+1];
		int cost[][]=new int[n+1][n+1];
		int dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			a[i]=sc.nextInt();
			sum[i]=sum[i-1]+a[i];
		}
		for(int i=1;i<=n;i++){
			for(int j=i;j<=n;j++){
				cost[i][j]=sum[j]-sum[i-1];
			}
		}
		for(int len=2;len<=n;len++){
			for(int i=1;i<=n;i++){
				int j=i+len-1;
				if(j>n)
					continue;
				for(int k=i;kdp[i][k]+dp[k+1][j]+cost[i][j])
						dp[i][j]=dp[i][k]+dp[k+1][j]+cost[i][j];
				}
			}
		}
		System.out.println(dp[1][n]);
		sc.close();
	}
}