动态规划入门，从简单递归到记忆化搜索到动态规划

WeChat098

于 2024-07-04 18:18:54 发布

阅读量451

点赞数 9

文章标签：动态规划算法

本文链接：https://blog.csdn.net/lin1151211427/article/details/140183449

版权

动态规划入门，从简单递归到记忆化搜索到动态规划

打家劫舍

在这里插入图片描述

class Solution {
    private int nums[];
    public int rob(int[] nums) {
        this.nums = nums;
        return dfs(nums.length - 1);
    }
    public int dfs(int i){
        if (i < 0){
            return 0;
        }
        int res = Math.max(dfs(i - 1), dfs(i - 2) + nums[i]);
        return res;
    }
}

思路：

首先看到题目可以转换到当前这个位置选择或者不选的场景，比如说，首先我们选择了第一个，那么下一次能选择的第一个是第三个，如果不选第一个的话，下一个能选择的就是第二个.

注意点

对于结束的地方，刚开始大家可能会想着这个时候会是结束的地方，需要返回中的sum结果，但是我们需要知道这个地方返回的是当前位置能有的收益是多少，如果当前这个位置已经 < 0,那么这时候结果就是0。
int res = Math.max(dfs(i - 1), dfs(i - 2) + nums[i]); 这代表我们在当前i的这个位置能有的两种情况，对于第一种情况，表示在当前这个位置我们不进行选择，可以在下一个位置进行选择。第二种情况表示我们选择了当前这个位置，体现在将当前的收益进行相加，下一次能选择的第一个位置就是dfs（i - 2），最后选择这两种情况的最大值。
返回res的结果。

上述情况会超时，我们分析一下是哪些时候会重复计算：

在这里插入图片描述
上述情况中，可以看到2的这种情况会重复计算，我们可以在计算得到2的结果之后，将2的结果保存到map中或者数组中，这样下次需要2的结果的时候直接从map中进行查找就可以，这时候O（1）的时间就可以获得。

记忆化搜索

class Solution {
    private int nums[];
    HashMap<Integer,Integer> hashmap = new HashMap<>(); // 记忆化数组
    public int rob(int[] nums) {
        this.nums = nums;
        return dfs(nums.length - 1);
    }
    public int dfs(int i){
        if (i < 0){
            return 0;
        }
        if (hashmap.containsKey(i)){ // 如果当前这个位置之前已经算过，直接去记忆化数组中拿
            return hashmap.get(i);
        }
        int res = Math.max(dfs(i - 1), dfs(i - 2) + nums[i]);
        hashmap.put(i,res); // 每次计算一个结果 就将当前的结果存入到记忆化数组中
        return res;
    }
}

和上面的代码优化的地方就是加入了一个记忆化数组，如果一个位置的结果计算过，就将结果存入到记忆化数组中，之后需要这个结果的时候，就从记忆化数组中进行获取。

从记忆化搜索到动态规划

我们使用图示的方法：

步骤

1、首先查看dfs中有多少个可变的变量（有时候，有些参数是固定的，不会发生变化）。比如说这里我们只有一个参数，我们就生成一个一维表。
2、找到已知条件。动态规划的题目都是可以从一些给定的点，逐步得到最后的结果，比如说给定0，我们可以推到1，得到1，可以推出2，得到2，可以推出 3，之后逐步获得答案。那么我们需要如何得到这些已知条件。
答案就是我们可以看basecase，也就是dfs递归的出口，我们观察到当i < 0 的时候，对应的结果都是0。另外我们观察到我们需要两个参数，所以我们取出 -1 和 -2 得到 dfs（0）
dfs（0）= max（dfs（-1），dfs(-2) + nums[0]）= 1
dfs（1）= max（dfs（0），dfs(-1) + nums[1]
。。。。。
依次可以得到最终的dfs（4），这个dfs（4）就是我们需要的最终结果。

class Solution {
    int nums[];
    private int res[];
    public int rob(int[] nums) {
        this.nums = nums;
        res = new int[nums.length + 2];
        res[0] = 0;
        res[1] = 0;
        for (int i = 2;i < res.length;i++){
            res[i] = Math.max(res[i - 1],res[i - 2] + nums[i - 2]);
        }
        return res[res.length - 1];
    }
}