记忆化DFS——普适且高效的解题武器

记忆化DFS——普适且高效的解题武器

​ 前言：我们知道，DFS是一种很普适的解题方法，常常能够用来解决许多问题。曾有一句戏言，只要你会搜索，尤其是DFS，你就可以拿奖。DFS既可以做BFS的题目，也可以做DP的题目，也可以做他们俩解决不了的问题。DFS的解题普适十分强大。但是，DFS也存在一系列问题。其中最大的问题，就是时空效率问题。用DFS解题，我们时常会碰到MLE、TLE。

​ 那么如何让DFS变成一个解题普适性又强、又高效率的搜索方法呢？答案，就在本讲。（本文大多数思路为本人原创，如有错误，欢迎指正。）

为什么常规的DFS容易爆掉（TLE、MLE）？

​ 常规的DFS容易爆掉，最根本的原因，就是其**在不断调用递归的过程中，存在着大量的低效率的重复计算。**我们以下题为例：

图1.第一道DFS例题

​ 在这道题中（本题传送门），常规DFS的思路很好想，起点的到终点路径数，就是起点接下一步每一个可以达到的点的到终点路径数的总和，而下一步可达到的点的到终点路径数，就是下一步的下一步可达到点的到终点路径数总和，以此类推，推到终点，就返回1给上一个点，因为每抵达一次终点，说明有1条路径，那么就返回一次1。代码如下：

#include<bits/stdc++.h>
using namespace std;
int mp[102][102],n,m,t;
int check(int a,int b){	//边界检查 
    if(a>=1&&a<=n&&b>=1&&b<=m)return true;
    return false;
}
//重点部分：9~18行
int dfs(int x,int y){//爆搜从x,y点开始到终点的可行路径总数 
 	if(x==n&&y==m)return 1;	//如果是终点，说明一条路径成功抵达，返回1 
    int ans=0;	//存储本次搜索的答案 
    for(int i=0;i<=mp[x][y];i++) //遍历下一步所有的可能 
        for(int j=0;j<=mp[x][y]-i;j++){
            if(check(x+i,y+j))
            ans=(dfs(x+i,y+j)+ans)%10000;//答案就是累加所有下一步的路径数 
        }
    return ans;//返回答案 
}
int main(){
    ios::sync_with_stdio(false);
    cin>>t;
    while(t--){
        cin>>n>>m;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                cin>>mp[i][j];
            }
        cout<<dfs(1,1)<<endl;//输出从起点开始到终点的路径总数
    }
    return 0;
}

​ 乍一看，思路肯定是可行的。但是将代码上传到OJ的时候，我们遇到了刚才讲到的问题，爆了。

图2.以上代码提交至OJ评测的最终结果

​ 为什么会爆呢？根本原因，还是刚才说的，过多的重复计算，不仅仅占用内存，也影响速度。重复计算源自哪里？，比如说，从起点到3，3点，要计算一次dfs（3，3），但是棋盘上有许多点，都可以到3，3点，如2，3点，如3，2点，如4，3点，如3，4点，但是每一次计算的都是dfs（3，3），dfs（3，3）被重复执行了很多次。

​ 再6*6的棋盘里，从起点开始，走到3，3点的路径数是非常多的了，我个人猜测至少大于十万级别，而3，3尚且只是一个点，便有了如此多的重复计算，那么棋盘上所有的点，都经历这样的重复计算，实质上浪费时间的量级，就非常非常大了。

​ 如何才能够让每一个点的路径数只计算一遍，即省去一切的重复计算呢？答案就是使用记忆化DFS。

什么是记忆化DFS？

​ 记忆化DFS，顾名思义，就是带有记忆的DFS。到实际操作中，就是在每一次计算dfs(x,y)的时候，就把x，y点的dfs计算结果存储起来，下一次再调用的时候，直接返回存储值即可。还是图1那一道题目，我们记忆化dfs的代码，可以设计成这样：

#include<bits/stdc++.h>
using namespace std;
int mp[102][102],ans[102][102]/*结果数组，用于记忆dfs的结果，一定要是全局数组才行*/,n,m,t;
int check(int a,int b){
    if(a>=1&&a<=n&&b>=1&&b<=m)return true;
    return false;
}
int dfs(int x,int y){
    if(ans[x][y]>=0)return ans[x][y];//如果该点的结果数组里有结果了，直接返回该点的结果数组的值
    ans[x][y]=0;
    for(int i=0;i<=mp[x][y];i++)
        for(int j=0;j<=mp[x][y]-i;j++){
            if(check(x+i,y+j))
            ans[x][y]=(dfs(x+i,y+j)+ans[x][y])%10000;//将该点的计算结果都存储在该点的结果数组中
        }
    return ans[x][y];//返回结果数组
}
int main(){
    ios::sync_with_stdio(false);
    cin>>t;
    while(t--){
        cin>>n>>m;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                cin>>mp[i][j];
            }
        memset(ans,-1,sizeof(ans));
        ans[n][m]=1;//终点的结果数组是1，之前已经说明过
        cout<<dfs(1,1)<<endl;
    }
    return 0;
}

是否有实现DFS记忆化的通用思路？

​ 知道了记忆化DFS，我们最重要地，还是熟练运用记忆化DFS，而要熟练运用某一样东西，就一定要知道这个东西的通用思路，接下来，就是在已有DFS代码的基础上，实现DFS记忆化的通用思路。

​ 记忆化DFS第一步——创建：创建与题目描述的内容状态转移时，与状态同属性的结果数组。

​ 例如，刚才的棋盘，状态转移本质上就是从一个点，转移到另一个点。每一个点的属性，就是横纵坐标，那么结果数组就应该是一个二维数组。

​ 但是，数组也有可能是一维、三维的，具体要依据题目，来判断数组的维度，也即刚才说的属性。

​ 记忆化DFS第二步——预备：将结果数组依据题意初始化，再将出口存储在结果数组中。

​ 记忆化DFS第三步——改头：在DFS函数内部，开头的部分就判断结果数组是否有值，有就直接返回结果数组值。

​ 记忆化DFS第四步——改尾：在DFS函数内部，结尾的部分直接返回结果数组。

​ 记忆化DFS第五步——改中间：在DFS函数内部，中间的部分将一切计算结果保存在当前状态的结果数组中。

​ 一句话，就是“创建预备，改头改尾改中间”，还是挺好记的。

​ 接下来，我们看看，这句话是如何在上述修改后的代码中呈现的。

#include<bits/stdc++.h>
using namespace std;
int mp[102][102],ans[102][102]/*创建：创建同属性结果数组*/,n,m,t;
int check(int a,int b){
    if(a>=1&&a<=n&&b>=1&&b<=m)return true;
    return false;
}
int dfs(int x,int y){
    if(ans[x][y]>=0)return ans[x][y];/*改头：存在结果值，返回结果值*/
    ans[x][y]=0;
    for(int i=0;i<=mp[x][y];i++)
        for(int j=0;j<=mp[x][y]-i;j++){
            if(check(x+i,y+j))
            ans[x][y]=(dfs(x+i,y+j)+ans[x][y])%10000;/*改中间：计算结果，一律存于结果数组*/
        }
    return ans[x][y];/*改尾：返回当前状态的结果数组*/
}
int main(){
    ios::sync_with_stdio(false);
    cin>>t;
    while(t--){
        cin>>n>>m;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                cin>>mp[i][j];
            }
        memset(ans,-1,sizeof(ans));/*预备：初始化结果数组*/
        ans[n][m]=1;/*预备：存储出口*/
        cout<<dfs(1,1)<<endl;
    }
    return 0;
}

参考

《2021杭电ACM-LCY算法培训入门班第12节课》