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

小丁爱养花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

相关推荐
乌啼霜满天249几秒前
Spring 与 Spring MVC 与 Spring Boot三者之间的区别与联系
java·spring boot·spring·mvc
tangliang_cn6 分钟前
java入门 自定义springboot starter
java·开发语言·spring boot
莫叫石榴姐6 分钟前
数据科学与SQL：组距分组分析 | 区间分布问题
大数据·人工智能·sql·深度学习·算法·机器学习·数据挖掘
程序猿阿伟7 分钟前
《智能指针频繁创建销毁：程序性能的“隐形杀手”》
java·开发语言·前端
Grey_fantasy16 分钟前
高级编程之结构化代码
java·spring boot·spring cloud
新知图书18 分钟前
Rust编程与项目实战-模块std::thread（之一）
开发语言·后端·rust
威威猫的栗子20 分钟前
Python Turtle召唤童年：喜羊羊与灰太狼之懒羊羊绘画
开发语言·python
力透键背20 分钟前
display: none和visibility: hidden的区别
开发语言·前端·javascript
bluefox197921 分钟前
使用 Oracle.DataAccess.Client 驱动 和 OleDB 调用Oracle 函数的区别
开发语言·c#
弗锐土豆23 分钟前
工业生产安全-安全帽第二篇-用java语言看看opencv实现的目标检测使用过程
java·opencv·安全·检测·面部
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿