动态规划——面试必刷TOP101

最新推荐文章于 2024-01-24 09:46:39 发布
最新推荐文章于 2024-01-24 09:46:39 发布
阅读量957 收藏 1
点赞数
分类专栏： 题目记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xmm18323188267Ella/article/details/124624595
版权

动态规划

BM62 斐波那契数列

public class Solution {
    public int Fibonacci(int n) {
        int a=0,b=1,c=0;
        for(int i=0;i<n;i++){
            c=a+b;
            a=b;
            b=c;
        }
        return a;
    }
}

BM63 跳台阶

public class Solution {
    public int jumpFloor(int n) {
        int a=1,b=1,c=0;
        for(int i=0;i<n;i++){
            c=a+b;
            a=b;
            b=c;
        }
        return a;
    }
}

BM64 最小花费爬楼梯

import java.util.*;

public class Solution {

    public int minCostClimbingStairs (int[] cost) {
        int n=cost.length;
        int[] dp=new int[n];//dp[i]代表爬到这层,再向上爬需要耗费的最小值
        dp[0]=cost[0];
        dp[1]=cost[1];
        for(int i=2;i<n;i++){
            dp[i]=Math.min(dp[i-1],dp[i-2])+cost[i];
        }
        return Math.min(dp[n-1],dp[n-2]);
    }
}

BM65 输出两个字符串的最长公共子序列(不连续）

import java.util.*;

public class Solution {

    public String LCS (String s1, String s2) {
        int m=s1.length(),n=s2.length();
        int[][] dp=new int[m+1][n+1];
         //dp[i][j] 的含义是 s1[0:i-1] 和 s2[0:j-1] 的最长公共子序列的长度。
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(s1.charAt(i-1)==s2.charAt(j-1)) dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        // return dp[m][n];
        if(dp[m][n]==0) return "-1";
        StringBuilder sb=new StringBuilder();
        while(m>0 && n>0){
            if(s1.charAt(m-1)==s2.charAt(n-1)){
                sb.append(s1.charAt(m-1));
                m--;
                n--;
            }else{
                if(dp[m-1][n]>dp[m][n-1]) m--;
                else n--;
            }
        }
        return sb.reverse().toString();
    }
}

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int n1 = text1.length(),n2 = text2.length();
        int[][] dp = new int[n1 + 1][n2 + 1];
        for (int i = 1; i <= n1; i++) {
            for (int j = 1; j <= n2; j++) {
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return dp[n1][n2];
    }
}

BM66 输出两个字符串的最长公共子串(连续）

import java.util.*;

public class Solution {

    public String LCS (String s1, String s2) {
        int m=s1.length(),n=s2.length();
        int[][] dp=new int[m+1][n+1];
        int res=0,end=0;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(s1.charAt(i-1)==s2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+1;
                    if(dp[i][j]>res){
                        res=dp[i][j];
                        end=i-1;
                    }
                }
            }
        }
        String s=s1.substring(end+1-res,end+1);
        return s;
    }
}

class Solution {
    public int findLength(int[] A, int[] B) {
        int m = A.length,n = B.length;
        int[][] dp = new int[m + 1][n + 1];//dp[i][j]代表以A[i-1]与B[j-1]结尾的公共字串的长度
        int res = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (A[i - 1] == B[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    res = Math.max(res,dp[i][j]);
                }
            }
        }
        return res;
    }
}

BM67 在m×n的矩阵上从左上角到右下角不同路径的数目

import java.util.*;

public class Solution {

    public int uniquePaths (int m, int n) {
        int[][] dp=new int[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(i==0) dp[0][j]=1;
                else if(j==0) dp[i][0]=1;
                else dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
}

BM68 在m×n的矩阵上从左上角到右下角的最小路径和

import java.util.*;

public class Solution {

    public int minPathSum (int[][] matrix) {
        int m=matrix.length,n=matrix[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(i==0 && j==0) continue;
                else if(i==0) matrix[0][j]+=matrix[0][j-1];
                else if(j==0) matrix[i][0]+=matrix[i-1][0];
                else matrix[i][j]+=Math.min(matrix[i-1][j],matrix[i][j-1]);
            }
        }
        return matrix[m-1][n-1];
    }
}

BM69 把数字翻译成字符串(‘a’->1, ‘b->2’, … , ‘z->26’)

import java.util.*;

public class Solution {

    public int solve (String nums) {
        if(nums==null ||nums.length()==0) return 0;
        int[] dp = new int[nums.length()+1];
        dp[0]=1;//dp[i]表示nums[0,i-1]的译码方法有多少种。
        dp[1]=nums.charAt(0)=='0'?0:1;
        for(int i=2;i<dp.length;i++){
            //nums[i-1]无法独立编码也无法nums[i-2]和nums[i-1]组合编码
            if(nums.charAt(i-1)=='0' && (nums.charAt(i-2)=='0' || nums.charAt(i-2)>'2')) return 0;
            //只能nums[i-2]和nums[i-1]组合编码
            else if(nums.charAt(i-1)=='0') dp[i] = dp[i-2];
            //nums[i-1]只能独立编码
            else if(nums.charAt(i-2)=='0' || nums.charAt(i-2)>'2' || nums.charAt(i-2)=='2'&& nums.charAt(i-1)>'6' )
                dp[i] = dp[i-1];
            //两种编码方式都可以
            else dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[nums.length()];
    }
}

BM70 兑换零钱

import java.util.*;

public class Solution {
    public int minMoney (int[] arr, int aim) {
        int[] dp=new int[aim+1];
        Arrays.fill(dp,aim+1);
        dp[0]=0;
        for(int i=1;i<=aim;i++){
            for(int j=0;j<arr.length;j++){
                if(i>=arr[j]) dp[i]=Math.min(dp[i],dp[i-arr[j]]+1);
            }
        }
        return dp[aim]>aim?-1:dp[aim];
    }
}

BM71 最长上升子序列(不连续)

import java.util.*;

public class Solution {

    public int LIS(int[] nums) {
        int n=nums.length;
        if(n<=1) return n;
        int[] dp=new int[n];//dp[i]表示以nums[i]结尾的最长上升子序列的长度。
        Arrays.fill(dp,1);
        for(int i=1;i<n;i++){
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]) dp[i]=Math.max(dp[i],dp[j]+1);
            }
        }
        int res=0;
        for(int i=0;i<n;i++) res=Math.max(res,dp[i]);
        return res;
    }
}

BM72 连续子数组的最大和

public class Solution {
    public int FindGreatestSumOfSubArray(int[] arr) {
        for(int i=1;i<arr.length;i++){
            arr[i]+=Math.max(arr[i-1],0);//以arr[i]结尾的连续子数组的最大和
        }
        int res=arr[0];
        for(int i=1;i<arr.length;i++){
            res=Math.max(res,arr[i]);
        }
        return res;
    }
}

BM73 最长回文子串

import java.util.*;

public class Solution {

    public int getLongestPalindrome(String s) {
        int n = s.length();
        //String res = "";
        int res = 0;
        for (int i = 0; i < 2 * n - 1; i++) {
            int l = i / 2;
            int r = l + i % 2;
            while (l >= 0 && r < n && s.charAt(l) == s.charAt(r)) {
                res=Math.max(res,r-l+1);
                //String tmp = s.substring(l, r + 1);
                //if (tmp.length() > res.length()) res = tmp;
                l--;
                r++;
            }
        }
        return res;
    }
}
647. 回文子串的数目
class Solution6472 {
    public int countSubstrings(String s) {
        int n = s.length();
        int res = 0;
        for (int i = 0; i < 2 * n - 1; i++) {
            int l = i / 2;
            int r = l + i % 2;
            while (l >= 0 && r < n && s.charAt(l) == s.charAt(r)) {
                res++;
                l--;
                r++;
            }
        }
        return res;
    }
}

BM75 编辑距离

import java.util.*;

public class Solution {
/*
dp[i][j] 代表 word1[0,i-1]位置转换成 word2[0,j-1]位置需要最少步数
当 word1[i] == word2[j]，dp[i][j] = dp[i-1][j-1]；
当 word1[i] != word2[j]，dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1
其中，dp[i-1][j-1] 表示替换操作，dp[i-1][j] 表示删除操作，dp[i][j-1] 表示插入操作。
*/
    public int editDistance(String word1, String word2) {
        int n1=word1.length(),n2=word2.length();
        int[][]dp=new int [n1+1][n2+1];
        for(int j=1;j<=n2;j++) dp[0][j]=dp[0][j-1]+1;//插入
        for(int i=1;i<=n1;i++) dp[i][0]=dp[i-1][0]+1;//删除
        for(int i=1;i<=n1;i++){
            for(int j=1;j<=n2;j++){
                if(word1.charAt(i-1)==word2.charAt(j-1)) dp[i][j]=dp[i-1][j-1];
                else dp[i][j]=Math.min(Math.min(dp[i-1][j-1],dp[i-1][j]),dp[i][j-1])+1;
            }
        }
        return dp[n1][n2];
    }
}

BM76 正则表达式匹配

import java.util.*;
/*
最后来个归纳：
如果 p.charAt(j) == s.charAt(i) : dp[i][j] = dp[i-1][j-1]；
如果 p.charAt(j) == '.' : dp[i][j] = dp[i-1][j-1]；
如果 p.charAt(j) == '*'：
    如果 p.charAt(j-1) != s.charAt(i) : dp[i][j] = dp[i][j-2] //in this case, a* only counts as empty
    如果 p.charAt(j-1) == s.charAt(i) or p.charAt(j-1) == '.':
        dp[i][j] = dp[i-1][j] //in this case, a* counts as multiple a
        or dp[i][j] = dp[i][j-1] // in this case, a* counts as single a
        or dp[i][j] = dp[i][j-2] // in this case, a* counts as empty
*/
public class Solution {
    public boolean match(String s, String p) {
        //往原字符头部插入空格，这样得到 char 数组是从 1 开始，
        //而且可以使得 f[0][0] = true，可以将 true 这个结果滚动下去
        s = " " + s;
        p = " " + p;  
        int n = s.length(),m = p.length();
        boolean[][] dp = new boolean[n][m];//dp[i][j]表示s[0,i]与p[0,j]是否匹配
        dp[0][0] = true;
        if(p.charAt(1) == s.charAt(1) || p.charAt(1) == '.')dp[1][1] = true;
        for(int i = 0;i < n;i++){
            for(int j = 1;j < m;j++){
                if(p.charAt(j) != '*'){
                    if(i > 0)dp[i][j] = dp[i-1][j-1] && 
                        (p.charAt(j) == s.charAt(i) || p.charAt(j) == '.');
                }else {
                   if(i > 0) dp[i][j] = dp[i][j-2] || dp[i-1][j] && 
                       (p.charAt(j-1) == s.charAt(i) || p.charAt(j-1) == '.');
                   else{
                       dp[i][j] = dp[i][j - 2]; 
                   }
                }
            }
        }
        return dp[n-1][m-1];
    }
}

BM77 最长的括号子串

import java.util.*;

public class Solution {
    Stack<Integer> stack = new Stack<>();
    public int longestValidParentheses(String s) {
        if(s==null || s.length()==0) return 0;
        char[] c = s.toCharArray();
        int[] mark = new int[s.length()]; 
        for(int i=0; i<s.length(); i++){
            if(c[i]=='(') stack.push(i);//对于遇到的每个'('，我们将它的下标放入栈中
            else{
                if(!stack.isEmpty() && c[stack.peek()]=='('){
                    mark[stack.pop()] = 1;//与当前右括号所匹配的左括号
                    mark[i] = 1;//当前右括号   
                }
            }
        }
        int max = 0,cur = 0;
        for(int i:mark){
            if(i==1){
                cur ++;
                max = Math.max(max,cur);
            }else cur = 0;
        }
        return max;
    }
}

BM78 打家劫舍(一)

import java.util.*;

public class Solution {

    public int rob (int[] nums) {
        int n=nums.length;
        int[] dp=new int[n+1];
        dp[0]=0;
        dp[1]=nums[0];
        for(int i=2;i<=n;i++){
            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i-1]);
        }
        return dp[n];
    }
}

BM79 打家劫舍(二)

import java.util.*;

public class Solution {

    public int rob (int[] nums) {
        int n=nums.length;
        //一个是从0到n-1，另一个是从1到n，然后返回两个结果最大的。
        int rob1=getRob(Arrays.copyOfRange(nums,0,n-1));
        int rob2=getRob(Arrays.copyOfRange(nums,1,n));
        return Math.max(rob1,rob2);       
    }
    
    private int getRob(int[] nums){  
        int n=nums.length;
        int[] dp=new int[n+1];
        dp[0]=0;
        dp[1]=nums[0];
        for(int i=2;i<=n;i++){
            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i-1]);
        }
        return dp[n];
    }
}

BM80 买卖股票的最好时机(一)

import java.util.*;

public class Solution {

    public int maxProfit (int[] prices) {
        int cost=Integer.MAX_VALUE,res=0;
        for(int price:prices){
            cost=Math.min(price,cost);
            res=Math.max(res,price-cost);
        }
        return res;
    }
}

BM81 买卖股票的最好时机(二)

import java.util.*;

public class Solution {

    public int maxProfit (int[] prices) {
        int res=0;
        for(int i=1;i<prices.length;i++){
            if(prices[i]>prices[i-1]) res+=prices[i]-prices[i-1];
        }
        return res;
    }
}

BM82 买卖股票的最好时机(三)

import java.util.*;

public class Solution {

    public int maxProfit(int[] prices) {
        int firstBuy = Integer.MIN_VALUE, firstSell = 0;
        int secondBuy = Integer.MIN_VALUE, secondSell = 0;
        for(int p : prices) {
            firstBuy = Math.max(firstBuy, -p);
            firstSell = Math.max(firstSell, firstBuy + p);
            secondBuy = Math.max(secondBuy, firstSell - p);
            secondSell = Math.max(secondSell, secondBuy + p);
        }
        return secondSell;
    }
}
yy的旅行日志
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
“动态规划” 面试高频题——剑指offer精选万字总结
米莱虾
03-06 2197
❥分享初学DP时的两篇文章，希望对大家有所帮助❥ 算法设计与分析之 “动态规划” 经典习题总结&AC代码_夏旭的博客-CSDN博客 动态规划之4大背包问题详解_夏旭的博客-CSDN博客 首先我们大致了解一下动态规划 (dynamic programming) 的定义和核心套路： 动态规划 (DP) 是一种算法技术，它将大问题分解为更简单的子问题，对整体问题的最优解决方案取决于子问题的最优解决方案。 某些问题往往有 2个特征：重叠子问题、最优子结构。而用动规可以高效率地处理具有这...
在线编程——动态规划常见的面试问题总结（Python）
GeekZW的博客
08-29 8611
在线编程——动态规划常见的面试问题总结（Python） O、求解方法：阶段 + 状态变量 + 状态转移方程 + 边界条件 （1）划分阶段：按照问题的时间或空间特征，把问题分为若干个阶段。在划分阶段时，注意划分后的阶段一定要是有序的或者是可排序的，否则问题就无法求解。 （2）确定状态和状态变量：将问题发展到各个阶段时所处于的各种...
算法笔记_面试题_18.动态规划_模板及示例十几道(上)
惊鸿一博
11-13 627
目录 1. 引例 例1.数字三角形最小路径和 代码1_ traverse法 代码2_ 分治法DC 代码3_动态规划DP_记忆化搜索（分治法DC + 记忆化） 代码4_动态规划DP_多重循环（本文重点，重点记忆） 动态规划方法对比：记忆化搜索 对比 多重循环 2. 动态规划的套路 2.1 动态规划的四点要素 2.2什么情况下使用动态规划？ 2.3什么情况下不使用动态规划？ 2.4面试中常见的动态规划类型 参考：九章算法 lintocde leetcode 代码随想录carl ...
10｜面试即正义第二期：常见的动态规划面试题串烧
最新发布
qq_37756660的博客
01-24 955
以上就是求方案总数类型问题，以及求可行性类型问题的解法了。事实上，我们完全可以通过转化其它类型的问题，来得到求可行性类型的动态规划问题。比如说，在带障碍的路径规划中，我们求的是路径总数。但是，当我将题目改一下：问能否从起点移动到终点？这样就变成了求可行性的问题。我们依然在遵循之前给出的动态规划解题模板来求解问题。首先，根据重叠子问题、无后向性和最优子结构来确定能否用动态规划解题。然后，再确定初始化状态、状态参数，接着确定状态存储数组（即备忘录），最终写出关键的状态转移方程。
动态规划面试题
豆子
08-30 361
一、简单DP 礼物最大价值(矩阵贪心类题目)剑指 Offer 47 class Solution { public: int maxValue(vector<vector<int>>& grid) { int m = grid.size(), n = grid[0].size(); for(int i =...
大厂测试开发工程师面试基础——Linux命令
03-10
top 命令用于实时显示 process 的动态。使用权限：所有使用者。 语法：top [-] [d delay] [q] [c] [S] [s] [i] [n] [b] 参数说明： * d : 改变显示的更新速度，或是在交谈式指令列（interactive command）按 s * ...
WEB前端面试——常见CSS知识点
06-30
WEB前端面试——常见CSS知识点 CSS是一种标记语言，用于描述网页的样式和布局。以下是常见的CSS知识点： 一、CSS盒子模型 CSS盒子模型分为标准盒模型（content-box）和怪异盒模型（border-box）。标准盒模型的...
LeetCode 精选 TOP 面试题（2）1
08-04
这是经典的动态规划问题—— Kadane's Algorithm。目标是找到数组中和最大的连续子数组。我们定义状态f[i]表示以nums[i]为结尾的最大子数组和。状态转移方程是f[i] = max(f[i - 1] + nums[i], nums[i])，这表示当前...
程序员面试题精选.doc
12-13
【程序员面试题精选】——用两个栈实现队列 在面试中，经常会出现这样一道题：如何使用两个栈来模拟一个队列的行为。这道题目旨在考察候选者对数据结构的理解，尤其是对栈（LIFO，后进先出）和队列（FIFO，先进先出...
Ajax面试题
06-07
Ajax面试题详解 Ajax是近年来流行的一种技术，它允许浏览器与服务器进行通信，而无须刷新当前页面。下面是关于Ajax面试题的详解。 1. 富客户端和薄客户端 富客户端（Rich Client）是利用具有很强交互性的富客户端...
面试题-动态规划
03-20 333
一、什么是动态规划？ 动态规划就是通过采用分而治之的策略，通过解决大问题的子问题从而解决整体的做法。动态规划的核心思想就是将大问题拆分成多个子问题，按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。 动态规划有三个重要的概念 ...
阿里动态规划面试题之机器人运动问题
weixin_43923436的博客
06-08 519
题目描述 给你几个参数： N：代表总共有多少个位置。 S：机器人的出发位置。 E：机器人的目的地。 K：机器人必须走K步。 问题：请你求出机器人从S起始位置走K步到达终止位置E，一共有多少种走法？注意，每次机器人必须走一步，不能留在原地，每次只能走一格，可以向右或者向左。 暴力递归 递归终止条件base case： 那就是K走完了呗，如果停在目标位置，就是一种走法，如果没停在目标位置，就返回0. 递归函数： 如果到了边界，就只有向里走，如果不在边界，就可以向两边任意走，最后累加上所有结果。 代码 p
面试中的动态规划
qq_15288217的博客
06-15 619
机器学习面试，被问过最多的数据结构类题目是动态规划（Dynamic Programming，即DP）。所以总结一下剑指offer中常见的几种DP题目，供后续的回顾与学习。首先，DP题目的几种类型为：递推、背包、连续子序列最大和、最长公共子序列。1、递推典型题目：剑指offer——09 斐波那契数列理由：因为斐波那契数列的第F(n)项的解，包含了子问题F(n-1)项的解，即该问题具有“最优子结构”性...
剑指Offer（第二版）面试题14：剪绳子（动态规划）
热门推荐
冷血之心的博客
06-16 1万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/73351134冷血之心的博客） 剑指Offer（第二版）面试题14：剪绳子 题目一：给你一根长度为n的绳子，请把绳子剪成m段 (m和n都是整数，n>1并且m>1)每段绳子的长度记为k[0],k[1],...,k[m].请问k[0]*k[...
《剑指offer》面试题14：剪绳子（动态规划、贪婪算法）
Tianzez的博客
01-26 5483
更多剑指offer面试习题请点击： 《剑指offer》（第二版）题集目录索引 题目： 给你一根长度为n绳子，请把绳子剪成m段（m、n都是整数，n&gt;1并且m&gt;1）。每段的绳子的长度记为k[0]、k[1]、……、k[m]。k[0] * k[1]*…*k[m]可能的最大乘积是多少？例如当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到最大的乘积18。 解题思路：...
动态规划-面试题
void
07-14 8058
动态规划算法面试题
【编程练习】动态规划常规题目(经典常考重点）
Michelle
07-15 477
1 连续子数组和 时间限制：1秒 空间限制：32768K 热度指数：253787 本题知识点： 数组 题目描述 HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,...
动态规划解题思考
ss123mlk的博客
06-29 226
一点思考 看不懂可以评论讨论一下 思考问题的结果是什么 然后就设你的状态是什么意义 并且根据状态确定转移方程 其中状态数组的确定要注意长度 和 整体的初始值 以及0等边界的赋值 进入双层for循环 或者单层的for循环 外层的循环从i=1开始了 因为0等边界已经在外边赋值过了 因为动态规划的核心就是 你到当前的点就是一次选择 他还让你站在当前的选择去进行其他选择 所以进入外层循环 之后 自己来处理 二维抉择是不用for循环就可以解决 还是要借助 并且在二维抉择当中经常要有判断和防御 最后返回的是状态的最后一
【编程之路】面试必刷TOP101：动态规划（入门）（62-66，Python实现）
书山有路，学海无涯。记录成长，追逐梦想
08-07 400
面试必刷TOP101：动态规划（入门）（62-66，Python实现）
动态规划——礼物的最大价值python
05-26
题目描述 在一个 m*n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定的价值（大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或向下移动一格直到到达棋盘的右下角。给定一个棋盘及其上面的礼物，请计算你最多能拿到多少价值的礼物？ 示例 1: 输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 12 解释: 路径 1→3→5→2→1 可以拿到最多价值礼物 提示： 0 < grid.length <= 200 0 < grid[0].length <= 200 解题思路 这道题可以用动态规划解决。我们可以定义一个 dp 数组，其中 dp[i][j] 表示到达 i,j 位置时能拿到的最大价值。那么我们可以得到状态转移方程： dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid[i][j] 其中 dp[i-1][j] 表示从上面的格子到达当前格子，dp[i][j-1] 表示从左边的格子到达当前格子，grid[i][j] 表示当前格子的价值。 最后返回 dp[m-1][n-1] 即可。 代码实现 Python 代码

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值