如何让算法拥有“记忆”？一文读懂记忆化搜索

Chris-zz

于 2024-10-08 10:26:02 发布

阅读量483

点赞数 15

分类专栏：递归、搜索与回溯算法文章标签：算法散列表 c++ 数据结构哈希算法

本文链接：https://blog.csdn.net/2301_79691881/article/details/142725474

版权

递归、搜索与回溯算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

✨✨✨学习的道路很枯燥，希望我们能并肩走下来!

文章目录

前言

本篇详细介绍了进一步介绍记忆化搜索，让使用者对记忆化搜素有更加深刻的认知，而不是仅仅停留在表面，更好的模拟，为了更好的使用. 文章可能出现错误，如有请在评论区指正，让我们一起交流，共同进步！

一什么是记忆化搜索

记忆化搜索（Memoization Search）：是一种通过存储已经遍历过的状态信息，从而避免对同一状态重复遍历的搜索算法。

记忆化搜索是动态规划的一种实现方式。在记忆化搜索中，当算法需要计算某个子问题的结果时，它首先检查是否已经计算过该问题。如果已经计算过，则直接返回已经存储的结果；否则，计算该问题，并将结果存储下来以备将来使用。

这样看概念可能有些抽象，接下来将用斐波那契数作为例子讲解

二相关题目练习

2.1 斐波那契数（详解记忆化搜索）

509. 斐波那契数 - 力扣（LeetCode）

解法一（递归）：

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);
    }
};

从解法上看，这是一种低效的做法，时间复杂度为（2的n次方），那么为什么呢？

我们发现，递归的解法重复计算，导致效率低下！

那么我们可不可以用一个备忘录记录下重复计算的值呢？

解法二（记忆化搜索）：

class Solution {
    int memo[31];  //memory
public:
    int fib(int n) {
        memset(memo,-1,sizeof(memo));
        return dfs(n);
    }

    int dfs(int n)
    {
        //往备忘录里找一下
        if(memo[n] != -1)
            return memo[n];
        if(n == 0 || n == 1)
        {
            memo[n] = n;  //返回之前放进备忘录里
            return n;
        }
        
        memo[n] = dfs(n-1) + dfs(n-2); //返回之前放进备忘录里
        return memo[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.2 不同路径

62. 不同路径 - 力扣（LeetCode）

解法一：记忆化搜索

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> memo(m+1,vector<int>(n+1));
        return dfs(m,n,memo);
    }

    int dfs(int i,int j,vector<vector<int>>& memo)
    {
        if(memo[i][j] != 0)
        {
            return memo[i][j];
        }
        if(i == 0 || j == 0)    return 0;
        if(i == 1 && j == 1)
        {
            memo[i][j] = 1;
            return 1;
        }

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

解法二：动态规划

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        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];
    }
};

2.3 最长递增子序列

300. 最长递增子序列 - 力扣（LeetCode）

解法一：记忆化搜索

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

    int dfs(vector<int>& nums,int pos,vector<int>& memo)
    {
        if(memo[pos] != 0)  return memo[pos];
        int ret = 1;
        for(int i = pos + 1; i < nums.size(); i++)
        {
            if(nums[i] > nums[pos])
            {
                ret = max(ret,dfs(nums,i,memo) + 1);
            }
        }
        memo[pos] = ret;
        return ret;
    }
};

解法二：动态规划

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size(),ret = 0;
        vector<int> dp(n,1);
        for(int i = n-1;i >= 0; i--)
        {
            for(int j = i + 1; j < n; j++)
            {
                if(nums[j] > nums[i])
                    dp[i] = max(dp[i],dp[j] + 1);
            }
            ret = max(ret,dp[i]);
        }
        return ret;
    }
};

2.4 猜数字大小II

375. 猜数字大小 II - 力扣（LeetCode）

暴搜（超时）：

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

    int dfs(int left,int right)
    {
        if(left >= right)   return 0;

        int ret = INT_MAX;
        for(int head = left; head <= right; head++)
        {
            int x = dfs(left,head-1);
            int y = dfs(head+1,right);
            ret = min(ret,head+max(x,y));
        }
        return ret;
    }
};

记忆化搜索：

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

    int dfs(int left,int right)
    {
        if(left >= right)   return 0;

        if(memo[left][right] != 0)  return memo[left][right];
        int ret = INT_MAX;
        for(int head = left; head <= right; head++)
        {
            int x = dfs(left,head-1);
            int y = dfs(head+1,right);
            ret = min(ret,head+max(x,y));
        }
        memo[left][right] = ret;
        return ret;
    }
};

2.5 矩阵中的最长递增路径

329. 矩阵中的最长递增路径 - 力扣（LeetCode）

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