牛客刷题-动态规划

已于 2024-04-27 15:54:12 修改
阅读量210 收藏 2
点赞数 8
文章标签： 动态规划 算法 数据结构
于 2024-04-18 21:57:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaqaz/article/details/137888844
版权
文章详细介绍了动态规划在解决斐波那契数列、跳台阶、最长公共子序列、最长公共子串、不同路径数、矩阵最小路径和、数字翻译、兑换零钱问题以及打家劫舍问题中的应用。这些问题是编程中常见的字符串处理和优化路径问题，展示了动态规划方法的应用。
摘要由CSDN通过智能技术生成

动态规划

1.斐波那契数列

大家都知道斐波那契数列，现在要求输入一个正整数 n ，请你输出斐波那契数列的第 n 项。斐波那契数列是一个满足:
当x= 1,2时，f(x)=1；当x>2时，f(x) = f(x-1) + f(x-2).

代码如下（示例）：

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param n int整型 
     * @return int整型
     */
    public int Fibonacci (int n) {
        // write code here
        if(n < 0){
            return -1;
        }
        if(n ==1 || n==2){
            return 1;
        }
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
}

2.跳台阶

描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

代码如下（示例）：
在这里插入图片描述

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param number int整型 
     * @return int整型
     */
    public int jumpFloor (int number) {
        // write code here
        if(number <= 1){
            return 1;
        }
        return jumpFloor(number - 1) + jumpFloor(number - 2);
    }
}

该处使用的url网络请求的数据。

3.最长公共子序列(二)

描述：给定两个字符串str1和str2，输出两个字符串的最长公共子序列。如果最长公共子序列为空，则返回"-1"。目前给出的数据，仅仅会存在一个最长的公共子序列。

代码如下（示例）：

public class Solution {
    /**
     * longest common subsequence
     * @param s1 string字符串 the string
     * @param s2 string字符串 the string
     * @return string字符串
     */
    public String LCS (String s1, String s2) {
        // write code here
        if(s1.length()==0 || s2.length()==2){
            return "-1";
        }
        int len1 = s1.length();
        int len2 = s2.length();
        String[][] dp = new String[len1 + 1][len2 + 1];
        for(int i= 0; i <=len1; i++){
            dp[i][0] = "";
        }
        for(int j =0; j <= len2; j++){
            dp[0][j] = "";
        }
        for (int i=1; i <= len1; i++){
            for(int j = 1; j <= len2; j ++){
                if(s1.charAt(i-1) == s2.charAt(j - 1)){
                    dp[i][j] = dp[i-1][j-1] + s1.charAt(i-1);
                }else{
                    dp[i][j] = dp[i-1][j].length() > dp[i][j-1].length() ? dp[i-1][j] : dp[i][j-1];
                }
            }
        }
        // int i = len1,j = len2;
        // Stack<Character> s = new Stack<Character>();
        // while(dp[i][j] != 0){
        //     if(dp[i][j] == dp[i-1][j]){
        //         i--;
        //     }else if(dp[i][j] == dp[i][j-1]){
        //         j--;
        //     }else if(dp[i][j] > dp[i-1][j-1]){
        //         i--;
        //         j--;
        //         s.push(s1.charAt(i));
        //     }
        // }
        // String res = "";
        // while(!s.isEmpty()){
        //     res += s.pop();
        // }
        // return !res.isEmpty() ? res : "-1";
        return dp[len1][len2] == "" ? "-1" : dp[len1][len2];
    }
}

4.最长公共子串

描述：给定两个字符串str1和str2,输出两个字符串的最长公共子串，题目保证str1和str2的最长公共子串存在且唯一。

代码如下（示例）：

public class Solution {
    /**
     * longest common substring
     * @param str1 string字符串 the string
     * @param str2 string字符串 the string
     * @return string字符串
     */
    public String LCS (String str1, String str2) {
        // write code here
        //公共子串最大长度
        int maxLen = 0;
        //公共子串最大长度的最后一个下标
        int maxlastLocation = 0;
        int len1 = str1.length(),len2 = str2.length();
        int[][] dp = new int[len1+1][len2+2];
        for(int i=0; i < len1; i ++){
            for(int j = 0; j < len2; j ++){
                if(str1.charAt(i) == str2.charAt(j)){
                    dp[i+1][j+1]=dp[i][j] + 1;
                    if(dp[i+1][j+1] > maxLen){
                        maxLen = dp[i+1][j+1];
                        maxlastLocation = i;
                    }
                }else {
                    dp[i+1][j+1] = 0;
                }
            }
        }
        return str1.substring(maxlastLocation-maxLen+1,maxlastLocation +1);
    }
}

5.不同路径的数目(一)

描述：一个机器人在m×n大小的地图的左上角（起点）。
机器人每次可以向下或向右移动。机器人要到达地图的右下角（终点）。
可以有多少种不同的路径从起点走到终点？
在这里插入图片描述

代码如下（示例）：

public class Solution {
    /**
     * @param m int整型 
     * @param n int整型 
     * @return int整型
     */
    public int uniquePaths (int m, int n) {
        int[][] dp = new int[m][n];
        // write code here
        for(int i = 0; i < m; i++){
            dp[i][0] = 1;
        }
        for(int j = 0; j < n; j++){
            dp[0][j] = 1;
        }
        for (int i = 1; i < m; i++){
            for (int j = 1; j < n; j++){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
}

6.矩阵的最小路径和

描述：给定一个 n * m 的矩阵 a，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，输出所有的路径中最小的路径和。
例如：当输入[[1,3,5,9],[8,1,3,4],[5,0,6,1],[8,8,4,0]]时，对应的返回值为12，
所选择的最小累加和路径如下图所示：
在这里插入图片描述

代码如下（示例）：

public class Solution {
    /**
     * @param matrix int整型二维数组 the matrix
     * @return int整型
     */
    public int minPathSum (int[][] matrix) {
        // write code here
        //行
        int row = matrix.length;
        //列
        int col = matrix[0].length;
        int[][] dp = new int[row+1][col+1];
        dp[0][0] = matrix[0][0];
        for(int i = 1; i < row; i++){
            dp[i][0] = matrix[i][0] + dp[i-1][0];
        }
        for(int j =1; j < col; j ++){
            dp[0][j] = matrix[0][j] + dp[0][j-1];
        }
        for(int i=1; i < row; i++){
            for(int j =1; j < col; j ++){
                dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + matrix[i][j];
            }
        }
        return dp[row-1][col-1];
    }
}

7.把数字翻译成字符串

描述：有一种将字母编码成数字的方式：‘a’->1, ‘b->2’, … , ‘z->26’。现在给一串数字，返回有多少种可能的译码结果：

代码如下（示例）：

public class Solution {
    /**
     * @param nums string字符串 数字串
     * @return int整型
     */
    public int solve (String nums) {
        // write code here
        //排除0
        if(nums.equals("0")){
            return 0;
        }
        //排除只有一种可能的10 和 20
        if(nums.equals("10") || nums.equals("20")){
            return 1;
        }
        //当0的前面不是1或2时，无法译码，0种
        for(int i = 1; i < nums.length(); i++){
            if(nums.charAt(i) == '0'){
                if(nums.charAt(i-1) != '1' && nums.charAt(i-1) != '2'){
                    return 0;
                }
            }
        }
        //辅助数组初始化为1
        int[] dp = new int[nums.length() + 1];
        Arrays.fill(dp,1);
        //在11-19，21-26之间的情况
        for(int i = 2; i <= nums.length(); i++){
            if(nums.charAt(i-2) == '1' && nums.charAt(i-1) != '0' || 
            nums.charAt(i-2) == '2' && nums.charAt(i-1) > '0' && nums.charAt(i-1) < '7'){
                dp[i] = dp[i-1] + dp[i-2];
            }else{
                dp[i] = dp[i-1];
            }
        }
        return dp[nums.length()];
    }
}

8.兑换零钱(一)

描述：给定数组arr，arr中所有的值都为正整数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个aim，代表要找的钱数，求组成aim的最少货币数。
如果无解，请返回-1。

代码如下（示例）：

public class Solution {
    /**
     * 最少货币数
     * @param arr int整型一维数组 the array
     * @param aim int整型 the target
     * @return int整型
     */
    public int minMoney (int[] arr, int aim) {
        // write code here
        if(arr.length == 0){
            return -1;
        }
        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(arr[j] <= i){
                    dp[i] = Math.min(dp[i],dp[i-arr[j]] + 1);
                }
            }
        }
        return dp[aim] > aim ? -1 : dp[aim];
    }
}

9.最长回文子串

描述：对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

代码如下（示例）：

方法一：动态规划
public class Solution {
    /**
     * @param A string字符串 
     * @return int整型
     */
    public int getLongestPalindrome (String A) {
        // write code here
        //定义字符串长度
        int n = A.length();
        //定义一个boolean型的数组
        boolean[][] dp = new boolean[n][n];
        //定义回文字符串初始值
        int res = 0;
        for(int len = 0; len < n+1; len ++){
            //定义i、j为子字符串的左右指针
            for(int i = 0; i < n - len; i ++){
                int j = len + i;
                //判断i、j当前位置是否相等
                if(A.charAt(i) == A.charAt(j)){
                    //如果相等，判断子串长度是否大于1，如果小于1，则是一个元素，设置为true
                    if(len <=1){
                        dp[i][j] = true;
                    }else{
                    //如果不相等，则判断字符串子串是否为回文子串
                        dp[i][j] = dp[i+1][j-1];
                    }
                    //如果是回文子串，则在len的长度上加1，因为len是从0开始的。
                    if(dp[i][j]){
                        res = len + 1;
                    }
                }
            }
        }
        return res;
    }
}

方法二：中心扩散法：
public class Solution {
    /**
     * @param A string字符串 
     * @return int整型
     */
    public int getLongestPalindrome (String A) {
        // write code here
        int n = A.length();
        if(n < 2){
            return n;
        }
        int res = 0;
        for(int i = 0; i < n; i++){
            int len = center(A,i,i) > center(A,i,i+1) ? center(A,i,i) : center(A,i,i+1);
            res = Math.max(len,res);
        }
        return res;
    }
    private int center(String A, int left, int right){
        while(left >= 0 && right < A.length()){
            if(A.charAt(left) == A.charAt(right)){
                left --;
                right ++;
                continue;
            }
            break;
        }
        return right - left + 1 - 2;
    }
}

10、打家劫舍(一)

描述：你是一个经验丰富的小偷，准备偷沿街的一排房间，每个房间都存有一定的现金，为了防止被发现，你不能偷相邻的两家，即，如果偷了第一家，就不能再偷第二家；如果偷了第二家，那么就不能偷第一家和第三家。
给定一个整数数组nums，数组中的元素表示每个房间存有的现金数额，请你计算在不被发现的前提下最多的偷窃金额。

代码如下（示例）：

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *dp[1] = nums[0]
     *dp[i] = max{dp[i-1],dp[i-2] + nums[i-1]}
     * 
     * @param nums int整型一维数组 
     * @return int整型
     */
    public int rob (int[] nums) {
        // write code here
        int len = nums.length;
        if(len ==0){
            return 0;
        }
        if(len == 1){
            return nums[0];
        }
        int[] dp = new int[len];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0],nums[1]);
        for(int i = 2; i < len; i ++){
            dp[i] = Math.max(dp[i-2] + nums[i],dp[i-1]);
        } 
        return dp[len-1];
    }
}

11、打家劫舍(二)

描述：你是一个经验丰富的小偷，准备偷沿湖的一排房间，每个房间都存有一定的现金，为了防止被发现，你不能偷相邻的两家，即，如果偷了第一家，就不能再偷第二家，如果偷了第二家，那么就不能偷第一家和第三家。沿湖的房间组成一个闭合的圆形，即第一个房间和最后一个房间视为相邻。
给定一个长度为n的整数数组nums，数组中的元素表示每个房间存有的现金数额，请你计算在不被发现的前提下最多的偷窃金额。

代码如下（示例）：

public class Solution {
    /**
     * @param nums int整型一维数组 
     * @return int整型
     */
    public int rob (int[] nums) {
        // write code here
        int n = nums.length;
        //在0到n-2范围内找
        int l1 = helper(Arrays.copyOfRange(nums,0,n-1));
        //在1到n-1范围内找
        int l2 = helper(Arrays.copyOfRange(nums,1,n));
        return Math.max(l1,l2);
    }
    private int helper(int[] nums){
        int n = nums.length;
        if(n==0) return 0;
        if(n == 1) return nums[0];
        if(n ==2) return Math.max(nums[0],nums[1]);
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0],nums[1]);
        for(int i= 2; i < n; i++){
            dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[n -1];
    }
}

总结

xiaqaz
关注
【牛客刷题-SQL进阶挑战】NO5.窗口函数
IT邦德
06-04 1716
SQL每个人都要用，但是用来衡量产出的并不是SQL本身，你需要用这个工具，去创造其它的价值。
牛客刷题记录--Mysql
Cheryl_Xu的博客
05-29 609
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录一、简单类1、SQL15 查找employees表emp_no与last_name的员工信息----奇数、为某值 一、简单类 1、SQL15 查找employees表emp_no与last_name的员工信息----奇数、为某值 where emp_no%2=1 and las
牛客刷题-树
qq_46034034的博客
03-21 496
牛客刷题-C/C++笔试题目
qq_44092751的博客
01-17 372
C/C++笔试牛客刷题
牛客刷题之动态规划
m0_60264772的博客
09-15 325
兄弟们，一起来刷题👉嘎嘎的写题。
【牛客刷题-算法】NC34 不同路径的数目(一) | 动态规划、组合数解法
成长之路
09-30 976
描述 一个机器人在m×n大小的地图的左上角（起点）。 机器人每次可以向下或向右移动。机器人要到达地图的右下角（终点）。 可以有多少种不同的路径从起点走到终点？
牛客刷题-SQL篇
xfz_0616的博客
07-13 747
聚合函数：1.SQL类别高难度试卷得分的截断平均值； 连接查询：1.满足条件的用户的试卷完成数和题目练习数； 2. 每个6/7级用户活跃情况
牛客刷题-数据库
qq_49477533的博客
06-10 85
牛客刷题-数据库
牛客刷题---JZ10 斐波那契数列
ljn1046016768的博客
03-14 415
描述 自己想到的解法： 递归实现 public class Solution { public int Fibonacci(int n) { if(n==1||n==2){ return 1; }else{ // n>2 return Fibonacci(n-1)+Fibonacci(n-2); } } } 优点，代码简单好写 缺点：慢，数字太大会超时 时间复杂度：O(2^
牛客刷题---简单
Let's Coding
02-07 411
牛客刷题---简单1题目要求题目分析如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 题目要求 一个有小到大的整形（包含正整数和负整数）数组 nums，数组最大1000个元素。求该数组中两个元素之和的绝对值最小的那个值并输出该绝对值。 按照由大到小的顺序在终端输入一行数字，
牛客刷题总结.docx
01-28
"牛客刷题总结" 本资源摘要信息主要涵盖了 Java 语言的基础知识点、设计模式和事务处理。下面是详细的知识点解释： 一、Java 基础知识 1. Java 源程序只能有一个 public 类存在，且类名与文件名相同。这是因为 ...
关于牛客刷题总结全部汇总
02-21
关于牛客刷题总结全部汇总 本资源摘要信息主要讲述了 Java 语言的基本概念、设计模式、MVC 模式、数学函数、重载和重写的区别、多态、数组、静态成员和方法、事务属性等知识点。 一、Java 基本概念 1. Java 源...
牛客刷题---年会抽奖
weixin_53999801的博客
08-04 254
①A抽之后，二个人B恰好抽到了带有A名字的字条，A也刚好抽到了带有B名字的字条。那这样题目的思路就梳理的比较明了了， 相对对立的系统我们可以使用递归的方式来处理。阅读题意我们首先要明白”无人获奖的概率“是怎末算出来的，这也是本题的难点。样本容量很好找，N个人去抽N个不同的字条，抽一个盒子里就少一个，所以。3. 如果抽到的字条上写的就是自己的名字，那么“恭喜你，中奖了！这一事件是一个新的独立的系统，与前面A和B没有关系。②A抽之后，二个人B没有抽到了带有A名字的字条。这种情况下，相当于A后面的N-1个人。..
【牛客刷题--SQL篇】SQL14操作符混合运用（多种写法）&amp；&amp；SQL15查看学校名称中含北京的用户_drop table if exists user_profile；
2301_79098963的博客
05-06 999
INSERT INTO user_profile VALUES(1,2138,‘male’,21,‘北京大学’,‘BeiJing’,3.4);INSERT INTO user_profile VALUES(2,3214,‘male’,null,‘复旦大学’,‘Shanghai’,4.0);
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 2105
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 803
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
数据结构常考基础代码题-数组倒置
最新发布
qq_52291558的博客
10-16 286
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 149
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
【刷题册】2024.10.13 - 2024.10.15
yj20040627的博客
10-16 505
BC153 [NOIP2010]数字统计 NC313 两个数组的交集 AB5 点击消除 BC64牛牛的快递 DP4 最小花费爬楼梯 数组中最小两个字符串的最小距离 BC149 简写单词 dd爱框框 除2！
牛客刷题 jsnode 输入输出
08-25
在牛客网上刷题，使用 JavaScript 和 Node.js 进行输入输出操作是非常常见的。下面是一个简单的示例，演示如何使用 Node.js 读取标准输入并输出结果： ```javascript // 导入内置的 `readline` 模块 const readline...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值