区间DP浅析

区间dp

区间dp就是在区间上进行动态规划，求解一段区间上的最优解。主要是通过合并小区间的 最优解进而得出整个大区间上最优解的dp算法。

解决思路

让我求解在一个区间上的最优解，那么我把这个区间分割成一个个小区间，求解每个小区间的最优解，再合并小区间得到大区间即可。所以在代码实现上，我可以枚举区间长度len为每次分割成的小区间长度（由短到长不断合并），内层枚举该长度下可以的起点，自然终点也就明了了。然后在这个起点终点之间枚举分割点，求解这段小区间在某个分割点下的最优解。

代码模板

for(int len = 1;len<=n;len++){//枚举长度
        for(int j = 1;j+len<=n+1;j++){//枚举起点，ends<=n
            int ends = j+len - 1;
            for(int i = j;i<ends;i++){//枚举分割点，更新小区间最优解
                dp[j][ends] = min(dp[j][ends],dp[j][i]+dp[i+1][ends]+something);
            }
        }
}

例子

N堆石子摆成一条线。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将N堆石子合并成一堆的最小代价。

例如： 1 2 3 4，有不少合并方法

1 2 3 4 => 3 3 4(3) => 6 4(9) => 10(19)

1 2 3 4 => 1 5 4(5) => 1 9(14) => 10(24)

1 2 3 4 => 1 2 7(7) => 3 7(10) => 10(20)

括号里面为总代价可以看出，第一种方法的代价最低，现在给出n堆石子的数量，计算最小合并代价。

/**
    * @Description
    * @Author  xujz
    * @Date   2020/4/10 15:32
    * @Param  n代表n个石堆
    * @Return      void
    * @Exception
    *
    */
    public static void great(int n) {
        int[] stone = new int[n + 1];
        int[] sum = new int[n + 1];
        int[][] dp = new int[n + 1][n + 1];
        Scanner scanner = new Scanner(System.in);
        for (int i = 1; i <= n; i++) {
            int w = scanner.nextInt();
            stone[i] = w;
            sum[i] = sum[i - 1] + w;
            dp[i][i] = 0;
        }
        /*先算出长度为1的，
        */
        for (int len = 1; len <= n; len++) {
            for (int j = 1; j + len <= n + 1; j++) {
                // j代表下标
                int end = j + len - 1;
                {
                    if (j != end) {
                        dp[j][end] = Integer.MAX_VALUE;
                    }
                    for (int i = j; i < end; i++) {
                        // i代表区间被分割的下标
                        dp[j][end] = Math.min(dp[j][end], dp[j][i] + dp[i + 1][end] + sum[end] - sum[j - 1]);
                    }
                }
            }
        }
        System.out.println(dp[1][4]);
	}