记忆化搜索专题——算法简介&力扣实战应用

小丁爱养花2024-09-21 12:56

目录

1、记忆化搜索算法简介

[1.1 什么是记忆化搜索](#1.1 什么是记忆化搜索)

[1.2 如何实现记忆化搜索](#1.2 如何实现记忆化搜索)

[1.3 记忆化搜索与动态规划的区别](#1.3 记忆化搜索与动态规划的区别)

2、算法应用【leetcode】

[2.1 题一：斐波那契数](#2.1 题一：斐波那契数)

[2.1.1 递归暴搜解法代码](#2.1.1 递归暴搜解法代码)

[2.1.2 记忆化搜索解法代码](#2.1.2 记忆化搜索解法代码)

[2.1.3 动态规划解法代码](#2.1.3 动态规划解法代码)

[2.2 题二：不同路径](#2.2 题二：不同路径)

[2.2.1 算法原理](#2.2.1 算法原理)

[2.2.2 记忆化搜索代码](#2.2.2 记忆化搜索代码)

[2.2.3 动态规划代码](#2.2.3 动态规划代码)

[2.3 题三：最长递增子序列](#2.3 题三：最长递增子序列)

[2.3.1 算法原理](#2.3.1 算法原理)

[2.3.2 记忆化搜索代码](#2.3.2 记忆化搜索代码)

[2.3.3 动态规划代码](#2.3.3 动态规划代码)

[2.4 题四：猜数字大小II](#2.4 题四：猜数字大小II)

[2.4.1 算法原理](#2.4.1 算法原理)

[2.4.2 算法代码](#2.4.2 算法代码)

[2.5 题五：矩阵中的最长递增路径【困难】](#2.5 题五：矩阵中的最长递增路径【困难】)

[2.5.1 算法原理](#2.5.1 算法原理)

[2.5.2 算法代码](#2.5.2 算法代码)

1、记忆化搜索算法简介

1.1 什么是记忆化搜索

**记忆化搜索（Memoization）是一种优化搜索算法的技术，主要用于减少重复计算，提高算法效率。**它通过存储已经计算过的结果来避免对同一问题的重复计算，特别适用于‌递归算法中存在大量完全重复的递归的情况。

简单来说，记忆化搜索就是带备忘录的递归。

举个例子，当我们使用普通的暴搜递归法求斐波那契数时，意味着每个节点都需要遍历一遍，时间复杂度为O(2^N)，但是这其中出现大量完全重复的递归树，大量重复的递归导致时间效率严重降低。 这时，我们就可以使用一个"备忘录"所出现过的数据存起来，递归时若遇见重复的问题时，直接从"备忘录"中取值即可，不必再次重复递归。 这样一来，我们可将时间复杂优化为线性级别：O(N)。

​

我们以添加"备忘录"的形式，将数据记忆起来，减少大量重复的递归，这样的暴搜优化( O(2^N) --> O(N) )算法就称为记忆化搜索。

注意：

并非所有的递归暴搜都可改为记忆化搜索，只有在递归的过程中，出现了大量完全相同的问题时（并非相同子问题），才可以使用记忆化搜索进行优化。

1.2 如何实现记忆化搜索

  1. 添加备忘录 ---> <可变参数，返回值>
  2. 每次进入递归的时候，瞅一瞅备忘录里面是否已存在想要的结果
  3. 每次递归返回的时候，将结果放到备忘录中存起来

1.3 记忆化搜索与动态规划的区别

其实记忆化搜索与动态规划本质上都是一回事。

  1. 都属于暴力解法(暴搜)
  2. 都是对暴搜的优化：把计算过的值，存起来

但是不同的是：

  1. 记忆化搜索是以递归的形式进行的
  2. 动态规划是以递推(循环)的形式进行的
  3. 记忆化搜索是自顶向下（dfs(n) --> dfs(n-1) 、 dfs(n-2)）
  4. 动态规划是自底向上（dp[1] 、 dp[2] --> dp[3] ）

2、算法应用【leetcode】

2.1 题一：斐波那契数

. - 力扣（LeetCode）

相信对于斐波那契数的计算，大家都已了然于心，这里就不多废话了，只向大家展示三中不同解法：

  • 递归暴搜解法：O(2^N)
  • 记忆化搜索解法(暴搜优化)：O(N)
  • 动态规划解法(暴搜优化)：O(N)

2.1.1 递归暴搜解法代码

java 复制代码 
class Solution {
    public int fib(int n) {
        return dfs(n);
    }
    public int dfs(int n) {
        if(n == 0 || n == 1) return n;
        return dfs(n - 1) + dfs(n - 2);
    }
}

2.1.2 记忆化搜索解法代码

java 复制代码 
class Solution {
    //记忆化搜索
    int[] memo;//memory
    public int fib(int n) {
        memo = new int[31];
        Arrays.fill(memo, -1);//初始化时，填入不可能出现的值
        return dfs(n);
    }
    public 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];
    }
}

2.1.3 动态规划解法代码

java 复制代码 
class Solution {
    //动态规划
    int[] dp;
    public int fib(int n) {
        dp = new int[31];
        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 题二：不同路径

. - 力扣（LeetCode）

2.2.1 算法原理

经过分析，可以发现：到达(x,y)位置的路径数=到达(x,y-1)的路径数+到达(x-1,y)的路径数

设计递归函数体：dfs(m,n) = dfs(m,n-1)+dfs(m-1,n)

函数出口：

  1. if(m == 0 || n == 0) return 0;（从下标1开始为有效位置）
  2. if(m== 1&&n ==1) return 1;//特殊处理

经过验证，纯暴搜解法是会超时的，经分析，问题中出现了大量重复的问题，采取记忆化搜索算法和动态规划进行优化。

​

2.2.2 记忆化搜索代码

java 复制代码 
class Solution {
    //记忆化搜索
    int[][] memo;
    public int uniquePaths(int m, int n) {
        //从下标1,1开始
        memo = new int[m + 1][n + 1];
        return dfs(m, n);
    }
    public int dfs(int m, int n) {
        if(memo[m][n] != 0) return memo[m][n];
        if(m == 0 || n == 0) {
            return 0;
        }
        if(m == 1 && n == 1) {
            memo[m][n] = 1;
            return 1;
        }
        memo[m][n] =  dfs(m, n - 1) + dfs(m - 1, n);
        return memo[m][n];
    }
}

2.2.3 动态规划代码

java 复制代码 
class Solution {
    public int uniquePaths(int m, int n) {
        //动态规划
        int[][] dp = new int[m + 1][n + 1];
        dp[1][1] = 1;
        for(int i = 1; i < m + 1; i++) {
            for(int j = 1;j < n + 1; j++) {
                if(i == 1 && j == 1) continue;
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
            }
        }
        return dp[m][n];
    }
}

2.3 题三：最长递增子序列

2.3.1 算法原理

因为是最长递增子序列，所以只能从当前位置向后找。

  • 函数头：dfs(pos)；//pos位置处的最长子序列
  • 从当前位置pos开始，选出后面位置中最长的子序列len(注意：要求nums[i] > nums[pos])，再得len+1(当加上前位置)，就是当前位置的最长子序列。

​

2.3.2 记忆化搜索代码

java 复制代码 
class Solution {
    //记忆化搜索
    int n;
    public int lengthOfLIS(int[] nums) {
        int ret = 0;
        n = nums.length;
        int[] memo = new int[n];
        for(int i = 0; i < n; i++) {
            ret = Math.max(ret, dfs(nums, i, memo));
        }
        return ret;
    }
    public int dfs(int[] nums, int pos, int[] memo) {
        if(memo[pos] != 0) return memo[pos];
        int ret = 1;
        for(int i = pos + 1; i < n; i++) {
            if(nums[i] > nums[pos]) {
                ret = Math.max(ret,  dfs(nums, i, memo) + 1);
            }
        }
        memo[pos] = ret;
        return ret;
    }
}

2.3.3 动态规划代码

java 复制代码 
class Solution {
    //动态规划
    int n;
    public int lengthOfLIS(int[] nums) {
        int ret = 0;
        n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        for(int i = n - 1; i >= 0; i--) {
            for(int j = i + 1; j < n; j++) {
                if(nums[i] < nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            ret = Math.max(dp[i], ret);
        }
        return ret;
    }
}

2.4 题四：猜数字大小II

. - 力扣（LeetCode）

2.4.1 算法原理

暴力枚举出所有可能出现的情况，选出花费最小的最佳策略。

  • 每一种情况都需要选出左右子树中话费金额的最大值(保证能赢)
  • 每种情况话费的金额为：max(左，右)+本身
  • 选出所有情况中花费最小的最佳策略。

​

2.4.2 算法代码

java 复制代码 
class Solution {
    int[][] memo;
    public int getMoneyAmount(int n) {
        memo = new int[n + 1][n + 1];
        return dfs(1, n);
    }
    public int dfs(int s, int e) {
        int ret = Integer.MAX_VALUE;
        if(s >= e) {
            return 0;
        }
        if(memo[s][e] != 0) return memo[s][e];
        for(int i = s; i <= e; i++) {
            int left = dfs(s, i - 1);
            int right = dfs(i + 1, e);
            ret = Math.min(Math.max(left, right) + i, ret);
        }
        memo[s][e] = ret;
        return ret;
    }
}

2.5 题五：矩阵中的最长递增路径【困难】

. - 力扣（LeetCode）

2.5.1 算法原理

  • 枚举所有节点，选出所有节点中最长的路径
  • 函数设计：dfs(i,j) --> 返回(i,j)位置的最长路径
  • 一个位置的最长路径是固定的 --> 备忘录int[][] memo

2.5.2 算法代码

java 复制代码 
class Solution {
    int m, n;
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};
    int[][] matrix;
    int[][] memo;//备忘录
    public int longestIncreasingPath(int[][] matrix_) {
        matrix = matrix_;
        m = matrix.length; n = matrix[0].length;
        memo = new int[m + 1][n + 1];
        int ret = 0;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                ret = Math.max(ret, dfs(i, j));
            }
        }
        return ret;
    }
    public int dfs(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];
            int y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j]) {
                //求出当前位置的最长路径
                ret = Math.max(ret, dfs(x, y) + 1);
            }
        }
        memo[i][j] = ret;
        return ret;
    }
}

END

相关推荐
__AtYou__15 分钟前
Golang | Leetcode Golang题解之第417题太平洋大西洋水流问题
leetcode·golang·题解
yanyanwenmeng16 分钟前
matlab基础
开发语言·算法·matlab
Yz987617 分钟前
Hadoop里面MapReduce的序列化与Java序列化比较
java·大数据·jvm·hadoop·分布式·mapreduce·big data
##晴天小猪19 分钟前
ByteTrack多目标跟踪流程图
人工智能·算法·目标检测·机器学习·目标跟踪
凯哥Java19 分钟前
优化批处理流程：自定义BatchProcessorUtils的设计与应用
java·数据库·mysql
njnu@liyong27 分钟前
AOP-前置原理-怎么判断和拦截？
java·aop·拦截
Ddddddd_15829 分钟前
C++ | Leetcode C++题解之第421题数组中两个数的最大异或值
c++·leetcode·题解
末央＆32 分钟前
【C++】内存管理
java·开发语言·c++
ly-how33 分钟前
leetcode练习 二叉树的层序遍历
算法·leetcode
不是仙人的闲人35 分钟前
Qt日志输出及QsLog日志库
开发语言·数据库·qt
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04软件工程从理论到实践客观题汇总(头歌第一章至第八章)05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CCF-CSP认证考试 202406-3 文本分词 100分题解08yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10实战 | 基于YOLOv9和OpenCV实现车辆跟踪计数（步骤 + 源码）