一.记忆化搜索概述

1.概念

搜索是一种简单有效但是效率又很低下的算法结构，其低效的原因主要在于存在很多重叠子问题。而记忆化搜索则是在搜索的基础上，利用数组来记录已经计算出来的重叠子问题状态，进行合理化的剪枝，从而降低时间复杂度。这个记录状态的过程就是记忆化的过程，我们需要找到不同搜索层次之间的子问题、状态转移关系，这与动态规划的思想又不谋而合。

简单来说，记忆化搜索是一种典型的空间换时间的思想，记忆化搜索 = 深度优先搜索实现 + 动态规划思想（记录状态、剪枝）。

2.图示

此处以某个记忆化搜索题目的结构树为例。在搜索过程中，我们将问题的搜索树画出来如下所示。左侧为暴力搜索的搜索树，而右侧为记忆化搜索剪枝的搜索树。

记忆化搜索可以看作是动态规划的前置过程，或者说记忆化搜索一般是自顶向下的，而动态规划一般是自底向上的。

二.例题

1.LeetCode 45. 跳跃游戏改

给定一个长度为 n 的整数数组 nums。初始位置为 nums[0]。每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处（0 <= j <= nums[i]）

返回到达 nums[n - 1] 的最小跳跃次数。已知跳跃次数有上限K，若无法在K次内到达则返回 -1

（1）记忆化搜索

对于该题，我们可以先求出到达终点的最小跳跃次数 t，然后比较 t 与上限 K 的大小，若t > K则返回 -1 。

按照搜索的思想来说，我们在到达某个索引 i 时，该位置到达终点的最小跳跃次数取决于 min(dfs(i) , dfs(i+j) + 1)，0 <= j <= nums[i] ；按照记忆化的思想，像最短路一样，某个位置 i 到达终点的最小跳跃次数应该是确定的，属于重叠子问题，不应该重复搜索，因此可以使用数组记录每个位置的最小次数。

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000 + 7;
int n,k,nums[maxn],mem[maxn];

int dfs(int index){
    if(index >= n-1)return 0;
    if(mem[index]!=-1)return mem[index];//记忆化
    int ans = -1;
    for(int i = 1;i<=nums[index];i++){
        int res = dfs(index+i)+1;
        if(res != 0){
            ans = ans==-1?res:min(ans,res);
        }
    }
    return mem[index] = ans;
}

int main()
{
    memset(mem,-1,sizeof(mem));
    scanf("%d%d",&n,&k);
    for(int i = 0;i<n;i++){
        scanf("%d",&nums[i]);
    }
    dfs(0);
    if(mem[0] == -1 || mem[0] > k)printf("-1\n");
    else printf("%d\n",mem[0]);
}

（2）贪心

记忆化搜索的方式可行，但是复杂度还是有点高会超时。我们重新来审视这个题，每个位置处的跳跃距离是固定的、相互独立的，与之前的子节点和之后的子节点都是没关系的，也就是说该题其实与动态规划思想无关。

考虑现在跳到了位置 i ，那么接下来应该选择跳到 i+1 ~ i+nums[i] 的哪个位置呢？答案是「贪心」地选择能跳跃到距离最后一个位置最远的那个位置（即使得“探索序列”能够拓宽最远的那个位置），原因是以该位置为下一次起跳点所能到达的地方，由于其是最远的，所以能够覆盖其他所有的起跳点位置范围，这肯定是最优的。

当一次跳跃结束时，从下一个格子开始，到现在 能跳到最远的距离，都是下一次跳跃的 起跳点。所以跳完一次之后，不断更新维护下一次 起跳点的范围。在新的范围内跳，更新 能跳到最远的距离。

int jump(int len){
    int ans = 0;
    int start = 0,last = 0; //初始起跳范围 [0,0] 闭区间
    while(last < len - 1){
        int maxpos = 0;
        //选择下一次跳哪个
        for(int i = start;i<=last;i++){
            maxpos = max(maxpos,i+nums[i]);
        }
        start = last+1; // 下一次起跳点范围开始的格子
        last = maxpos;  // 下一次起跳点范围结束的格子
        ans++; // 跳跃次数
    }
    return ans;
}

2. 青蛙过河

一只青蛙想要过河。假定河流被等分为若干个单元格，并且在每一个单元格内都有可能放有一块石子（也有可能没有）。青蛙可以跳上石子，但是不可以跳入水中。

假设河流中一共有 n 个石子，给你每个石子的河流单元格位置的列表 stones（用单元格序号升序表示），请判定青蛙能否成功过河（即能否在最后一步跳至最后一块石子上）。

开始时，青蛙默认已站在第一块石子上，并可以假定它第一步只能跳跃一个单位（即只能从单元格1 跳至单元格 2 ）。如果青蛙上一步跳跃了 k 个单位，那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1 个单位。另请注意，青蛙只能向前方（终点的方向）跳跃。
输入：stones = [0,1,3,5,6,8,12,17]
输出：true
解释：青蛙可以成功过河，按照如下方案跳跃：跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, 接着 跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, 最后，跳 5 个单位到第 8 个石子（即最后一块石子）。

该题题意与上一题的跳跃游戏类似，但是二者很大的一个不同就是每个位置的跳跃范围：跳跃游戏中每个位置的跳跃范围是固定的、相互独立的，而该题中每个位置的跳跃范围受到上一次跳跃的影响，具有子结构，因此该题优先考虑动态规划或记忆化搜索。

对于记忆化搜索来说，我们可以仍然去搜索所有可能的路径。但是对于每个节点来说，他的状态主要受到两个因素的影响：当前所在 stone 下标位置、上一次跳的步长，这两个因素决定了该位置后续的最优解。因此我们可以使用一个二维数组 dp[i][j] 保留位置 i 时，上个步长为 j 时的能否到达状态，以此进行记忆化搜索。

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000 + 7;
int n,stones[maxn];
vector<unordered_map<int, bool>> dp;

bool dfs(int index,int preSteps){
    if(index == n-1)return true;
    if(index >= n)return false;
    if(dp[index].count(preSteps))return dp[index][preSteps];
    bool res = false;
    for(int i = preSteps-1;i<=preSteps+1;i++){
        if(i<=0)continue;
        int nextpos = lower_bound(stones+index, stones+n, stones[index]+i) - stones;
        if(nextpos < n && stones[nextpos] == stones[index]+i){
             res = dfs(nextpos,i);
             if(res)break;
        }
    }
    return dp[index][preSteps] = res;
}

int main()
{
    scanf("%d",&n);
    dp.resize(n); // 初始化 vector 空间长度，int默认填充0，此处默认填充 空map
    for(int i = 0;i<n;i++){
        scanf("%d",&stones[i]);
    }
    bool ans = dfs(0,0);
    if(ans)printf("true\n");
    else printf("false\n");
    return 0;
}

ACM 记忆化搜索