记忆化搜索（5题）

是什么？ 是一个带备忘录的递归

如何实现记忆化搜索

1.添加一个备忘录（建立一个可变参数和返回值的映射关系）

2.递归每次返回的时候把结果放到备忘录里

3.在每次进入递归的时候往备忘录里面看看。

目录

1.斐波那契数列

2.不同路径

3.最长递增子序列

4.猜数字大小2

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

---

1.斐波那契数列

LCR 126. 斐波那契数 - 力扣（LeetCode）

         我们再看看动态规划的做法。我们发现其实两者具有一一对应的关系，只不过一种是用递归形式呈现，另一种是用递推形式呈现

小问题：

1. 所有的递归（暴搜、深搜），都能改成记忆化搜索吗？

不是的，只有在递归的过程中，出现了大量完全相同的问题时，才能用记忆化搜索的方式优化

2.带备忘录的递归vs动态规划 vs记忆化搜索

本质上是一回事

3.自顶向下  vs  自低向上

不同的看待问题的方式

4.暴搜->记忆化搜索->动态规划

可以为我们的动态规划提供一个方向

        我们创建一个备忘录的时候需要在里面填入一个不可能取到的值，以此来判断备忘录是否已经更新

class Solution {
public:int memo[110];//一个备忘录int fib(int n) {memset(memo, -1, sizeof(memo));return dfs(n);}int dfs(int n){if(memo[n] != -1)return memo[n];//每次进入的时候查看备忘录里面是否存值if(n == 1){memo[1] = 1;return memo[1];//返回之前把值存到备忘录里面}else if(n == 0){memo[0] = 0;return memo[0];}else {memo[n] = (dfs(n-1) + dfs(n - 2))%1000000007;return memo[n];}}
};

2.不同路径

62. 不同路径 - 力扣（LeetCode）

1.暴力搜索（会超时）

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

2.记忆化搜索

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

3.最长递增子序列

 300. 最长递增子序列 - 力扣（LeetCode）

1.暴搜（会超时） 

dfs（pos）的任务是返回以nums[pos]为开头的最长子序列

我们在主函数里面从头开始遍历一次，找到最大的那个，ret 一开始为0.

在dfs函数中，ret一开始为1，因为已经进入dfs函数的情况下最少也有一个数。

我们从pos的下一位开始，遍历到结尾，每遍历到一个位置我们判断这个值是否比nums【i】大，如果更大说明它可以连接到nums【i】后面，我们再更新ret， ret = max(ret, dfs(nums, i) + 1);

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

2.记忆化搜索

记录数据需要在返回之前记录。

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

3.递归代码

dp[i]表示的是从i下标开始最大的一个子序列。

因此我们从末尾开始填dp表，每个位置最小的子序列是自身，因此dp表每个位置先赋值为1.

 每次进行比较之后才更新

 if(nums[i] < nums[j])
                {
                    dp[i] = max(dp[i], dp[j] + 1);
                }

最后的结果从dp表里面挑一个最大的即可。

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

4.猜数字大小2

375. 猜数字大小 II - 力扣（LeetCode）

1.暴搜（会超时）

这题让我们求  不管猜的是哪个数字 确保获胜  的最小金额

        首先，猜的策略有很多种，我们用暴力搜索，从小到大依次以某个值为根，然后分出两个树，继续对两个树进行相同的操作。

我们要确保无论它让我们猜哪个值都要获胜，那么就应该找每棵树里面花钱最多的策略，

我们使得int l = dfs(left,i - 1);
            int r = dfs(i + 1, right);

花钱最多的 即根节点+ 左右两树中花钱多的即 i + max(l, r) ， 

同时又要最少金额，那么就从各种一定会获胜的金额中取出最小的即可

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++){int l = dfs(left,i - 1);int r = dfs(i + 1, right);ret = min(ret, i + max(l, r));}return ret;}
};

2.记忆化搜索

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

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

 LCR 112. 矩阵中的最长递增路径 - 力扣（LeetCode）

 

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