java数据结构与算法刷题-----LeetCode198. 打家劫舍

java数据结构与算法刷题目录(剑指Offer、LeetCode、ACM)-----主目录-----持续更新(进不去说明我没写完):https://blog.csdn.net/grd_java/article/details/123063846

很多人觉得动态规划很难,但它就是固定套路而已。其实动态规划只不过是将多余的步骤,提前放到dp数组中(就是一个数组,只不过大家都叫它dp),达到空间换时间的效果。它仅仅只是一种优化思路,因此它目前的境地和线性代数一样----虚假的难。

  1. 想想线性代数,在国外留学的学生大多数不觉得线性代数难理解。但是中国的学生学习线性代数时,完全摸不着头脑,一上来就是行列式和矩阵,根本不知道这玩意是干嘛的。
  2. 线性代数从根本上是在空间上研究向量,抽象上研究线性关系的学科。人家国外的教科书都是第一讲就帮助大家理解研究向量和线性关系。
  3. 反观国内的教材,直接把行列式搞到第一章。搞的国内的学生在学习线性代数的时候,只会觉得一知半解,觉得麻烦,完全不知道这玩意学来干什么。当苦尽甘来终于理解线性代数时干什么的时候,发现人家国外的教材第一节就把这玩意讲清楚了。你只会大骂我们国内这些教材,什么狗东西(以上是自己学完线性代数后的吐槽,我们同学无一例外都这么觉得)。

而我想告诉你,动态规划和线性代数一样,我学完了才知道,它不过就是研究空间换时间,提前将固定的重复操作规划到dp数组中,而不用暴力求解,从而让效率极大提升。

  1. 但是网上教动态规划的兄弟们,你直接给一个动态方程是怎么回事?和线性代数,一上来就教行列式和矩阵一样,纯属恶心人。我差不多做了30多道动态规划题目,才理解,动态方程只是一个步骤而已,而这已经浪费我很长时间了,我每道题都一知半解不理解,过程及其痛苦。最后只能重新做。
  2. 动态规划,一定是优先考虑重复操作与dp数组之间的关系,搞清楚后,再提出动态方程。而你们前面步骤省略了不讲,一上来给个方程,不是纯属扯淡吗?
  3. 我推荐研究动态规划题目,按5个步骤,从上到下依次来分析
  1. DP数组及下标含义
  2. 递推公式
  3. dp数组初始化
  4. 数组遍历顺序(双重循环及以上时,才考虑)
  5. dp数组打印,分析思路是否正确(相当于做完题,检查一下)

java数据结构与算法刷题-----LeetCode198. 打家劫舍_第1张图片

java数据结构与算法刷题-----LeetCode198. 打家劫舍_第2张图片

先理解题目细节

想象这样一个场景,我们是小偷,从第一栋挨个考虑偷还是不偷,如果偷,那就是身上已经偷了多少+这一栋能偷多少。如果不偷,那就是身上已经偷了多少。

java数据结构与算法刷题-----LeetCode198. 打家劫舍_第3张图片

  1. 题目给我们的数组代表每个房子有多少钱,而且相邻的房子不能都偷,只能偷不相邻的。
  2. 例如2,1,1,2 这个序列,显然不触发警报的前提下(不偷相邻的)----偷第一个和第4个为能偷到的最多的钱
  3. 怎么偷才能偷到最多呢?当然是保证最大获利情况下,能偷的都偷了,而且不能触发警报。
  4. 我们每个房子都单独考虑,偷还是不偷,而且只需考虑它前面的房子,因为我们要能偷的都偷
  1. 若要偷当前房子:那么,前面相邻的不能考虑,只能考虑再前面一个,也就是当前房子的金额,加上除了前面一个相邻的房子外,已经偷了多少。
  2. 若不偷当前房子:那么,前面偷了多少,到这个房子就还有多少,金额不变
解题思路
  1. 暴力求解的思想,就是回溯算法,枚举每一种情况,拿到最大值,显然会做大量无效运算。
  2. 但是如果我们预先将其存储到dp数组,就可以直接通过dp[x], 获取dp数组中指定位置x的体力花费,而不用枚举。典型的动态规划题目
动态规划思考5步曲
  1. DP数组及下标含义

我们要求出的是到了某个房子后最大情况下偷了多少钱,那么dp数组中存储的就是最大情况下偷了多少钱。要求出谁的最大情况下偷了多少。显然是到达某个房子后,那么下标就是代表现在到了哪个房子,也就是代表到了某一栋房子后的最大已偷取的金额。显然,只需要一个下标即可表示,故这道题的dp数组只需要一维数组

  1. 递推公式
  1. 由题意可知,每个房子都可以选择偷与不偷,选择最大值。而第一个房子肯定要偷它,才能获得最大值。而第二个房子,因为它前面没有不相邻的房子,所以它要么不偷,也就是只偷第一个房子。要么选择偷第二个房子,而第一个房子不偷,然后选择最大情况。

故:第一个房子固定为F(0) = 第一个房子金额。第二个固定为F(1) = max(第一个房子金额,第二个房子金额)

  1. 之后每一栋,都需要判断它偷还是不偷,以及前面不相邻的房子。如果偷,就要考虑前面不相邻的+自己这栋能偷多少钱。不偷,那么前一栋相邻的它肯定考虑一下。而前面的房子怎么考虑的是前面房子的事,它们也考虑过了偷还是不偷。我们只考虑当前这栋是偷,还是不偷
  2. 因此,可以得到,从第三栋开始,递推公式为偷或者不偷,选择最大值: F(n) = max( F(n-2)+nums[n] , F(n-1) )
  1. dp数组初始化

java数据结构与算法刷题-----LeetCode198. 打家劫舍_第4张图片

  1. 数组遍历顺序(因为这个数列是一维的,只需要一重循环,无需考虑这个)
  2. 打印dp数组(自己生成dp数组后,将dp数组输出看看,是否和自己预想的一样。)

java数据结构与算法刷题-----LeetCode198. 打家劫舍_第5张图片

代码:时间复杂度O(n).空间复杂度O(n)

java数据结构与算法刷题-----LeetCode198. 打家劫舍_第6张图片

class Solution {
    public int rob(int[] nums) {
        int length = nums.length;//有多少栋房子
        int dp[] = new int[length];//dp数组
        dp[0] = nums[0];//第一栋,只能选择偷它
        //第二栋可以选择偷(那么第一栋不能偷),或者不偷(只偷第二栋,第一栋不偷),无需考虑前面不相邻的
        if(length>=2) dp[1] = Math.max(nums[0],nums[1]);
        //第三栋开始,不仅仅要考虑偷还是不偷,还要考虑前面不相邻的
        for(int i = 2;i<length;i++){
            //如果这一栋不偷,则前面偷了多少就是多少,也就是到上一栋时,有多少就有多少===dp[i-1]
            //如果这一栋要偷,则前面不相邻的偷了多少 + 这一栋有多少 为偷完这一栋拿到的钱
            dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);//我们只考虑最大情况
        }
        return dp[length-1];//返回偷到最后一栋时,偷到的最大金额
    }
}
学有余力的同学可以尝试这个方法,将空间复杂度变为常数级-----------------代码:时间复杂度O(n).空间复杂度O(1)

将dp数组优化掉,换成3个变量,滚动执行。将dp[0]换成first。dp[1]换成second. 也就是first永远指向当前栋的前面不相邻的,second永远指向前面相邻的。
java数据结构与算法刷题-----LeetCode198. 打家劫舍_第7张图片

class Solution {
    public int rob(int[] nums) {
        int length = nums.length;//有多少栋房子
        int first = nums[0],second = nums[0];//第一栋,只能选择偷它
        //第二栋可以选择偷(那么第一栋不能偷),或者不偷(只偷第二栋,第一栋不偷),无需考虑前面不相邻的
        if(length>=2) second = Math.max(nums[0],nums[1]);
        //第三栋开始,不仅仅要考虑偷还是不偷,还要考虑前面不相邻的
        for(int i = 2;i<length;i++){
            int temp = second;
            second = Math.max(first+nums[i],second);//我们只考虑最大情况
            first = temp;
        }
        return second;//返回偷到最后一栋时,偷到的最大金额
    }
}

你可能感兴趣的:(算法,java,leetcode,算法)