Leetcode 题解 - 动态规划-斐波那契数列

- 日理万妓 2023-01-13 04:21 92阅读 0赞

# Leetcode 题解 - 动态规划 #

### 文章目录 ###

*  Leetcode 题解 - 动态规划
 *   *  斐波那契数列系列
     *   *  509. 斐波那契数（简单）
         *  70. 爬楼梯（简单）
         *  198. 打家劫舍（中等）
         *  213. 打家劫舍 II（中等）
         *  母牛生产（程序员代码面试指南-P181）

--------------------

*递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。*

## 斐波那契数列系列 ##

参考文章：**labuladong**微信公众号\#手把手刷动态规划系列文章，很棒的公众号，推荐给大家

**动态规划问题的一般形式就是求最值**。动态规划其实是运筹学的一种最优化方法，只不过在计算机问题上应用比较多，比如说让你求**最长**递增子序列呀，**最小**编辑距离呀等等。

既然是要求最值，核心问题是什么呢？**求解动态规划的核心问题是穷举**。因为要求最值，肯定要把所有可行的答案穷举出来，然后在其中找最值呗。

动态规划就这么简单，就是穷举就完事了？我看到的动态规划问题都很难啊！

首先，动态规划的穷举有点特别，因为这类问题**存在「重叠子问题」**，如果暴力穷举的话效率会极其低下，所以需要「备忘录」或者「DP table」来优化穷举过程，避免不必要的计算。

而且，动态规划问题一定会**具备「最优子结构」**，才能通过子问题的最值得到原问题的最值。

另外，虽然动态规划的核心思想就是穷举求最值，但是问题可以千变万化，穷举所有可行解其实并不是一件容易的事，只有列出**正确的「状态转移方程**」才能正确地穷举。

以上提到的重叠子问题、最优子结构、状态转移方程就是动态规划三要素。具体什么意思等会会举例详解，但是在实际的算法问题中，**写出状态转移方程是最困难的**，这也就是为什么很多朋友觉得动态规划问题困难的原因，我来提供我研究出来的一个思维框架，辅助你思考状态转移方程：

**明确「状态」 -> 定义 dp 数组/函数的含义 -> 明确「选择」-> 明确 base case。**

下面通过斐波那契数列问题来详解动态规划的基本原理。让你明白什么是重叠子问题（斐波那契数列严格来说不是动态规划问题）

--------------------

### 509. 斐波那契数（简单） ###

**斐波那契数**，通常用 `F(n)` 表示，形成的序列称为 **斐波那契数列** 。该数列由 `0` 和 `1` 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
    F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给你 `n` ，请计算 `F(n)` 。

输入：2
    输出：1
    解释：F(2) = F(1) + F(0) = 1 + 0 = 1

输入：3
    输出：2
    解释：F(3) = F(2) + F(1) = 1 + 1 = 2

**方法一：暴力递归**

斐波那契数列的数学形式就是递归的，写成代码就是这样：

int fib(int N) {
        
        if (N == 1 || N == 2) return 1;
        return fib(N - 1) + fib(N - 2);
    }

这样写代码虽然简洁易懂，但是十分低效，低效在哪里？假设 n = 20，请画出递归树。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center]

就是说想要计算原问题`f(20)`，我就得先计算出子问题`f(19)`和`f(18)`，然后要计算`f(19)`，我就要先算出子问题`f(18)`和`f(17)`，以此类推。最后遇到`f(1)`或者`f(2)`的时候，结果已知，就能直接返回结果，递归树不再向下生长了。

**递归算法的时间复杂度怎么计算？子问题个数乘以解决一个子问题需要的时间。**

子问题个数，即递归树中节点的总数。显然二叉树节点总数为指数级别，所以子问题个数为 O(2^n)。

解决一个子问题的时间，在本算法中，没有循环，只有 f(n - 1) + f(n - 2) 一个加法操作，时间为 O(1)。

所以，这个算法的时间复杂度为 O(2^n)，指数级别，爆炸。

观察递归树，很明显发现了算法低效的原因：存在大量重复计算，比如`f(18)`被计算了两次，而且你可以看到，以`f(18)`为根的这个递归树体量巨大，多算一遍，会耗费巨大的时间。更何况，还不止`f(18)`这一个节点被重复计算，所以这个算法及其低效。

这就是动态规划问题的第一个性质：**重叠子问题**。下面，我们想办法解决这个问题。

--------------------

**方法二：带备忘录的递归解法**

即然耗时的原因是重复计算，那么我们可以造一个「备忘录」，每次算出某个子问题的答案后别急着返回，先记到「备忘录」里再返回；每次遇到一个子问题先去「备忘录」里查一查，如果发现之前已经解决过这个问题了，直接把答案拿出来用，不要再耗时去计算了。

class Solution {
        
        public int fib(int n) {
        
            int[] memo = new int[n + 1];//备忘录初始化为 0
            return helper(memo, n);        
        }
    
        int helper(int[] memo, int n){
        
            if(n == 0 || n == 1){
        
                return n;
            }
            
            if(memo[n] != 0) return memo[n];// 已经计算过
            memo[n] = helper(memo, n - 1) + helper(memo, n - 2);
            return memo[n];
        }
    }

现在，画出递归树，你就知道「备忘录」到底做了什么：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center 1]

实际上，带「备忘录」的递归算法，把一棵存在巨量冗余的递归树通过「剪枝」，改造成了一幅不存在冗余的递归图，极大减少了子问题（即递归图中节点）的个数。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center 2]

本算法的时间复杂度是 O(n)。比起暴力算法，是降维打击。至此，带备忘录的递归解法的效率已经和迭代的动态规划一样了。实际上，这种解法和迭代的动态规划思想已经差不多，只不过这种方法叫做「自顶向下」，动态规划叫做「自底向上」。

\*\*啥叫「自顶向下」？\*\*注意我们刚才画的递归树（或者说图），是从上向下延伸，都是从一个规模较大的原问题比如说`f(20)`，向下逐渐分解规模，直到`f(1)`和`f(2)`触底，然后逐层返回答案，这就叫「自顶向下」。

\*\*啥叫「自底向上」？\*\*反过来，我们直接从最底下，最简单，问题规模最小的`f(1)`和`f(2)`开始往上推，直到推到我们想要的答案`f(20)`，这就是动态规划的思路，这也是为什么动态规划一般都脱离了递归，而是由循环迭代完成计算。

--------------------

**方法三：DP数组的迭代解法**

有了上一步「备忘录」的启发，我们可以把这个「备忘录」独立出来成为一张表，就叫做 DP table 吧，在这张表上完成「自底向上」的推算岂不美哉！

class Solution {
        
        public int fib(int n) {
        
            if(n == 1 || n == 0) return n;
            int[] dp = new int[n + 1];
            //basae case
            dp[1] = 1;
            //穷举循环
            for(int i = 2; i <= n; i++){
        
                dp[i] = dp[i-1] + dp[i-2]; 
            }
            return dp[n];
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center 3]

画个图就很好理解了，而且你发现这个 DP table 特别像之前那个「剪枝」后的结果，只是反过来算而已。实际上，带备忘录的递归解法中的「备忘录」，最终完成后就是这个 DP table，所以说这两种解法其实是差不多的，大部分情况下，效率也基本相同。

这里，引出「状态转移方程」这个名词，实际上就是描述问题结构的数学形式：  
![在这里插入图片描述][20210415212212103.png_pic_center]  
你会发现，上面的几种解法中的所有操作，例如 return f(n - 1) + f(n - 2)，dp\[i\] = dp\[i - 1\] + dp\[i - 2\]，以及对备忘录或 DP table 的初始化操作，都是围绕这个方程式的不同表现形式。可见列出「状态转移方程」的重要性，它是解决问题的核心。很容易发现，其实状态转移方程直接代表着暴力解法。

**千万不要看不起暴力解，动态规划问题最困难的就是写出状态转移方程**，即这个暴力解。优化方法无非是用备忘录或者 DP table，再无奥妙可言。

这个例子的最后，讲一个细节优化。细心的读者会发现，根据斐波那契数列的状态转移方程，当前状态只和之前的两个状态有关，其实并不需要那么长的一个 DP table 来存储所有的状态，只要想办法存储之前的两个状态就行了。所以，可以进一步优化，把空间复杂度降为 O(1)：

class Solution {
        
        public int fib(int n) {
        
            if(n == 1 || n == 0) return n;
            //basae case
            int pre = 0, cur = 1;
            //穷举循环
            for(int i = 2; i <= n; i++){
        
                int sum = pre + cur;
                pre = cur;
                cur = sum; 
            }
            return cur;
        }
    }

斐波那契数列的例子严格来说不算动态规划，因为没有涉及求最值，以上旨在演示算法设计螺旋上升的过程。下面根据斐波那契的例子，列举leetcode中的几道典型题目，来让大家对状态转移的过程有更深刻的理解。

--------------------

### 70. 爬楼梯（简单） ###

假设你正在爬楼梯。需要 *n* 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

\*\*注意：\*\*给定 *n* 是一个正整数。

输入： 2
    输出： 2
    解释： 有两种方法可以爬到楼顶。
    1.  1 阶 + 1 阶
    2.  2 阶

输入： 3
    输出： 3
    解释： 有三种方法可以爬到楼顶。
    1.  1 阶 + 1 阶 + 1 阶
    2.  1 阶 + 2 阶
    3.  2 阶 + 1 阶

\*\*解题思路：\*\*定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp\[i\] 表示走到第 i 个楼梯的方法数目。第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，所以走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。

状态转移方程： d p \[ i \] = d p \[ i − 1 \] + d p \[ i − 2 \] dp\[i\] = dp\[i-1\] + dp\[i-2\] dp\[i\]=dp\[i−1\]\+dp\[i−2\]

考虑到 dp\[i\] 只与 dp\[i - 1\] 和 dp\[i - 2\] 有关，因此可以只用两个变量来存储 dp\[i - 1\] 和 dp\[i - 2\]，使得原来的 O(N) 空间复杂度优化为 O(1) 复杂度。

public int climbStairs(int n) {
        
            //base case
            if(n == 1 || n == 2) return n; //n为正整数，所以不考虑0
            int pre = 1, cur = 2;
           //遍历循环
            for(int i = 3; i <= n; i++){
        
                int sum = pre + cur;
                pre = cur;
                cur = sum;
            }
            return cur;
        }

--------------------

### 198. 打家劫舍（中等） ###

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，**如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警**。

给定一个代表每个房屋存放金额的非负整数数组，计算你 **不触动警报装置的情况下** ，一夜之内能够偷窃到的最高金额。

输入：[1,2,3,1]
    输出：4
    解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
         偷窃到的最高金额 = 1 + 3 = 4 。

输入：[2,7,9,3,1]
    输出：12
    解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
         偷窃到的最高金额 = 2 + 9 + 1 = 12 。

\*\*解题思路：\*\*将原问题分解为多个子问题，那么对于第 k (k>2) 间房屋，有两个选项：

1.  偷窃第 k 间房屋，那么就不能偷窃第 k-1 间房屋，偷窃总金额为前 k-2 间房屋的最高总金额与第 k 间房屋的金额之和。
2.  不偷窃第 k 间房屋，偷窃总金额为前 k-1间房屋的最高总金额。

在两个选项中选择偷窃总金额较大的选项，该选项对应的偷窃总金额即为前 k 间房屋能偷窃到的最高总金额。

定义 dp 数组用来存储最大的抢劫量，其中 dp\[i\] 表示抢到第 i 个住户时的最大抢劫量，那么就有如下的状态转移方程：

d p \[ i \] = m a x ( d p \[ i − 1 \] , d p \[ i − 2 \] + n u m s \[ i \] ) dp\[i\] = max(dp\[i-1\], dp\[i-2\]+nums\[i\]) dp\[i\]=max(dp\[i−1\],dp\[i−2\]\+nums\[i\])

public int rob(int[] nums) {
        
            //base case
            if (nums == null || nums.length == 0) {
        
                return 0;
            }
            if(nums.length == 1) return nums[0];
            int pre = nums[0], cur = Math.max(nums[0], nums[1]); //利用数值存储前两个值可以减少空间复杂度
            for(int i = 2; i < nums.length; i++){
        
                int res = Math.max(cur, pre + nums[i]);
                pre = cur;
                cur = res;
            }
            return cur;
        }

--------------------

### 213. 打家劫舍 II（中等） ###

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 **围成一圈** ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，**如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警** 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 **在不触动警报装置的情况下** ，能够偷窃到的最高金额。

输入：nums = [2,3,2]
    输出：3
    解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

输入：nums = [1,2,3,1]
    输出：4
    解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
         偷窃到的最高金额 = 1 + 3 = 4 。

\*\*解题思路：\*\*与上题思路基本类似，不同的是在本题中由于房屋围绕成环形，因此第一个房子和最后一个房子不能同时偷窃，如果偷窃了第一间房屋，则不能偷窃最后一间房屋，因此偷窃房屋的范围是第一间房屋到最后第二间房屋；如果偷窃了最后一间房屋，则不能偷窃第一间房屋，因此偷窃房屋的范围是第二间房屋到最后一间房屋。

==假设数组 nums 的长度为 n。如果不偷窃最后一间房屋，则偷窃房屋的下标范围是 \[0,n−2\]；如果不偷窃第一间房屋，则偷窃房屋的下标范围是 \[1,n−1\]。==在确定偷窃房屋的下标范围之后，即可用第 198 题的方法解决。对于两段下标范围分别计算可以偷窃到的最高总金额，其中的最大值即为在 n 间房屋中可以偷窃到的最高总金额。

class Solution {
        
        public int rob(int[] nums) {
        
            //base case
            if(nums == null || nums.length == 0) return 0;
            int n = nums.length;
            if(n == 1) return nums[0];
            if(n == 2) return Math.max(nums[0], nums[1]);
            return Math.max(rob(nums, 0, n-2), rob(nums, 1, n-1));//重点在于数组的取值范围
        }
    
        private int rob(int[] nums, int first, int last){
        
            int pre = nums[first], cur = Math.max(nums[first], nums[first + 1]);
            for(int i = first + 2; i <= last; i++){
        
                int res = Math.max(pre + nums[i], cur);
                pre = cur;
                cur = res;
            }
            return cur;
        }
    }

--------------------

### 母牛生产（程序员代码面试指南-P181） ###

题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。

第 i 年成熟的牛的数量为： d p \[ i \] = d p \[ i − 1 \] + d p \[ i − 3 \] dp\[i\] = dp\[i - 1\] + dp\[i - 3\] dp\[i\]=dp\[i−1\]\+dp\[i−3\]

即上一年的成熟的牛的数量（即使刚生了小母牛也还未成熟）+ 新增成熟的牛的数量（三年前成熟的牛每头生产一只小母牛，三年后正好成熟）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/73fe48d8bdb747c5b4b8a495e4c77580.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/c8833fc04ae64f25ac04f6035db7273c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221022/3e2ce011ebb246fea908ff60c293865b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODc0MzE5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221022/c8a13b638a54406fab3c9337587cac5e.png
[20210415212212103.png_pic_center]: /images/20221022/a550f774574e4dd68a9d6ef34bc64586.png