【递归深搜之记忆化搜索算法】

1. 斐波那契数

解法一：递归

class Solution {
public:
    int fib(int n) {
        return dfs(n);
    }

    int dfs(int n)
    {
        if(n == 0 || n == 1)
            return n;
        return dfs(n - 1) + dfs(n - 2);
    }
};

解法二：记忆化搜索

class Solution {
    int nums[31]; // 备忘录
public:
    int fib(int n) {
        memset(nums, -1, sizeof(nums)); // 全部都初始化为-1
        return dfs(n);
    }

    int dfs(int n)
    {
        // 在备忘录里面查询一下
        if(nums[n] != -1)
        {
            // 如果已经计算过直接返回
            return nums[n];
        }

        // 否则在返回的时候添加到备忘录
        if(n == 0 || n == 1)
        {
            nums[n] = n;
            return nums[n];
        }
        else
        {
            nums[n] = dfs(n - 1) + dfs(n - 2);
            return nums[n];
        } 
    }
};  

解法三：动态规划

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. 不同路径 

这个题目我们首先想到就是递归深搜右和下两个方向的路径，直到达到终点，此时我们统计次数，但是别忘记了要恢复现场哟

class Solution {
    int dx[2] = {0, 1};
    int dy[2] = {1, 0};
    bool vis[101][101] = { false };
    int ret;

public:
    int uniquePaths(int m, int n) {
        dfs(0, 0, m, n);
        return ret;
    }

    void dfs(int i, int j, int m, int n)
    {
        vis[i][j] = true;
        if(i == n - 1 && j == m - 1) // 注意这里 j 和 m 的位置
        {
            ret++;
            vis[i][j] = false; // 回溯：恢复访问状态
            return;
        }
        for(int k = 0 ; k < 2; k++)
        {
            int x = dx[k] + i;
            int y = dy[k] + j;
            if(x >= 0 && x < n && y >=0 && y < m && !vis[x][y]) // 注意这里 x 和 y 的范围检查
            {
                dfs(x, y, m, n); // 传递正确的 m 和 n
                vis[x][y] = false; // 回溯：恢复访问状态
            }
        }
    }
};

但是我们点击运行发现程序报错了，超时了，因为我们题目存在大量的重复的递归，所以我们这个题目需要采用记忆化手搜索去解决。

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 == j && j == 1) return 1;
        return dfs(i - 1, j) + dfs(i, j - 1);
    }
};

class Solution {
public:
    int uniquePaths(int m, int n) {
        // 添加备忘录
        vector<vector<int>> nums(m + 1, vector<int>(n + 1));
        return dfs(m, n, nums);
    }

    int dfs(int i, int j, vector<vector<int>>& nums)
    {   
        // 查找备忘录
        if(nums[i][j])
        {
            return nums[i][j];
        }

        if(i == 0 || j == 0)
        {
            // 因为数组原本内容就是0,这里就不用填写到备忘录
            return 0;
        }
        if(i == j && j == 1)
        {
            nums[i][j] = 1;
            return nums[i][j];
        } 

        nums[i][j] = dfs(i - 1, j, nums) + dfs(i, j - 1, nums);
        return nums[i][j];
    }
};

同时我们这里还可以直接修改成动态规划的形式

class Solution {
public:
    int uniquePaths(int m, int n) {
        // 添加dp表
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        // 因为数组原本内容就是0,这里就不用填写到dp表中
        dp[1][1] = 1;
        for(int i = 1; i <= m; i++)
            for(int j = 1; j <= n; j++)
                { 
                    if(i == 1 && j == 1)
                        continue;
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                }
        return dp[m][n];
    }
};

3. 最长递增子序列

我们看到这个题目，依然是先画出我们的决策树，先来看看决策树什么样子

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int ret = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            // 考虑以所有位置为起点的情况
            ret = max(ret, dfs(nums, i));
        }
        return ret; 
    }
    int dfs(vector<int>& nums, int pos)
    {
        int ret = 1; // 起始位置算一个子序列
        for(int i = pos + 1; i < nums.size(); i++)
        {
            if(nums[pos] < nums[i])
            {
                ret = max(ret, dfs(nums, i) + 1);
            }
        }
        return ret;
    }
};

但是此时会超时，我们依然要使用记忆化搜索去解决。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> mem(nums.size());
        int ret = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            // 考虑以所有位置为起点的情况
            ret = max(ret, dfs(nums, i, mem));
        }
        return ret; 
    }
    
    int dfs(vector<int>& nums, int pos, vector<int>& mem)
    {
        // 查找备忘录
        if(mem[pos])
            return mem[pos];
        int ret = 1; // 起始位置算一个子序列
        for(int i = pos + 1; i < nums.size(); i++)
        {
            if(nums[pos] < nums[i])
            {
                // 递归下一层,并且记录上当层子序列
                ret = max(ret, dfs(nums, i, mem) + 1);
            }
        }
        // 添加到备忘录
        mem[pos] = ret;
        return mem[pos];
    }
};

此时我们也可以改成动态规划的代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        // dp(i) 表示以i位置为起点的最长递增子序列的个数
        // 填表顺序 -> 从后往前
        vector<int> dp(nums.size(), 1);
        int ret = 0;
        for(int i = nums.size() - 1; i >= 0; i--)
        {
            for(int j = i + 1; j < nums.size(); j++)
            {
                if(nums[j] > nums[i])
                {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            ret = max(dp[i], ret);
        }
        return ret; 
    }
};

4. 猜数字大小II

class Solution {
    int mem[201][201];
public:
    int getMoneyAmount(int n) {
        return dfs(1, n);
    }

    int dfs(int left, int right)
    {
        if(left > right)
        {
            return 0;
        }
        if(left == right)
        {
            return 0;
        }
        if(mem[left][right] != 0)
            return mem[left][right];
        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));
        }
        mem[left][right] = ret;
        return mem[left][right];
    }
};

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

class Solution {
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
    int nums[201][201];
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        m = matrix.size();
        n = matrix[0].size();
        int ret = 0;
        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(nums[i][j] != 0)
            return nums[i][j];
        int step = 1;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k];
            int y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j])
            {
                step = max(step, dfs(matrix, x, y) + 1);
            }
        }
        nums[i][j] = step;
        return step;
    }
};