Offer必备算法37_记忆化搜索_五道力扣题详解（由易到难）_力扣 记忆化搜索

目录

记忆化搜索概念和使用场景

①力扣509. 斐波那契数

解析代码1_循环

解析代码2_暴搜递归

解析代码3_记忆化搜索

解析代码4_动态规划

②力扣62. 不同路径

解析代码1_暴搜递归（超时）

解析代码2_记忆化搜索

解析代码3_动态规划

③力扣300. 最长递增子序列

解析代码1_爆搜递归（超时）

解析代码2_记忆化搜索

解析代码3_动态规划

④力扣375. 猜数字大小 II

解析代码1_爆搜递归（超时）

解析代码2_记忆化搜索

⑤力扣329. 矩阵中的最长递增路径

解析代码1_爆搜递归（超时）

解析代码2_记忆化搜索

本篇完。

---

记忆化搜索概念和使用场景

记忆化搜索是一种典型的空间换时间的思想，可以看成带备忘录的爆搜递归。

        搜索的低效在于没有能够很好地处理重叠子问题。在搜索过程中，会有很多重复计算，如果我们能记录一些状态的答案，就可以减少重复搜索量。动态规划虽然比较好地处理了重叠子问题，但是在有些拓扑关系比较复杂的题目面前，又显得无奈。记忆化搜索正是在这样的情况下产生的，它采用搜索的形式和动态规划中递推的思想将这两种方法有机地综合在一起，扬长避短，简单实用，在信息学中有着重要的作用。

        根据记忆化搜索的思想，它是解决重复计算，而不是重复生成，也就是说，这些搜索必须是在搜索扩展路径的过程中分步计算的题目，也就是“搜索答案与路径相关″的题目，而不能是搜索一个路径之后才能进行计算的题目，必须要分步计算，并且搜索过程中，一个搜索结果必须可以建立在同类型问题的结果上，也就是类似于动态规划解决的那种。

        记忆化搜索的典型应用场景是可能经过不同路径转移到相同状态的dfs问题。更明确地说，当我们需要在有层次结构的图（不是树，即当前层的不同节点可能转移到下一层的相同节点）中自上而下地进行dfs搜索时，大概率我们都可以通过记忆化搜索的技巧降低时间复杂度。

动态规划和记忆化搜索都是在爆搜的基础上优化。《算法导论》里也把记忆化搜索看成动态规划。

---

①力扣509. 斐波那契数

509. 斐波那契数

难度 简单

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

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

给定 n ，请计算 F(n) 。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 0 <= n <= 30

class Solution {
public:
    int fib(int n) {
 
    }
};

---

解析代码1_循环

求斐波那契数是很经典的一道题，有多种解法。

        下面会从递归解法得出记忆化搜索解法，在得出动态规划解法，循环的解法也可以看作动态规划的状态压缩，完成闭环。

class Solution {
public:
    int fib(int n) {
        if (n < 2)
            return n;
        int fib1 = 0, fib2 = 0, ret = 1;
        for (int i = 2; i <= n; ++i)
        {
            fib1 = fib2;
            fib2 = ret;
            ret = fib1 + fib2;
        }
        return ret;
    }
};

---

解析代码2_暴搜递归

暴搜递归：

• 递归含义：给 dfs 一个使命，给它一个数 n ，返回第 n 个斐波那契数的值。
• 函数体：斐波那契数的递推公式。
• 递归出口：当 n == 0 或者 n == 1 时，不用套公式。

class Solution {
public:
    int fib(int n) {
        return dfs(n);
    }
 
    int dfs(int n)
    {
        if(n <= 1)
            return n;
        return dfs(n - 1) + dfs(n - 2);
    }
};

---

解析代码3_记忆化搜索

记忆化搜索：

• 在递归的基础上加上一个备忘录（所以记忆化搜索也叫带备忘录的递归）。
• 每次进入递归的时候，去备忘录里面看看。
• 每次返回的时候，将结果加入到备忘录里面。

class Solution {
    int memo[31];
public:
    int fib(int n) {
        memset(memo, -1, sizeof(memo));
        return dfs(n);
    }
 
    int dfs(int n)
    {
        if(n <= 1)
            return n;
        if(memo[n] != -1)
            return memo[n];
 
        memo[n] = dfs(n - 1) + dfs(n - 2);
        return memo[n];
    }
};

---

解析代码4_动态规划

动态规划已经写过很多题了，这里根据记忆化搜索得出动态规划的解法：

• 递归含义：状态表示
• 函数体：状态转移方程
• 递归出口：初始化
• 填表顺序：填备忘录的顺序
• 返回值：备忘录的值

        可以看出都是类似的，因为两者本质都是一样的，都是在爆搜的基础上优化。《算法导论》里也把记忆化搜索看成动态规划。

        所以很多时候都可以把爆搜递归的代码改成记忆化搜索，再改成动态规划，不过爆搜改记忆化搜索已经完成时间的优化了，没太多必要改成动态规划了。

class Solution {
public:
    int fib(int n) {
        if(n == 0)
            return 0;
        vector<int> dp(n + 1);
        dp[1] = 1;
        for(int i = 2; i <= n; ++i)
        {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

---

②力扣62. 不同路径

62. 不同路径

难度 中等

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 10^9

class Solution {
public:
    int uniquePaths(int m, int n) {
 
    }
};

---

解析代码1_暴搜递归（超时）

• 递归含义：给 dfs 一个下标，返回从 [0, 0] 位置走到 [i, j] 位置一共有多少种方法。
• 函数体：只要知道到达上面位置的方法数以及到达左边位置的方法数，然后累加起来即可。
• 递归出口：当下标越界的时候返回 0 ，当位于起点的时候，返回 1 。

class Solution {
public:
    int uniquePaths(int m, int n) {
        return dfs(m, n);
    }
 
    int dfs(int sr, int sc)
    {
        if(sr == 0 || sc == 0)
            return 0;
        if(sr == 1 && sc == 1)
            return 1;
        return dfs(sr - 1, sc) + dfs(sr, sc - 1);
    }
};

---

解析代码2_记忆化搜索

记忆化搜索解法：

• 加上一个备忘录。
• 每次进入递归的时候，去备忘录里面看看。
• 每次返回的时候，将结果加入到备忘录里面。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> memo(m + 1, vector<int>(n + 1));
        return dfs(m, n, memo);
    }
 
    int dfs(int sr, int sc, vector<vector<int>>& memo)
    {
        if(sr == 0 || sc == 0)
            return 0;
        if(sr == 1 && sc == 1)
            return 1;
 
        if(memo[sr][sc] != 0)
            return memo[sr][sc];
        
        memo[sr][sc] = dfs(sr - 1, sc, memo) + dfs(sr, sc - 1, memo);
        return memo[sr][sc];
    }
};

---

解析代码3_动态规划

根据记忆化搜索得出动态规划的解法：

• 递归含义：状态表示
• 函数体：状态转移方程
• 递归出口：初始化
• 填表顺序：填备忘录的顺序
• 返回值：备忘录的值

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        dp[1][1] = 1;
        for(int i = 1; i <= m; ++i)
        {
            for(int j = 1; j <= n; ++j)
            {
                if(i == 1 && j == 1)
                    continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m][n];
    }
};

---

③力扣300. 最长递增子序列

300. 最长递增子序列

难度 中等

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

• 1 <= nums.length <= 2500
• -10^4 <= nums[i] <= 10^4

进阶：

• 你能将算法的时间复杂度降低到 O(n log(n)) 吗?

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
 
    }
};

---

解析代码1_爆搜递归（超时）

• 递归含义：给 dfs 一个数 i ，返回以 i 位置为起点的最长增子序列的长度。
• 函数体：遍历 i 后面的所有位置，看谁能加到 i 这个元素的后面。统计所有情况下的最大值。
• 递归出口：因为是判断之后再进入递归的，因此没有出口。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int sz = nums.size(), ret = 1;
        for(int i = 0; i < sz; ++i)
        {
            ret = max(ret, dfs(i, nums));
        }
        return ret;
    }
 
    int dfs(int pos, vector<int>& nums)
    {
        int sz = nums.size(), ret = 1;
        for(int i = pos + 1; i < sz; ++i)
        {
            if(nums[i] > nums[pos])
                ret = max(ret, dfs(i, nums) + 1);
        }
        return ret;
    }
};

---

解析代码2_记忆化搜索

记忆化搜索解法：

• 加上一个备忘录。
• 每次进入递归的时候，去备忘录里面看看。
• 每次返回的时候，将结果加入到备忘录里面。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int sz = nums.size(), ret = 1;
        vector<int> memo(sz);
        for(int i = 0; i < sz; ++i)
        {
            ret = max(ret, dfs(i, nums, memo));
        }
        return ret;
    }
 
    int dfs(int pos, vector<int>& nums, vector<int>& memo)
    {
        if(memo[pos] != 0)
            return memo[pos];
        int sz = nums.size(), ret = 1;
        for(int i = pos + 1; i < sz; ++i)
        {
            if(nums[i] > nums[pos])
                ret = max(ret, dfs(i, nums, memo) + 1);
        }
        memo[pos] = ret;
        return ret;
    }
};

---

解析代码3_动态规划

根据记忆化搜索得出动态规划的解法：

• 递归含义：状态表示
• 函数体：状态转移方程
• 递归出口：初始化
• 填表顺序：填备忘录的顺序
• 返回值：备忘录的值

        注意这里填表顺序有点不一样，因为记忆化搜索填pos位置的值的时候，依赖的是pos后面的值，所以动态规划解法的代码，填表顺序是从后往前填表。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int sz = nums.size(), ret = 1;
        vector<int> dp(sz, 1);
        for(int i = sz - 2; i >= 0; --i)
        {
            for(int j = i + 1; j < sz; ++j)
            {
                if(nums[j] > nums[i])
                    dp[i] = max(dp[i], dp[j] + 1);
            }
            ret = max(ret, dp[i]);
        }
        return ret;
    }
};

---

④力扣375. 猜数字大小 II

375. 猜数字大小 II

难度 中等

我们正在玩一个猜数游戏，游戏规则如下：

1. 我从 1 到 n 之间选择一个数字。
2. 你来猜我选了哪个数字。
3. 如果你猜到正确的数字，就会 赢得游戏 。
4. 如果你猜错了，那么我会告诉你，我选的数字比你的 更大或者更小 ，并且你需要继续猜数。
5. 每当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。如果你花光了钱，就会 输掉游戏 。

给你一个特定的数字 n ，返回能够 确保你获胜 的最小现金数，不管我选择那个数字 。

示例 1：

输入：n = 10
输出：16
解释：制胜策略如下：
- 数字范围是 [1,10] 。你先猜测数字为 7 。
    - 如果这是我选中的数字，你的总费用为 $0 。否则，你需要支付 $7 。
    - 如果我的数字更大，则下一步需要猜测的数字范围是 [8,10] 。你可以猜测数字为 9 。
        - 如果这是我选中的数字，你的总费用为 $7 。否则，你需要支付 $9 。
        - 如果我的数字更大，那么这个数字一定是 10 。你猜测数字为 10 并赢得游戏，总费用为 $7 + $9 = $16 。
        - 如果我的数字更小，那么这个数字一定是 8 。你猜测数字为 8 并赢得游戏，总费用为 $7 + $9 = $16 。
    - 如果我的数字更小，则下一步需要猜测的数字范围是 [1,6] 。你可以猜测数字为 3 。
        - 如果这是我选中的数字，你的总费用为 $7 。否则，你需要支付 $3 。
        - 如果我的数字更大，则下一步需要猜测的数字范围是 [4,6] 。你可以猜测数字为 5 。
            - 如果这是我选中的数字，你的总费用为 $7 + $3 = $10 。否则，你需要支付 $5 。
            - 如果我的数字更大，那么这个数字一定是 6 。你猜测数字为 6 并赢得游戏，总费用为 $7 + $3 + $5 = $15 。
            - 如果我的数字更小，那么这个数字一定是 4 。你猜测数字为 4 并赢得游戏，总费用为 $7 + $3 + $5 = $15 。
        - 如果我的数字更小，则下一步需要猜测的数字范围是 [1,2] 。你可以猜测数字为 1 。
            - 如果这是我选中的数字，你的总费用为 $7 + $3 = $10 。否则，你需要支付 $1 。
            - 如果我的数字更大，那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏，总费用为 $7 + $3 + $1 = $11 。
在最糟糕的情况下，你需要支付 $16 。因此，你只需要 $16 就可以确保自己赢得游戏。

示例 2：

输入：n = 1
输出：0
解释：只有一个可能的数字，所以你可以直接猜 1 并赢得游戏，无需支付任何费用。

示例 3：

输入：n = 2
输出：1
解释：有两个可能的数字 1 和 2 。
- 你可以先猜 1 。
    - 如果这是我选中的数字，你的总费用为 $0 。否则，你需要支付 $1 。
    - 如果我的数字更大，那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏，总费用为 $1 。
最糟糕的情况下，你需要支付 $1 。

提示：

• 1 <= n <= 200

class Solution {
public:
    int getMoneyAmount(int n) {
 
    }
};

---

解析代码1_爆搜递归（超时）

• 递归含义：给 dfs 一个区间 [left, right] ，返回在这个区间上能完胜的最小费用。
• 函数体：选择 [left, right] 区间上的任意一个数作为头结点，然后递归分析左右子树。 求出所有情况下的最小值。因为要得到这个区间上能完胜的最小费用，所以选择左右子树时要求最大值。
• 递归出口：当 left >= right 的时候，直接返回 0 。

class Solution {
public:
    int getMoneyAmount(int n) {
        return dfs(1, n);
    }
 
    int dfs(int left, int right)
    {
        if(left >= right)
            return 0;
        int ret = INT_MAX;
        for(int i = left; i <= right; ++i)
        {
            ret = min(ret, max(dfs(left, i - 1), dfs(i + 1, right)) + i);
        }
        return ret;
    }
};

---

解析代码2_记忆化搜索

记忆化搜索解法：

• 加上一个备忘录。
• 每次进入递归的时候，去备忘录里面看看。
• 每次返回的时候，将结果加入到备忘录里面。

class Solution {
    int memo[201][201];
public:
    int getMoneyAmount(int n) {
        return dfs(1, n);
    }
 
    int dfs(int left, int right)
    {
        if(left >= right)
            return 0;
        if(memo[left][right] != 0)
            return memo[left][right];
        int ret = INT_MAX;
        for(int i = left; i <= right; ++i)
        {
            ret = min(ret, max(dfs(left, i - 1), dfs(i + 1, right)) + i);
        }
        memo[left][right] =ret;
        return ret;
    }
};

---

⑤力扣329. 矩阵中的最长递增路径

329. 矩阵中的最长递增路径

难度 困难

给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你 不能 在 对角线 方向上移动或移动到 边界外（即不允许环绕）。

示例 1：

输入：matrix = [[9,9,4],[6,6,8],[2,1,1]]
输出：4 
解释：最长递增路径为 [1, 2, 6, 9]。

示例 2：

输入：matrix = [[3,4,5],[3,2,6],[2,2,1]]
输出：4 
解释：最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

示例 3：

输入：matrix = [[1]]
输出：1

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 200
• 0 <= matrix[i][j] <= 2^31 - 1

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
 
    }
};

---

解析代码1_爆搜递归（超时）

• 递归含义：给 dfs 一个下标 [i, j] ，返回从这个位置开始的最长递增路径的长度。
• 函数体：上下左右四个方向看一看，哪里能过去就过去，统计四个方向上的最大长度。
• 递归出口：因为是先判断再进入递归，因此没有出口。

class Solution {
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {1, -1, 0, 0};
    int m = 0, n = 0;
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        m = matrix.size(), n = matrix[0].size();
        int ret = 0;
        for(int i = 0; i < m; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                ret = max(ret, dfs(i, j, matrix));
            }
        }
        return ret + 1; // 加上自己
    }
 
    int dfs(int sr, int sc, vector<vector<int>>& matrix)
    {
        int ret = 0;
        for(int i = 0; i < 4; ++i)
        {
            int x = sr + dx[i], y = sc + dy[i];
            if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[sr][sc])
            {
                ret = max(ret, dfs(x, y, matrix) + 1);
            }
        }
        return ret;
    }
};

---

解析代码2_记忆化搜索

记忆化搜索解法：

• 加上一个备忘录。
• 每次进入递归的时候，去备忘录里面看看。
• 每次返回的时候，将结果加入到备忘录里面。

class Solution {
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {1, -1, 0, 0};
    int m = 0, n = 0;
    int memo[201][201];
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        m = matrix.size(), n = matrix[0].size();
        int ret = 0;
        for(int i = 0; i < m; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                ret = max(ret, dfs(i, j, matrix));
            }
        }
        return ret + 1; // 加上自己
    }
 
    int dfs(int sr, int sc, vector<vector<int>>& matrix)
    {
        if(memo[sr][sc] != 0)
            return memo[sr][sc];
        int ret = 0;
        for(int i = 0; i < 4; ++i)
        {
            int x = sr + dx[i], y = sc + dy[i];
            if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[sr][sc])
            {
                ret = max(ret, dfs(x, y, matrix) + 1);
            }
        }
        memo[sr][sc] = ret;
        return ret;
    }
};

---

本篇完。

下一篇是贪心算法的第四部分。