【LeetCode每日一题: 1000. 合并石头的最低成本 | 暴力递归=＞记忆化搜索=＞动态规划 | 区间dp 】

作者简介：硕风和炜，CSDN-Java领域新星创作者，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享
座右铭：人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？

题目链接

1000. 合并石头的最低成本

题目描述

有 N 堆石头排成一排，第 i 堆中有 stones[i] 块石头。

每次移动（move）需要将连续的 K 堆石头合并为一堆，而这个移动的成本为这 K 堆石头的总数。

找出把所有石头合并成一堆的最低成本。如果不可能，返回 -1 。

示例 1：
输入：stones = [3,2,4,1], K = 2
输出：20
解释：
从 [3, 2, 4, 1] 开始。
合并 [3, 2]，成本为 5，剩下 [5, 4, 1]。
合并 [4, 1]，成本为 5，剩下 [5, 5]。
合并 [5, 5]，成本为 10，剩下 [10]。
总成本 20，这是可能的最小值。

示例 2：
输入：stones = [3,2,4,1], K = 3
输出：-1
解释：任何合并操作后，都会剩下 2 堆，我们无法再进行合并。所以这项任务是不可能完成的。.

示例 3：
输入：stones = [3,5,1,2,6], K = 3
输出：25
解释：
从 [3, 5, 1, 2, 6] 开始。
合并 [5, 1, 2]，成本为 8，剩下 [3, 8, 6]。
合并 [3, 8, 6]，成本为 17，剩下 [17]。
总成本 25，这是可能的最小值。

提示：
1 <= stones.length <= 30
2 <= K <= 30
1 <= stones[i] <= 100

求解思路&实现代码&运行结果

暴力递归

求解思路

1. 为了能够让同学们更好的理解这个过程，我特意将整个思考的过程以及作图的过程都绘制在下面这张图中，希望可以通过下面这张图更好的帮助你理解整个过程。
   

实现代码

注意，代码的实现方式可以有很多，大家根据自己的习惯来就好

class Solution {
    public int mergeStones(int[] stones, int k) {
        int n=stones.length;
        if((n-1)%(k-1)!=0) return -1;
        int[] sum=new int[n+1];
        for(int i=0;i<n;i++){
            sum[i+1]=sum[i]+stones[i];
        }
        return process(0,n-1,1,k,stones,sum);
    }

    public int process(int left,int right,int cnt,int k,int[] stones,int[] sum){
        // 确定递归出口 
        if(cnt==1){
            return left==right?0:process(left,right,k,k,stones,sum)+sum[right+1]-sum[left];
        }
        // 确定每一堆的一个状态过程
        int min=Integer.MAX_VALUE;
        for(int i=left;i<right;i+=k-1){
            min=Math.min(min,process(left,i,1,k,stones,sum)+process(i+1,right,cnt-1,k,stones,sum));
        }
        return min;
    }
}

运行结果

不要灰心，继续改进。是我们想要的结果。

记忆化搜索

求解思路

1. 核心思路就是我们上面的求解过程，如果看上面的图解过程。
2. 在原来的基础上加缓存表，将结果进行记录，避免重复计算。

实现代码

class Solution {
    public int mergeStones(int[] stones, int k) {
        int n=stones.length;
        if((n-1)%(k-1)!=0) return -1;
        int[] sum=new int[n+1];
        for(int i=0;i<n;i++){
            sum[i+1]=sum[i]+stones[i];
        }
        int[][][] dp=new int[n][n][k+1];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                Arrays.fill(dp[i][j],-1);
            }
        }
        return process(0,n-1,1,k,stones,sum,dp);
    }

    public int process(int left,int right,int cnt,int k,int[] stones,int[] sum,int[][][] dp){
        if(dp[left][right][cnt]!=-1) return dp[left][right][cnt];
        if(cnt==1){
            return dp[left][right][cnt]=left==right?0:process(left,right,k,k,stones,sum,dp)+sum[right+1]-sum[left];
        }
        int min=Integer.MAX_VALUE;
        for(int i=left;i<right;i+=k-1){
            min=Math.min(min,process(left,i,1,k,stones,sum,dp)+process(i+1,right,cnt-1,k,stones,sum,dp));
        }
        return dp[left][right][cnt]=min;
    }
}

运行结果

缓存表已经通过了，真想！

动态规划

求解思路

1. 同理，核心求解思路我们上面已经讲过了，此处不同的是原来通过递归，此时我们通过dp数组和循环即可完成。

实现代码

class Solution {
    public int mergeStones(int[] stones, int k) {
        int n=stones.length;
        if((n-1)%(k-1)!=0) return -1;
        int[] sum=new int[n+1];
        for(int i=0;i<n;i++){
            sum[i+1]=sum[i]+stones[i];
        }
        int[][][] dp=new int[n][n][k+1];
        for(int left=n-1;left>=0;left--){
            for(int right=left+1;right<n;right++){
                for(int cnt=k;cnt>=2;cnt--){
                    int min=Integer.MAX_VALUE;
                    for(int i=left;i<right;i+=k-1){
                        min=Math.min(min,dp[left][i][1]+dp[i+1][right][cnt-1]);
                    }
                    dp[left][right][cnt]=min;
                }
                dp[left][right][1]=dp[left][right][k]+sum[right+1]-sum[left];
            }
        }
        return dp[0][n-1][1];
    }
}

运行结果

课后作业

作业描述

该题目可以继续优化呢？如果可以，怎么继续优化呢？亲自动手尝试一下，看看能解决吗？

实现代码

class Solution {
    public int mergeStones(int[] stones, int k) {
        int n=stones.length;
        if((n-1)%(k-1)!=0) return -1;
        int[] sum=new int[n+1];
        for(int i=0;i<n;i++){
            sum[i+1]=sum[i]+stones[i];
        }
        int[][] dp=new int[n][n];
        for(int left=n-1;left>=0;left--){
            for(int right=left+1;right<n;right++){
                dp[left][right]=Integer.MAX_VALUE;
                for(int i=left;i<right;i+=k-1){
                    dp[left][right]=Math.min(dp[left][right],dp[left][i]+dp[i+1][right]);
                }
                if((right-left)%(k-1)==0) dp[left][right]+=sum[right+1]-sum[left];
            }
        }
        return dp[0][n-1];
    }
}

运行结果

共勉

最后，我想送给大家一句一直激励我的座右铭，希望可以与大家共勉！