leetcode之记忆化搜索刷题总结1

最新推荐文章于 2024-02-22 20:41:28 发布
最新推荐文章于 2024-02-22 20:41:28 发布
阅读量647 收藏 4
点赞数 4
分类专栏： 算法与数据结构 文章标签： leetcode 深度优先 算法 记忆化搜索 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/123055295
版权

leetcode之记忆化搜索刷题总结1

1-青蛙跳台阶问题
题目链接：题目链接戳这里！！！

思路1：动态规划思想
f[i]表示跳到第i层的种类数，因为每次可以调一层和二层，故等于跳到第i-1层的种类数+跳到第i-2层的种类数。递推表达式如下：
f[i]=f[i-1]+f[i-2]

class Solution {
    int mod = 1000000007;
    public int numWays(int n) {
       if(n<=1){
           return 1 ;
       }
       int [] f = new int [n+1] ;
       f[0]=f[1] = 1 ;
       for(int i=2; i<=n; i++){
           f[i] = f[i-1]%mod + f[i-2]%mod ;
       }
       return f[n]%mod ;

    }
}

在这里插入图片描述
思路2：记忆化搜索，也就是记忆递归，直接递归由于包含大量重复计算，会超时。

class Solution {
    int mod = 1000000007;
    public int numWays(int n) {
        int [] vis = new int [n+1] ;
        Arrays.fill(vis,-1) ;
        return dfs(vis,n) ;
    }
    public int dfs(int [] vis, int n){
        if(vis[n]!=-1){
            return vis[n] ;
        }
        if(n==0 || n==1){
            return 1 ;
        }
        vis[n] = dfs(vis,n-1)%mod+dfs(vis,n-2)%mod ;
        return vis[n]%mod ;
        
    }
}

在这里插入图片描述
2-三步问题
题目链接：题目据链接戳这里！！！

思路1：动态规划
和上一题思路一样，只不过这一题递推式是三个相加

class Solution {
    int mod = 1000000007 ;
    public int waysToStep(int n) {
        if(n==1){
            return 1 ;
        }else if(n==2){
            return 2 ;
        }else if(n==3){
            return 4 ;
        }
        int [] f = new int [n+1] ;
        f[1]=1;
        f[2]=2;
        f[3]=4;
        for(int i=4; i<=n; i++){
            f[i] = ((f[i-1]%mod + f[i-2]%mod)%mod + f[i-3]%mod)%mod ;
        }
        return f[n]%mod;


    }
}

在这里插入图片描述
思路2：记忆化搜索

class Solution {
    int mod = 1000000007 ;
    public int waysToStep(int n) {
       int [] vis = new int [n+1] ;
       Arrays.fill(vis,-1) ;
       return dfs(vis,n) ;
    }
    public int dfs(int [] vis, int n){
        if(vis[n]!=-1){
            return vis[n] ;
        }
        if(n==1){
            return 1 ;
        }
        if(n==2){
            return 2 ;
        }
        if(n==3){
            return 4 ;
        }
        vis[n] = ((dfs(vis,n-1)%mod + dfs(vis,n-2)%mod)%mod + dfs(vis,n-3)%mod)%mod;
        return vis[n]%mod ;
    }
}

在这里插入图片描述
3-第N个泰波那契数列
题目链接：题目链接戳这里！！！

注意：不是斐波那契数列，哈哈，不过思路一样的，记忆化递归。

class Solution {
    int [] vis ;
    public int tribonacci(int n) {
     vis = new int [n+1] ;
     Arrays.fill(vis,-1) ;
     return dfs(n) ;
    }
    public int dfs(int n){
        if(vis[n]!=-1){
            return vis[n] ;
        }
        if(n==0){
            return 0 ;
        }
        if(n==1 || n==2){
            return 1 ;
        }
        vis[n] =  dfs(n-1) + dfs(n-2) + dfs(n-3) ;
        return vis[n] ;
    }
}

在这里插入图片描述
这题用动态规划也是一样的，不再赘述。

4-斐波那契数列
题目链接：题目链接戳这里！！！

思路：记忆化搜索，动态规划也可以。

class Solution {
    int [] vis ;
    int mod = 1000000007 ;
    public int fib(int n) {
        vis = new int [n+1] ;
        Arrays.fill(vis,-1) ;
        return dfs(n) ;
    }
    public int dfs(int n){
        if(vis[n]!=-1){
            return vis[n] ;
        }
        if(n==0){
            return 0 ;
        }
        if(n==1){
            return 1 ;
        }
        vis[n] = (dfs(n-1)%mod + dfs(n-2)%mod)%mod ;
        return vis[n]%mod ;
    }
}

在这里插入图片描述
5-单词拆分
题目链接：题目链接戳这里！！！

思路1：动态规划
dp[i]表示前i位是否可以用wordDict表示

初始化 dp[0]=true，空字符可以被表示

遍历字符串的所有子串，如果dp[j]为true，则说明前j位可以被wordDict表示，此时若wordDict中存在s.substring(j,i),则dp[i]为true，即前i位可以用wordDict表示。

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        //dp[i]表示前i位是否可以用wordDict表示
        int n = s.length() ;
        boolean [] dp = new boolean [n+1] ;
        dp[0] = true ;
        Set<String> set = new HashSet<>(wordDict) ;
        for(int i=1; i<dp.length; i++){
            for(int j=0; j<i; j++){
                if(dp[j] && set.contains(s.substring(j,i))){
                    dp[i] = true;
                    break ;
                }
            }
        }
        return dp[n] ;
    }
}

在这里插入图片描述

6-矩阵中的最长递增路径
题目链接：题目链接戳这里！！！

思路：沿着四个方向记忆化搜索，每次将搜索到的最大值返回，下次如果在搜索到该位置，直接返回。

class Solution {
    //记忆化搜索
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    int [][] temp ;
    public int longestIncreasingPath(int[][] matrix) {
        int max = Integer.MIN_VALUE ;
        temp = new int [matrix.length][matrix[0].length] ;
        for(int i=0; i<temp.length; i++){
            for(int j=0; j<temp[0].length; j++){
                temp[i][j] = -1 ;
            }
        }
        for(int i=0; i<matrix.length; i++){
            for(int j=0; j<matrix[0].length; j++){
                max = Math.max(max,dfs(matrix,i,j)) ;
            }
        }
        return max ;
    }
    public int dfs(int [][] matrix, int x, int y){
        if(temp[x][y]!=-1){
            return temp[x][y] ;
        }
        temp[x][y] = 1 ;
        int res = 0 ;
        for(int i=0; i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx<0 || ty<0 || tx>matrix.length-1 || ty>matrix[0].length-1 || matrix[tx][ty]<=matrix[x][y]){
                continue ;
            }
            res = Math.max(res,dfs(matrix,tx,ty)) ;
        }
        temp[x][y] += res ;
        return temp[x][y] ;
    }
}

在这里插入图片描述
这样写看着更舒服，思路是一样的，记忆化搜索

class Solution {
    //记忆化搜索
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    int [][] temp ;
    public int longestIncreasingPath(int[][] matrix) {
        int max = Integer.MIN_VALUE ;
        temp = new int [matrix.length][matrix[0].length] ;
        for(int i=0; i<matrix.length; i++){
            for(int j=0; j<matrix[0].length; j++){
                max = Math.max(max,dfs(matrix,i,j,temp)) ;
            }
        }
        return max ;
    }
    public int dfs(int [][] matrix, int x, int y, int [][] temp){
        if(temp[x][y]!=0){
            return temp[x][y] ;
        }
        temp[x][y] = 1 ;
        int res = 0 ;
        for(int i=0; i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx>=0 && ty>=0 && tx<=matrix.length-1 && ty<=matrix[0].length-1 && matrix[tx][ty]>matrix[x][y]){
              temp[x][y] = Math.max(temp[x][y],dfs(matrix,tx,ty,temp)+1) ;
            }
        }
        return temp[x][y] ;
    }
}

在这里插入图片描述
7-统计所有可行路径
题目链接：题目链接戳这里！！！

思路：记忆化搜索
我使用数组memo[start][fuel]记录从start开始到finish一共有fuel燃料可以有多少种行驶路径。
最初数组全部填充-1，每次搜索到填充0，对于其它非开始顶点，如果燃料够用，就尝试着走，如果到不了终点，则不可行，达到终点则方案数加1，如果之前已经得到了方案数，下一次则直接返回方案数。

class Solution {
    int [][] memo;
    int mod = 1000000007;
    public int countRoutes(int[] locations, int start, int finish, int fuel) {
        memo = new int [locations.length][fuel+1] ;
        for(int [] arr : memo){
            Arrays.fill(arr,-1) ;
        }
        return dfs(locations,start,finish,fuel) ;
    }
    public int dfs(int [] locations, int start, int finish, int fuel){
        if(memo[start][fuel]!=-1){
            return memo[start][fuel] ;
        }
        memo[start][fuel] = 0 ;
        if(Math.abs(locations[start]-locations[finish]) > fuel){
            return 0 ;
        }
        for(int i=0; i<locations.length; i++){
            if(i!=start){
                int cost ;
                if((cost=Math.abs(locations[start]-locations[i]))<=fuel){
                    memo[start][fuel] += dfs(locations,i,finish,fuel-cost) ;
                    memo[start][fuel] %= mod ;
                }
            }
        }
          if(start==finish){
                memo[start][fuel]++ ;
                memo[start][fuel]%=mod ;
            }
        return memo[start][fuel] ;
    }
}

在这里插入图片描述
8-最长递增路径
题目链接：题目链接戳这里！！！

思路：记忆化搜索，哈哈，这一题竟然重复了，
memo[x][y]是记忆化数组，表示到达当前坐标位置时的最长递增路径长度。从每个点开始，沿着四个方向记忆化搜索，找出每轮搜索找到的最大值，再将所有的最大值进行比较，选出最大的即可。

class Solution {
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    int [][] memo ;
    public int longestIncreasingPath(int[][] matrix) {
        int max = Integer.MIN_VALUE ;
        memo = new int [matrix.length][matrix[0].length] ;
        for(int [] arr : memo){
            Arrays.fill(arr,-1) ;
        }
        for(int i=0; i<matrix.length; i++){
            for(int j=0; j<matrix[0].length; j++){
                max = Math.max(max, dfs(matrix,i,j)) ;
            }
        }
        return max ;
    }
    public int dfs(int [][] matrix, int x, int y){
        if(memo[x][y] != -1){
            return memo[x][y] ;
        }
        memo[x][y] = 1 ;
        for(int i=0; i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx<0 || ty<0 || tx>matrix.length-1 || ty>matrix[0].length-1 || matrix[tx][ty]<=matrix[x][y]){
                continue ;
            }
            memo[x][y]= Math.max(memo[x][y],dfs(matrix,tx,ty)+1) ;
        }
        return memo[x][y] ;
    }

}

在这里插入图片描述
9-吃掉n个橘子的最少天数
题目链接：题目链接戳这里！！！

思路：记忆化递归
map.get(n)表示吃掉n个橘子所需的最少天数

用f(i)表示吃掉i个橘子所需要的最少天数。
在这里插入图片描述

class Solution {
    Map<Integer, Integer> map = new HashMap<>() ;
    public int minDays(int n) {
        if(n<=1){
            return n ;
        }
        if(map.containsKey(n)){
            return map.get(n) ;
        }
        map.put(n,Math.min(n%2+1+minDays(n/2),n%3+1+minDays(n/3))) ;
        return map.get(n) ;
        
    }
}

在这里插入图片描述
10-有向图中最大颜色值
题目链接：题目链接戳这里！！！

思路：邻接表+dfs+dp
dfs+flag：判断是否成环
dp[i][26]：动态规划记录以i为起点的有效路径中，各颜色的最大值

class Solution {
    char [] color ;
    int [][] dp ;
    int res=0 ;
    public int largestPathValue(String colors, int[][] edges) {
        int [] flag = new int [colors.length()] ;
        dp = new int [colors.length()][26] ;//以i为起点的有效路径中，各颜色的最大值
        color = colors.toCharArray() ; //记录每个点的颜色
        List<List<Integer>> adj = new ArrayList<>() ;
        for(int i=0; i<colors.length(); i++){
            adj.add(new ArrayList<>()) ;
        }  
        for(int [] edge : edges){ //建立邻接表
            adj.get(edge[0]).add(edge[1]) ; 
        }
        for(int i=0; i<colors.length(); i++){
            if(!dfs(adj,i,flag)){
                return -1 ;
            }
        }
        return res ;
    }
    public boolean dfs(List<List<Integer>> adj, int i, int [] flag){
        if(flag[i]==-1){ //上一轮访问过
            return true ;
        }
        if(flag[i]==1){ //有环
            return false ;
        }
        flag[i] = 1 ;
        for(int j : adj.get(i)){
            if(!dfs(adj,j,flag)){
                return false ;
            }
            for(int k=0; k<26; k++){
                dp[i][k] = Math.max(dp[i][k],dp[j][k]) ;
            }
        }
        flag[i] = -1 ;
        dp[i][color[i]-'a'] += 1 ;
        res = Math.max(dp[i][color[i]-'a'],res) ;
        return true ;

    }
}

在这里插入图片描述

nuist__NJUPT
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode分类-leetcode:进行leetcode刷题而已
06-30
【标题】: "LeetCode 分类刷题指南" 【描述】: LeetCode 是一个深受程序员喜爱的在线编程挑战平台，它提供了丰富的算法和数据结构题目，帮助开发者提升技能，为面试和实际工作做好准备。本资源是针对LeetCode平台...
非科班出身程序员刷题-leetcode:按tag区分的刷题列表,充会员整理的按leetcode频率热度排序的刷题列表每个tag的top42(宇
07-07
个人刷题总结 数组问题 字符串 树 哈希表 动态规划 深度优先搜索 二分查找 贪心 双指针 广度优先搜索 栈 回溯算法 设计 链表 排序 堆 位运算 图 并查集 分治算法 滑动窗口 】 字典树 递归 有序映射 线段树 队列 数学...
记忆化搜索例题
Skywalker_____的博客
03-11 267
例题一：乘法游戏时间限制:1Sec内存限制:128MB题目描述乘法游戏是在一行牌上进行的。每一张牌包括了一个正整数。在每一个移动中，玩家拿出一张牌，得分是用它的数字乘以它左边和右边的数，所以不允许拿第1张和最后1张牌。最后一次移动后，这里只剩下两张牌，你的目标是使得分的和最小。例如，如果数是10 1 50 20 5，依次拿1、20、50，总分是10150+50205+10505=8000而拿50、20、1，总分是15020+1205+1015=1150。输入输入文件的第一行包括牌数(3<=n<=
【leetcode】记忆化搜索
最新发布
m0_70088010的博客
02-22 456
记忆化搜索
leetcode单词拆分python-动态规划和记忆化搜索
苏钟白的博客
03-17 738
动态规划与记忆化搜索
leetcode486. 预测赢家-【python3详细图解】递归+记忆化搜索与动态规划思路
闯入网络安全的数据分析小白
12-12 540
leetcode486递归+记录化搜索与动态规划的实现过程
【LeetCode】自由之路 [H]（记忆化搜索）
小七的博客
10-07 212
LeetCode 514：给定一个字符串 ring，表示刻在外环上的编码；给定另一个字符串 key，表示需要拼写的关键词。您需要算出能够拼写关键词中所有字符的最少步数。采用记忆化搜索求解。
leetcode:算法刷题
05-23
总结，LeetCode的JavaScript算法刷题之旅不仅能够帮助你巩固语言基础，还能提升你的算法思维，为实际工作中的问题解决提供强大的工具箱。坚持每周至少两题，结合实践与理论，你将逐渐成为一名熟练的JavaScript算法...
leetcode 刷题记录 截止到328题
07-24
9. **效率优化**：通过减少时间复杂度或空间复杂度提高算法效率，如使用双指针技巧、记忆化搜索等。 10. **设计模式**：如工厂模式、单例模式等，虽然在LeetCode题目中不常见，但在实际项目开发中非常有用。 ...
code-for-interview:LeetCode刷题记录
03-17
理解状态转移方程和记忆化搜索技巧是关键。 三、树与图 1. 树结构：二叉树、平衡树（如AVL和红黑树）、堆等，是数据结构中的重要组成部分。Python中，可以自定义节点类来表示树结构。 2. 图论：图的遍历（深度...
LeetCode·139.单词拆分·递归·记忆化搜索·字典树
m0_64560763的博客
09-21 301
递归·记忆化搜索·字典树
【LeetCode: 62. 不同路径 | 暴力递归=＞记忆化搜索=＞动态规划 】
Coder_ljw的博客
04-28 753
【LeetCode: 62. 不同路径 | 暴力递归=＞记忆化搜索=＞动态规划 】一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨🌲 作者简介：硕风和炜，CSDN-Java领域新星创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎
LeetCode 1105. Filling Bookcase Shelves【记忆化搜索,动态规划】中等
memcpy0的博客
04-20 178
本文属于「征服LeetCode」系列文章之一，这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁，本系列将至少持续到刷完所有无锁题之日为止；由于LeetCode还在不断地创建新题，本系列的终止日期可能是永远。在这一系列刷题文章中，我不仅会讲解多种解题思路及其优化，还会用多种编程语言实现题解，涉及到通用解法时更将归纳总结出相应的算法模板。。
Leetcode 802. 找到最终的安全状态（DFS + 记忆化搜索）
AAS48的博客
09-06 181
图由一个 索引从 0 开始 的 2D 整数数组 graph表示， graph[i]是与节点 i 相邻的节点的整数数组，这意味着从节点 i 到 graph[i]中的每个节点都有一条边。如果一个节点没有连出的有向边，则它是 终端节点。如果从该节点开始的所有可能路径都通向 终端节点 ，则该节点为 安全节点。判断一个节点是否是安全节点：1、如果其出度是终端节点，没问题。输入：graph = [[1,2],[2,3],[5],[0],[5],[],[]]节点 5 和节点 6 是终端节点，因为它们都没有出边。
记忆化搜索题目
weixin_47750287的博客
04-14 254
洛谷P1216 数字三角形 Number Triangles 题目描述 观察下面的数字金字塔。 写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 在上面的样例中,从 7 \to 3 \to 8 \to 7 \to 57→3→8→7→5 的路径产生了最大 输入格式 第一个行一个正整数 rr
记忆化搜索题单
辉小歌的博客
04-13 266
目录P1434 [SHOI2002]滑雪【经典记忆搜】 P1434 [SHOI2002]滑雪【经典记忆搜】 #include<bits/stdc++.h> using namespace std; const int N=110; int f[N][N],h[N][N],n,m; int st[N][N]; int dx[4]={-1,0,0,1}; int dy[4]={0,-1,1,0}; int dfs(int x,int y) { if(st[x][y]) return f[x][y
【LeetCode】我能赢吗 [M]（记忆化搜索）
小七的博客
09-27 1177
在 "100 game" 这个游戏中，两名玩家轮流选择从 1 到 10 的任意整数，累计整数和，先使得累计整数和 达到或超过 100 的玩家，即为胜者。 如果我们将游戏规则改为“玩家 不能 重复使用整数”呢？ 例如，两个玩家可以轮流从公共整数池中抽取从 1 到 15 的整数（不放回），直到累计整数和 >= 100。 给定两个整数 maxChoosableInteger （整数池中可选择的最大数）和 desiredTotal（累计和），若先出手的玩家是否能稳赢则返回 true ，否则返回 false 。
记忆化搜索例题 记忆化搜索
zamaochick的博客
04-09 532
1.poj 1579 题目链接： http://poj.org/problem?id=1579 代码如下： #include <cstdio> #include <cstring> #include <algorithm> #include <iostream> using namespace std; const int maxn=1e...
【算法题】LeetCode691、贴纸拼词（剪枝+记忆化搜索）
x0919的博客
06-24 753
帖纸拼词问题（剪枝+记忆化搜索）
LeetCode 刷题汇总1
08-03
LeetCode 刷题汇总1

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nuist__NJUPT

给个鼓励吧，谢谢你

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值