【ps】本篇有 5 道 leetcode OJ。
目录
一、算法简介
二、相关例题
1）斐波那契数
.1- 题目解析
.2- 代码编写
2）不同路径
.1- 题目解析
.2- 代码编写
3）最长递增子序列
.1- 题目解析
.2- 代码编写
4）猜数字大小 II
.1- 题目解析
.2- 代码编写
5）矩阵中的最长递增路径
.1- 题目解析
.2- 代码编写
一、算法简介
记忆化搜索是一种典型的空间换时间的思想，可以看成带备忘录的爆搜递归。
搜索的低效在于没有能够很好地处理重叠子问题。在搜索过程中，会有很多重复计算，如果我们能记录一些状态的答案，就可以减少重复搜索量。动态规划虽然比较好地处理了重叠子问题，但是在有些拓扑关系比较复杂的题目面前，又显得无奈。记忆化搜索正是在这样的情况下产生的，它采用搜索的形式和动态规划中递推的思想将这两种方法有机地综合在一起，扬长避短，简单实用，在信息学中有着重要的作用。
根据记忆化搜索的思想，它是解决重复计算，而不是重复生成，也就是说，这些搜索必须是在搜索扩展路径的过程中分步计算的题目，也就是“搜索答案与路径相关″的题目，而不能是搜索一个路径之后才能进行计算的题目，必须要分步计算，并且搜索过程中，一个搜索结果必须可以建立在同类型问题的结果上，也就是类似于动态规划解决的那种。
记忆化搜索的典型应用场景是可能经过不同路径转移到相同状态的dfs问题。更明确地说，当我们需要在有层次结构的图（不是树，即当前层的不同节点可能转移到下一层的相同节点）中自上而下地进行 DFS 搜索时，我们一般可以通过记忆化搜索的技巧降低时间复杂度。
二、相关例题
1）斐波那契数
509. 斐波那契数
.1- 题目解析
斐波那契数列可以用很多种方法实现，例如循环、递推、递归、动态规划（dp）、记忆化搜索、矩阵快速幂等，能运用很多知识也十分锻炼代码能力。
所谓记忆化搜索，就是在进行递归时，存在完全相同的子问题，此时可以把该子问题的结果存在一个“备忘录”中（一般为一个全局的哈希表），避免后续重复求解该子问题，进而增加代码的运行效率。
由递归和记忆化搜索，可以引申出另一个算法——动态规划（dp）。
.2- 代码编写
//循环方式
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;
}
};//dfs方式（递归）
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);
}
};//记忆化搜索方式
class Solution {
int mem[31];//备忘录，本质是一个哈希表，存的是可变参数和递归返回值之间的映射
public:
int fib(int n) {
memset(mem,-1,sizeof(mem)); //初始化备忘录
return dfs(n);
}
int dfs(int n)
{
if(mem[n]!=-1) //查找一下备忘录，若已进入过该状态，就不再进入了，直接向上返回（相当于剪枝）
return mem[n];
if(n==0 || n==1)
{
mem[n]=n; //填备忘录
return n;
}
mem[n]=dfs(n-1)+dfs(n-2);//填备忘录
return mem[n];
}
};//dp方式
class Solution {
int dp[31];
public:
int fib(int n) {
dp[0]=0,dp[1]=1;//初始化
for(int i=2;i<=n;i++)//填表顺序
dp[i]=dp[i-1]+dp[i-2];//状态转移方程
return dp[n];//返回值
}
};2）不同路径
62. 不同路径
.1- 题目解析
对于网格中的某一个格子，它左侧的格子和上方的格子均只需一步就能到达它，也就是说，对于左侧的格子，有多少种到达它左侧格子的方式就有多少到达它的方式，同理，对于上方的格子，有多少种到达它上方格子的方式也就有多少到达它的方式，那么，到达某一个格子有多少种方式，其实就是到达它左侧的格子和上方的格子的方式之和。
.2- 代码编写
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> mem(m+1,vector<int>(n+1));//防越界，合理地映射下标
return dfs(m,n,mem);
}
int dfs(int i,int j,vector<vector<int>>& mem)
{
if(mem[i][j]!=0)return mem[i][j];//查备忘录剪枝
if(i==0 || j==0)return 0;//边界上的格子
if(i==1 && j==1) //紧邻边界的开始出发的格子
{
mem[i][j]=1;
return 1;
}
mem[i][j]=dfs(i-1,j,mem)+dfs(i,j-1,mem);//填备忘录
return mem[i][j];
}
};3）最长递增子序列
300. 最长递增子序列
.1- 题目解析
我们可以以一个元素作为起点，去 DFS 它之后的元素，如果它之后的元素能够和它形成递增序列，就统计这个序列的长度。
显然在这个 DFS 的过程中会出现重复的子问题，那么我们就可以通过记忆化搜索的方式来保存重复子问题的结果。
.2- 代码编写
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n=nums.size();
vector<int> mem(n);
int ret=0;
for(int i=0;i<nums.size();i++)//将每一个元素作为起点分别DFS
ret=max(ret,dfs(i,nums,mem));
return ret;
}
int dfs(int pos,vector<int>& nums,vector<int>& mem)
{
if(mem[pos]!=0)return mem[pos];
int ret=1;//序列中至少有一个元素
for(int i=pos+1;i<nums.size();i++)
{
if(nums[i]>nums[pos])
{
ret=max(ret,dfs(i,nums,mem)+1);
}
}
mem[pos]=ret;
return mem[pos];
}
};4）猜数字大小 II
375. 猜数字大小 II
.1- 题目解析
1 到 n 之间的数可以构成一棵棵二叉搜索树，题目要求返回能够获胜的最小现金数，其实是要求某一数字作为根节点时，其左右子树中的最大值（返回左右子树的最大值，才能保证所有叶子节点是可选的，才不会输游戏），然后求出这些数字作为根节点时所得到的值中的最小值。
显然在 DFS 一棵棵二叉搜索树时，存在重复的情况，我们可以用一个备忘录保存它们的结果来进行剪枝。
.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 head = left; head <= right; head++) // 选择头结点
{
int x = dfs(left, head - 1);
int y = dfs(head + 1, right);
ret = min(ret, head + max(x, y));
}
memo[left][right] = ret;//填备忘录
return ret;
}
};5）矩阵中的最长递增路径
329. 矩阵中的最长递增路径
.1- 题目解析
遍历所有的方格，分别以它们为起点进行 DFS，找出最长递增路径即可。
显然在 DFS 所有路径时，存在重复的情况，我们可以用一个备忘录保存它们的结果来进行剪枝。
.2- 代码编写
class Solution {
int m, n;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int memo[201][201];
public:
int longestIncreasingPath(vector<vector<int>>& matrix) {
int ret = 0;
m = matrix.size(), n = matrix[0].size();
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
ret = max(ret, dfs(matrix, i, j));
}
return ret;
}
int dfs(vector<vector<int>>& matrix, int i, int j) {
if (memo[i][j] != 0)
return memo[i][j];
int ret = 1;
for (int k = 0; k < 4; k++) {
int x = i + dx[k], y = j + dy[k];
if (x >= 0 && x < m && y >= 0 && y < n &&
matrix[x][y] > matrix[i][j]) {
ret = max(ret, dfs(matrix, x, y) + 1);
}
}
memo[i][j] = ret;
return ret;
}
};
