算法练习（11）：牛客在线编程07 动态规划

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量310 收藏
点赞数 1
文章标签： 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42774617/article/details/133690119
版权 
package jz.bm;

import javax.crypto.MacSpi;
import java.util.ArrayList;
import java.util.Arrays;

public class bm7 {
    /**
     * BM62 斐波那契数列
     */
    public int Fibonacci(int n) {
        if (n <= 2) {
            return 1;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 1;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

    /**
     * BM63 跳台阶
     */
    public int jumpFloor (int number) {
        int[] dp = new int[number + 1];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= number; i++) {
            dp[i] = dp[i - 2] + dp[i - 1];
        }
        return dp[number];
    }

    /**
     * BM64 最小花费爬楼梯
     */
    public int minCostClimbingStairs (int[] cost) {
        int[] dp = new int[cost.length + 1];
//        dp[1] = 0; //只有一层已经在顶楼了
//        dp[2] = 0; //两层的话选择从2楼开始
        for (int i = 2; i <= cost.length; i++) {
            dp[i] = Math.min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1]);
        }
        return dp[cost.length];
    }

    /**
     * BM65 最长公共子序列(二)
     */
    public String LCS (String s1, String s2) {
        if (s1 == null || s1.equals("") || s2 == null || s2.equals("")) {
            return "";
        }
        int m = s1.length(), n = s2.length();
        String[][] dp = new String[m + 1][n + 1]; //dp[i][j]表示从左到右，当处理到s1的第i个元素和s2的第j个元素时的公共子序列
        for (int i = 0; i <= m; i++) {
            dp[i][0] = "";
        }
        for (int i = 0; i <= n; i++) {
            dp[0][i] = "";
        }
        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] + 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];
                }
            }
        }
        return dp[m][n].equals("") ? "-1" : dp[m][n];
    }

    /**
     * BM66 最长公共子串
     */
    public String LCS66 (String str1, String str2) {
        if (str1 == null || str1.equals("") || str2 == null || str2.equals("")) {
            return "";
        }
        int max = 0; //每段子串都是断开的，记录最长的那一个
        int maxIndex = 0;
        int m = str1.length(), n = str2.length();
        int[][] dp = new int[m + 1][n + 1]; //dp[i][j]表示从左到右，当处理到s1的第i个元素和s2的第j个元素时的公共字串长度
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    if (dp[i][j] > max) {
                        max = dp[i][j];
                        maxIndex = i;
                    }
                } else {
                    dp[i][j] = 0; //无法构成字串
                }
            }
        }
        return str1.substring(maxIndex - max, maxIndex);
    }

    /**
     * BM67 不同路径的数目(一)
     */
    public int uniquePaths (int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                //只有一行或一列时，只有一张方法
                if (i == 1) {
                    dp[i][j] = 1;
                    continue;
                }
                if (j == 1) {
                    dp[i][j] = 1;
                    continue;
                }
                //只能来自于上或者右
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m][n];
    }

    /**
     * BM68 矩阵的最小路径和
     */
    public int minPathSum (int[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        int[][] dp = new int[row][col];
        //初值
        dp[0][0] = matrix[0][0];
        for (int i = 1; i < row; i++) {
            dp[i][0] = dp[i - 1][0] + matrix[i][0];
        }
        for (int i = 1; i < col; i++) {
            dp[0][i] = dp[0][i - 1] + matrix[0][i];
        }
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                //选择值最小的路径
                dp[i][j] = Math.min(dp[i - 1][j] + matrix[i][j], dp[i][j] + matrix[i][j]);
            }
        }
        return dp[row - 1][col - 1];
    }

    /**
     * BM69 把数字翻译成字符串
     */
    public int solve (String nums) {
        if (nums == null | "".equals(nums) || nums.startsWith("0")) {
            return 0;
        }
        int n = nums.length();
//        for (int i = 1; i < n; i++) {
//            if (nums.charAt(i) == '0' && !(nums.charAt(i - 1) == '1' || nums.charAt(i - 1) == '2')) {
//                return 0;
//            }
//        }
        int[] dp = new int[n + 1];
//        Arrays.fill(dp, 1);
        dp[0] = 1;  //默认一个才行
        dp[1] = nums.charAt(0) == '0' ? 0 : 1;
        for (int i = 2; i <= n; i++) {
            //无法独立编码也无法组合编码 00 或者 30 ，40 ...
            if(nums.charAt(i-1) == '0' && (nums.charAt(i-2) == '0' || nums.charAt(i-2) > '2')){
                return 0;
                //只能组合编码
            }else if(nums.charAt(i-1)=='0'){ //10,20
                dp[i] = dp[i-2];
                //只能独立编码
            }else if(nums.charAt(i-2)=='0' || nums.charAt(i-2)>'2' || nums.charAt(i-2)=='2'&& nums.charAt(i-1)>'6' ){ //0x,超过27
                dp[i] = dp[i-1];
                //两种编码方式都可以
            }else{
                dp[i] = dp[i-1]+dp[i-2];
            }
//            int num = (nums.charAt(i - 2) - '0') * 10 + nums.charAt(i - 1) - '0';
//            if ((num >= 11 && num <= 19) || (num >= 21 && num <= 26)) { //可以组合又可以单独译码
//                dp[i] = dp[i - 1] + dp[i - 2];
//            } else { //只能单独破译或者是10，20
//                dp[i] = dp[i - 1];
//            }
        }
        return dp[n];
    }

    /**
     * BM70 兑换零钱(一)
     */
    public int minMoney (int[] arr, int aim) {
        int[] dp = new int[aim + 1];
        //初值，都设为最大值，假设货币值1元，则最大数为aim，因此可以设置为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] >= 0) { //当前面值可用
                    dp[i] = Math.min(dp[i], dp[i - arr[j]] + 1);
                }
            }
        }
        return dp[aim] > aim ? -1 : dp[aim];
    }
    /**
     * BM71 最长上升子序列(一)
     */
    public int LIS (int[] arr) {
        int m = arr.length;
        if (m == 0) {
            return 0;
        }
        int[] dp = new int[m]; //以i为结尾的最长子序列
        //初值都设置1，每个数字都是一个序列
        Arrays.fill(dp, 1);
        int res = 1;
        for (int i = 1; i < m; i++) {
            //遍历之前的所有数字，找到子序列
            for (int j = 0; j < i; j++) {
                //小于结尾数字，序列长度加1
                if (arr[i] > arr[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            res = Math.max(dp[i], res);
        }
        return res;
    }

    /**
     * BM72 连续子数组的最大和
     */
    public int FindGreatestSumOfSubArray (int[] array) {
        int n = array.length;
        int[] dp = new int[n + 1];
        dp[0] = 0;
        int max = array[0];
        for (int i = 1; i <= n; i++) {
            dp[i] = Math.max(dp[i - 1] + array[i - 1], array[i - 1]);
            max = Math.max(max, dp[i]);
        }
        return max;
    }

    /**
     * BM73 最长回文子串
     */
    public int getLongestPalindrome (String A) {
        int maxlen = 1;
        for(int i = 0; i < A.length() - 1; i++)
            maxlen = Math.max(maxlen, Math.max(getPalindrome(A, i, i), getPalindrome(A, i, i + 1)));
        return maxlen;
    }
    public int getPalindrome(String A, int left, int right) {
        while (left >= 0 && right < A.length() && A.charAt(left) == A.charAt(right)) {
            left--;
            right++;
        }
        //注意：长度要减1
        return right - left - 1;
    }

    /**
     * BM74 数字字符串转化成IP地址
     */
    //递归回溯
    public ArrayList<String> restoreIpAddresses (String s) {
        ArrayList<String> res = new ArrayList<>();
        dfs(s, 0, res, new ArrayList<String>());
        return res;
    }
    private void dfs(String s, int begin, ArrayList<String> res, ArrayList<String> cur) {
        //找到4段IP，并且字符串遍历完毕
        System.out.println(cur.size());
        if (cur.size() == 4 && begin == s.length()) {
            res.add(cur.get(0) + "." + cur.get(1) + "." + cur.get(2) + "." + cur.get(3));
            return;
        }
        //最多需要3 * （4 - cur.size())数字,最少需要（4 - cur.size()数字
        if ((s.length() - begin > 3 * (4 - cur.size())) || (s.length() - begin < (4 - cur.size()))) {
            return;
        }
        //寻找1到3位数字，作为当前的ip段
        for (int i = begin; i < begin + 3 && i < s.length(); i++) {
            String s1 = s.substring(begin, i + 1);
            int num = Integer.parseInt(s1);
            //小于255且不能有前导0
            if (num >= 0 && num <= 255 && (s1.length() == 1 || s1.charAt(0) != '0')) {
                cur.add(s1);
                dfs(s,i + 1, res, cur);
                cur.remove(cur.size() - 1);
            }
        }
    }

    /**
     * BM75 编辑距离(一)
     */
    public int editDistance (String str1, String str2) {
        int m = str1.length(), n = str2.length();
        int[][] dp = new int[m + 1][n + 1];//以i，j为结尾的字符串str1和str2，最少操作数
        //m为0时，str1变成str2最少操作数是str1插入字符
        for (int i = 1; i <= n; i++) {
            dp[0][i] = dp[0][i - 1] + 1;
        }
        //n为0时，str1变成str2最少操作数是str1删除字符
        for (int i = 1; i <= m; i++) {
            dp[i][0] = dp[i - 1][0] + 1;
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                //不需要额外操作
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    //插入、删除、修改都可以
                    dp[i][j] = Math.min(dp[i - 1][j], Math.min(dp[i][j - 1], dp[i - 1][j - 1])) + 1;
                }
            }
        }
        return dp[m][n];
    }

    /**
     * BM78 打家劫舍(一)
     */
    public int rob (int[] nums) {
        int n = nums.length;
        int[] dp = new int[n + 1];
        dp[1] = nums[0];
        for (int i = 2; i <= n; i++) {
            //偷这家，不偷这家
            dp[i] = Math.max(nums[i - 1] + dp[i - 2], dp[i - 1]);
        }
        return dp[n];
    }

    /**
     * BM79 打家劫舍(二)
     */
    public int rob2 (int[] nums) {
        int n = nums.length;
        int[] dp = new int[n + 1];
        //必须要分情况了
        //偷第一家,最后一家不可以偷
        dp[1] = nums[0];
        for (int i = 2; i < n; i++) {
            //偷这家，不偷这家
            dp[i] = Math.max(nums[i - 1] + dp[i - 2], dp[i - 1]);
        }
        int res = dp[n - 1];
        //不偷第一家
        Arrays.fill(dp, 0);
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            //偷这家，不偷这家
            dp[i] = Math.max(nums[i - 1] + dp[i - 2], dp[i - 1]);
        }
        return Math.max(res, dp[n]);
    }

    /**
     * BM80 买卖股票的最好时机(一)
     */
    public int maxProfit (int[] prices) {
        int n = prices.length;
        if (n == 0) return 0;
        int res = 0;
        int min = prices[0];
        for (int i = 1; i < n; i++) {
            res = Math.max(prices[i] - min, res);
            min = Math.min(min, prices[i]);
        }
        return res;
    }

    /**
     * BM81 买卖股票的最好时机(二)
     */
    public int maxProfit1 (int[] prices) {
        int n = prices.length;
        if (n <= 1) return 0;
        int res = 0;
        for (int i = 1; i < n; i++) {
            if (prices[i] - prices[i - 1] > 0) {
                res += prices[i] - prices[i - 1];
            }
        }
        return res;
    }

    /**
     *
     */
}
青铜爱码士
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
牛客的代码leetcode代码区别-niuke:牛客编程
06-30
在牛客上，开发者不仅可以练习算法，还能进行全真模拟面试，提升求职竞争力。此外，牛客网的题目类型可能更加贴近国内企业的实际项目需求，对于准备国内IT公司面试的开发者来说，这是一个很好的资源。 "niuke-...
练习：leetcode牛客练习
02-13
总结来说，"练习：leetcode牛客练习"是一个关于使用C++在LeetCode和牛客网上进行算法训练的主题，目的是提升编程技能和算法理解，同时也涉及到如何通过阅读和分析他人的代码来学习和成长。通过这样的练习，程序员...
算法练习（10）：牛客在线编程10 贪心算法
weixin_42774617的博客
08-30 670
【代码】算法练习（10）：牛客在线编程10 贪心算法。
算法练习（5）：牛客在线编程01 链表
weixin_42774617的博客
08-08 258
【代码】算法练习（5）：牛客在线编程01 链表。
算法练习（1）：牛客在线编程02 二分法
weixin_42774617的博客
07-22 89
【代码】算法练习（1）：牛客在线编程02 二分法。
算法练习（4）：牛客在线编程05 哈希
weixin_42774617的博客
08-01 377
【代码】算法练习（4）：牛客在线编程05 哈希。
算法练习（2）：牛客在线编程03 二叉树
weixin_42774617的博客
07-25 390
【代码】算法练习（2）：牛客在线编程03 二叉树。
算法练习（8）：牛客在线编程08 字符串
weixin_42774617的博客
08-20 428
【代码】算法练习（8）：牛客在线编程08 字符串。
算法练习（9）：牛客在线编程09 双指针
weixin_42774617的博客
08-23 200
【代码】算法练习（9）：牛客在线编程09 双指针。
算法练习（6）：牛客在线编程06 递归/回溯
weixin_42774617的博客
08-12 304
【代码】算法练习（6）：牛客在线编程06 递归/回溯。
Go ＞ 牛客OJ在线编程常见输入输出练习场
qq_33067925的博客
04-14 349
【代码】Go ＞ 牛客OJ在线编程常见输入输出练习场。
牛客的代码leetcode代码区别-Niuke:牛客网上的练习
06-30
而牛客网是中国本土的在线编程练习平台，除了算法题目外，还提供了更多针对国内企业面试的实战模拟题，比如笔试题、面试题等。牛客网的题目类型更加多元化，不仅包含算法，还有数据库设计、操作系统、网络等方面的...
牛客的代码leetcode代码区别-niuke:牛客网上的练习题
06-30
牛客网是一个专注于程序员培训、技术交流和求职服务的平台，其提供的在线编程练习题目覆盖了各种编程语言和算法领域。牛客网的代码练习通常会根据实际企业面试需求设计，因此更注重实战性和应用性。它的题目往往与...
牛客的代码leetcode代码区别-niuke:牛客
06-30
牛客网是中国一个知名的在线编程训练平台，而LeetCode是国际上广受欢迎的算法练习网站。两者都提供了大量的编程题目供用户练习，提升编程和算法能力。但是，它们的平台特性和提交代码的要求可能存在一些不同之处。 ...
P1145 约瑟夫
zty20120913的博客
08-06 406
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 924
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 208
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 557
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
牛客面试算法TOP101：JAVA与C++解析
此资源可能包含从基础到进阶的各种算法问题，例如排序、搜索、图论、动态规划等，对提升编程技能和解决实际问题能力非常有帮助。" 在这份牛客面试算法top101中，你将接触到各种类型的算法问题，这些题目通常会分为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值