记忆化搜索

今天每日一题可以用dp做，但是看答案有人用记忆化搜索，以前也经常听到这个名词，so今天好好来学一下，什么是记忆化搜索。

参考链接

以Fibonacci为例

int f(unsigned int n) {
    if(n <= 1) {
        return 1;
    }
    return f(n-1) + f(n-2);
}

这里直接说结论吧，递归时间复杂度是指数级

怎么优化？

从上面的图其实可以看出来，$f(3)、f(2)$都重复计算了。可以考虑将$f(i)$计算出来的值存在哈希表中，算过一次以后，第二次可以直接取。这样每次计算$f(i)$的时间复杂度就变成了$O(1)$。总的时间复杂度降成了$O(n)$。

const int inf = -1;
int h[46];

void init() {
    memset(h, inf, sizeof(h));  // 1）
}

int f(unsigned int n) {
    if(n <= 1) {
        return 1;
    }
    int &fib = h[n];            // 2）
    if(fib != inf) {
        return fib;             // 3）
    }
    fib = f(n-1) + f(n-2);      // 4）
    return fib;
}

这里为什么要用引用呢?

在第 2）行，我们使用引用 int &fib = h[n]; 来表示 $h$ 数组中的第 $n$ 个元素。这样，当我们在第 4）行计算 $fib=f(n-1)+f(n-2)$; 时，我们可以直接修改 $h[n]$ 的值，而不需要使用额外的变量。

如果我们不使用引用，而是使用一个普通的整数变量，那么在递归调用 f 函数时，我们需要将 $h[n]$的值传递给这个变量，然后在计算完成后将这个变量的值写回 $h[n]$。这会导致额外的内存和计算开销，降低算法的效率。

记忆化搜索的含义

记忆化搜索 = 深度优先搜索的实现 + 动态规划的思想

举个例子

给定一个$n\times m$的矩阵 ，要求选择一个起点，然后选择上下左右四个相邻方向之一开始行走，并且要保证行走的点的值比当前点小，即找一条单调递减的路径，要求这条路径最长。

我们可以从 $A_{33}=25$这个位置出发，得到一条最大长度为25的路径。

int dir[4][2] = {
    { 0, 1 }, { 0, -1 }, { 1, 0 }, { -1, 0 }
};
const int inf = -1;

int dfs(int preval, int x, int y) {
    if(x < 1 || y < 1 || x > n || y > m) {
        return 0;                 // 1）
    }
    if(A[x][y] >= preval) {
        return 0;                 // 2）
    }

    int &val = f[x][y];
    if (val != inf) {             // 3）
        return val;
    }

    val = 1;
    for (int i = 0; i < 4; ++i) { // 4）
        int tx = x + dir[i][0];
        int ty = y + dir[i][1];
        val = max(val, dfs(A[x][y], tx, ty) + 1);
    }
    return val;                   // 5）
}

• 1) 其中dfs(preval,x,y)代表的是从$Axy$这个位置出大能够到达的最长路，preval则代表从哪个值过来的；首先进行坐标合法性的判断，如果在边界以外，最长路一定是$0$
• 2) 然后进行偏序关系的判断，保证这条路是一条单调递减的路；
• 3) 如果哈希表中存在，直接取了返回
• 4) 然后遍历四个方向找最长路，四分方向的相邻位置作为当前位置的子问题求解；然后选最长
• 5) 将结果返回

记忆化搜索的框架

1) 合法性剪枝

因为在递归计算的时候，我们必须保证传入参数的合法性，所以这一步是必要的，比如坐标为负数之类的判断；

2)偏序关系剪枝

偏序关系其实就是代表了状态转移的方向，例如上面只允许值大的往值小的方向走，这就是一种偏序关系；如果不满足偏序关系的就不能继续往下搜索了；

3)记忆化剪枝

记忆化剪枝就是去对应的哈希数组判断这个状态是否曾经已经计算过，如果计算过则直接返回，时间复杂度$O(1)$

4)递归计算结果并返回

这一步就是深度优先搜索的递归过程，也是递归子问题取最优解的过程，需要具体问题具体分析；