记忆化搜索题目相关练习

前言

大家好，我是jiantaoyab，今天的刷题练习是记忆化搜索，在我看来，记忆化搜索就是带备忘录的递归，也是动态规划的一种，不过是用递归来实现的而已，常规的动态规划是用循环实现。

记忆化搜索实现

• 增加一个备忘录（可以用hash，数组）
• 递归每次返回的时候，将结果放到备忘录中
• 每次进入递归的时候，看看备忘录有没有已近出现的值有直接返回结果就行

先来看一道经典的题目

斐波那契数

https://leetcode.cn/problems/fei-bo-na-qi-shu-lie-lcof/

代码

class Solution {
    int memo[31]; //备忘录
public:
    int dfs(int n)
    {
        //每次递归前判断备忘录中是不是已经出现相同的值
        if(memo[n] != -1) return memo[n];
        if(n == 1 || n == 0) 
        {
            memo[n] = n; //递归之前先把值放入备忘录
            return n ;
        }
        memo[n] = dfs(n - 1) + dfs(n - 2);//递归之前先把值放入备忘录
        return  memo[n];
    }

    int fib(int n) {
        //将备忘录初始化为-1
        memset(memo, -1, sizeof(memo));
        return dfs(n);
    }
};

通过这到题，能看出来在我们遇到大量完全相同子问题的时候，就能将递归改成记忆化搜索进行优化

不同路径

看到上面的解析，很明显这个题也能用动态规划来写，我这里用记忆化搜索实现

代码

class Solution {
 public:
    int dfs(int i, int j, vector<vector<int>>& meno)
    {
        if(meno[i][j] != 0) return meno[i][j]; //记录到备忘录
        if(i == 0 || j ==0) return 0;
        if(i == 1 && j == 1) 
        {
            meno[i][j] = 1;
            return 1;
        }
        //返回前添加到备忘录
        meno[i][j] =  dfs(i - 1, j, meno) + dfs(i, j - 1, meno);
        return  meno[i][j];
    }
    int uniquePaths(int m, int n) 
    {
        //二位的备忘录是因为有2个参数
        vector<vector<int>> meno(m + 1, vector<int>(n + 1));//备忘录 需要访问到（m，n）
        return dfs(m, n, meno);
    }
};

最长递增子序列

代码

class Solution {
public:
    int dfs(int pos, vector<int>& nums, vector<int>& memo)
    {
        int count = 1; //穿过来默认有一个
        if(memo[pos] != 0) return memo[pos];
        for(int i = pos + 1; i < nums.size(); i++)
        {
            if(nums[i] > nums[pos])
            {
                count = max(count, dfs(i, nums, memo) + 1); // + 1加上自己
            }
        }
        memo[pos] = count;
        return count;

    }
    int lengthOfLIS(vector<int>& nums) {
        int ret = 0;
        vector<int>memo(nums.size());
        for(int i = 0; i < nums.size(); i++)
        {
            ret = max(ret, dfs(i, nums, memo));
        }
        return ret;
    }
};

猜数字大小 II

代码

class Solution {
   int memo[201][201];
public:
    int dfs(int left, int right)
    {
       //left > right [1,0] 没这种区间
       //left = right 说明到了叶子，就直接是结果，不用算钱
       if(left >= right) return 0;
       if(memo[left][right]) return memo[left][right];
       int ret = INT_MAX;
       //每个节点都遍历过
       for(int head = left; head <= right; head++)
       {
            int l = dfs(left, head - 1);
            int r = dfs(head + 1, right);
            ret = min(ret, head + max(l, r));
       }
       memo[left][right] = ret;
       return memo[left][right];
    }
    int getMoneyAmount(int n) {
         return dfs(1, n);
    }
};

矩阵中的最长递增路径

代码

class Solution {
    int meno[201][201];
    int m, n;
    int dx[4]= {1, -1, 0, 0};
    int dy[4]= {0, 0, -1, 1};
public:
    int dfs(vector<vector<int>>& matrix, int i, int j)
    {
        if(meno[i][j]) return meno[i][j];
        int sum = 1;
        for(int d = 0; d < 4; d++)
        {
            int x = i + dx[d], y = j + dy[d];
            if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j])
            {
                sum = max(sum,1 + dfs(matrix, x, y)) ;
            }
        }
        meno[i][j] = sum;
        return meno[i][j];
    }
    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;
    }
};