java---区间dp---石子合并（每日一道算法2022.10.15）

题目：
设有 N 堆石子排成一排，其编号为 1,2,3,…,N。
每堆石子有一定的质量，可以用一个整数来描述，现在要将这 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)。

输出格式
输出一个整数，表示最小代价。

数据范围
1≤N≤300

输入:
4
1 3 5 2

输出：
22

public class 区间dp_石子合并 {
    public static int N = 310, n;
    public static int[] s = new int[N];
    public static int[][] f = new int[N][N];

    public static void main(String[] args) {
        //读入并处理为前缀和
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        for (int i = 1; i<=n; i++) s[i] = in.nextInt() + s[i-1];

        //状态计算，区间dp的枚举以区间长度从小到大进行计算
        for (int len = 2; len <= n; len++) {        //len区间长度,从2开始，因为len为1时，挪动自己的代价是0，无需计算
            for (int i = 1; i+len-1 <= n; i++) {    //i起始点,条件(i+len-1 <= n)是起始点+区间长度不超过边界，-1是从1开始存的数据，所以长度是n+1
                int l = i, r = i+len-1;
                f[l][r] = 0x3f3f3f3f;               //这里每次计算前都要先给个初始值，要不然是0的话那结果就必定是0了
                for (int k = i; k < r; k++) {       //枚举所有分界线
                    f[l][r] = Math.min(f[l][r], f[l][k] + f[k+1][r] + s[r] - s[l-1]);
                }
            }
        }

        //输出从第一堆到最后一堆的最小代价即可
        System.out.println(f[1][n]);
    }
}

思路：
经典y式dp法

1.状态表示
f[i][j] 表示在 i 到 j 的区间中，最优的合并方式（也就是如何让合并代价最小）（Min）
例如：1 5 3
先合并5 3代价为8，再合并1 8代价为9， 8+9=17代价
但先合并1 5代价为6，再合并6 3代价为9， 6+9=15代价
那么1 5 3的最小/最优合并代价就是15

2.状态计算
通过分界线k “|” 来计算当前 f[i][j]

x x x x x | x x x x x
k的左侧最优解为f[i][k]
k的右侧最优解为f[k+1][j]

并且我们知道，最终合并左右的时候，代价一定是 i ~ j 的所有值加起来，那么就可以利用前缀和的特性来解决，s[j] - s[i-1]
最终的状态转移计算式即为：

f[i][j] = min(f[i][j], f[i][k] + f[k+1][j] + s[j] - s[i-1])

声明：
算法思路来源为y总，详细请见https://www.acwing.com/
本文仅用作学习记录和交流