Leetcode刷题笔记——dp （23）

已于 2024-01-22 04:59:09 修改
阅读量51 收藏
点赞数
文章标签： 算法 java 数据结构
于 2023-07-29 02:25:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77651729/article/details/131929585
版权

413. Arithmetic Slices

class Solution {
    public int numberOfArithmeticSlices(int[] nums) {
       int ans = 0, n = nums.length, a =0;
       for(int i = 2; i < n; i++) {
           if(nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) a += 1;
           else a = 0;
           ans  += a;
       }
       return ans;
    }
}

396. Rotate Function

class Solution {
    public int maxRotateFunction(int[] nums) {
        int sum = 0, max = Integer.MIN_VALUE, F0 = 0, n = nums.length;
        for(int i = 0; i < n; i++) {
            sum += nums[i];
            F0 += i * nums[i];
        }
        int[] dp = new int[n];
        dp[0] = F0;
        max = F0;
        for(int i = 1; i < n; i++) {
            dp[i] = dp[i - 1] + sum - n * nums[n - i];
            max = Math.max(max, dp[i]);
        }
        return max;
    }
}

152. Maximum Product Subarray

class Solution {
    public int maxProduct(int[] nums) {
        int max = Integer.MIN_VALUE, imax = 1, imin = 1;
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] < 0) {
                int temp = imax;
                imax = imin;
                imin = temp;
            }
            imax = Math.max(imax * nums[i],nums[i]);
            imin = Math.min(imin * nums[i], nums[i]);
            max = Math.max(max, imax);
        }
        return max;
    }
}

53. Maximum Subarray

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


91. Decode Ways

class Solution {
    public int numDecodings(String s) {
       if(s == null || s.length() == 0) {
           return 0;
       } 
       int n = s.length();
       int[] dp = new int[n + 1];
       dp[0] = 1;
       dp[1] = s.charAt(0) != '0'? 1 : 0;
       for(int i = 2; i <= n; i++) {
           int first = Integer.valueOf(s.substring(i - 1, i));
           int second = Integer.valueOf(s.substring(i - 2, i));
           if(first >= 1 && first <= 9) dp[i] += dp[i - 1];
           if(second >= 10 && second <= 26) dp[i] += dp[i - 2];
       }
       return dp[n];
    }
}

2645. Minimum Additions to Make Valid String

class Solution {
    public int addMinimum(String word) {
        int pre = 'z', k = 0, n = word.length();
        for(int i = 0; i < n; i++) {
            k += word.charAt(i) <= pre ? 1 : 0;
            pre = word.charAt(i);
        }
        return 3 * k - n;
    }
}

264. Ugly Number II 

class Solution {
    public int nthUglyNumber(int n) {
        int[] dp = new int[n + 1];
        dp[1] = 1;
        int p2 = 1;
        int p3 = 1;
        int p5 = 1;
        for(int i = 2; i <= n; i++) {
            int f1 = 2 * dp[p2];
            int f2 = 3 * dp[p3];
            int f3 = 5 * dp[p5];
            int min = Math.min(f1, Math.min(f2, f3));
            dp[i] = min;
            if(min == f1) p2++;
            if(min == f2) p3++;
            if(min == f3) p5++;
        }
        return dp[n];
    }
}

337. House Robber III

class Solution {
    public int rob(TreeNode root) {
        int[] num = dfs(root);
        return Math.max(num[0], num[1]);
    }
    public int[] dfs(TreeNode root) {
        int res[] = new int[2];
        if(root == null) return res;
        int[] left = dfs(root.left);
        int[] right = dfs(root.right);
        res[0] = left[1] + right[1] + root.val;
        res[1] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        return res;
    }
}

213. House Robber II

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 1) return nums[0];
        if(nums.length == 2) return Math.max(nums[0], nums[1]);
        int firstresult = solve(nums, 0, nums.length - 2);
        int lastresult = solve(nums, 1, nums.length - 1);
        return Math.max(firstresult, lastresult);
    }
    public int solve(int[] nums, int start, int end) {
        if(start == end) return nums[start];
        int[] money = new int[nums.length];
        money[start] = nums[start];
        money[start + 1] = Math.max(nums[start + 1], nums[start]);
        for(int i = start + 2; i <= end; i++) {
            money[i] = Math.max(money[i - 1], money[i - 2] + nums[i]);
        }
        return money[end];
    }
}

198. House Robber

class Solution {
    public int rob(int[] nums) {
        int rob = 0;
        int notrob = 0;
        for(int i = 0; i <nums.length; i++) {
            int currob = notrob + nums[i];
            notrob = Math.max(notrob, rob);
            rob = currob;
        }
        return Math.max(rob, notrob);
    }
}


45. Jump Game II

class Solution {
    public int jump(int[] nums) {
        int ans = 0;
        int end = 0;
        int farthest = 0;
        for(int i = 0; i < nums.length - 1; i++) {
            farthest = Math.max(farthest, i + nums[i]);
            if(farthest >= nums.length - 1) {
                ans++;
                break;
            }
            if(i == end) {
                ans++;
                end = farthest;
            }
        }
        return ans;
    }
}

55. Jump Game 

class Solution {
    public boolean canJump(int[] nums) {
        int reach = 0;
        for(int i = 0; i < nums.length; i++) {
            if(reach < i) return false;
            reach = Math.max(reach, i + nums[i]);
        }
        return true;
    }
}



class Solution {
    public boolean canJump(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        dp[n - 1] = 0;
        for(int i = n - 2; i >= 0; i--) {
            if(nums[i] == 0) {
                dp[i] = Integer.MAX_VALUE;
            }
            if(nums[i] > 0) {
                int min = Integer.MAX_VALUE;
                for(int j = 1; j <= nums[i]; j++) {
                    if(i + j < dp.length) {
                        if(dp[i + j] != Integer.MAX_VALUE) {
                            min = Math.min(min, dp[i + j]);
                        } else {
                            dp[i] = Integer.MAX_VALUE;
                        }
                    } else {
                        dp[i] = 1;
                        break;
                    }
                }
                if(min != Integer.MAX_VALUE) {
                    dp[i] = min + 1;
                }
            }
        }
        return dp[0] != Integer.MAX_VALUE;
    }
}

140. Word Break II 

class Solution {
    public List<String> wordBreak(String s, List<String> wordDict) {
        List<String> ans = new ArrayList();
        helper("", s, wordDict, ans);
        return ans;
    }
    void helper(String cur, String s, List<String> words, List<String> ans) {
        if(s.length() == 0) {
            ans.add(cur.trim());
            return;
        }
        for(String word : words) {
            if(s.indexOf(word) == 0) {
                helper(cur + " " + word, s.substring(word.length()), words, ans);
            }
        }
    }
}

139. Word Break 

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Boolean[] dp = new Boolean[s.length()];
        return helper(0, s, wordDict, dp);
    }
    public boolean helper(int index, String s, List<String>wordDict, Boolean[] dp) {
        int n = s.length();
        if(index == n) return true;
        if(dp[index] != null) return dp[index];
        for(int k = index + 1; k <= n; k++) {
            if(wordDict.contains(s.substring(index, k)) && helper(k, s, wordDict, dp))
            return dp[index] = true;
        }
        return dp[index] = false;
    }
}


97. Interleaving String 

class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        if(s1.length() + s2.length() != s3.length()) return false;
        Boolean[][] memo = new Boolean[s1.length() + 1][s2.length() + 1];
        return helper(s1, s2, s3, 0, 0, memo);
    }
    public boolean helper(String s1, String s2, String s3, int i, int j, Boolean[][] memo) {
        if(i + j == s3.length()) return true;
        if(memo[i][j] != null) return memo[i][j];
        if(i < s1.length() && s3.charAt(i + j) == s1.charAt(i)) {
            boolean flag = helper(s1, s2, s3, i + 1, j, memo);
            memo[i][j] = flag;
            if(flag) return true;
        }
        if(j < s2.length() && s3.charAt(i + j) == s2.charAt(j)) {
            boolean flag = helper(s1, s2, s3, i, j + 1, memo);
            memo[i][j] = flag;
            if(flag) return true;
        }
        memo[i][j] = false;
        return false;
    }
}

95. Unique Binary Search Trees II 

class Solution {
    public List<TreeNode> generateTrees(int n) {
        return solve(1, n);
    }
    public List<TreeNode> solve(int left, int right) {
        List<TreeNode> ans = new ArrayList();
        if(left > right) {
            ans.add(null);
            return ans;
        }
        for(int i = left; i <= right; i++) {
            List<TreeNode> lft = solve(left, i - 1);
            List<TreeNode> ryt = solve(i + 1, right);
            for(TreeNode l : lft) {
                for(TreeNode r : ryt) {
                    ans.add(new TreeNode(i, l, r));
                }
            }
        }
        return ans;
    }
}

72. Edit Distance14  

class Solution {
    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        int[][] dp = new int[m + 1][n + 1];
        for(int i = 1; i <= m; i++) {
            dp[i][0] = i;
        }
        for(int j = 1; j <= n; j++)
        dp[0][j] = j;
        for(int i = 1; i <= m; i++) {
            for(int j = 1; j <= n; j++) {
                if(word1.charAt(i - 1) == word2.charAt(j - 1))
                    dp[i][j] = dp[i - 1][j - 1];
                else
                    dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
            }
        }
        return dp[m][n];
    }
}

5. Longest Palindromic Substring

class Solution {
    public String longestPalindrome(String s) {
        int st = 0, e = 0;
        for(int i = 0; i < s.length(); i++) {
            int odd = pal(s, i, i);
            int even = pal(s, i, i + 1);
            int len = Math.max(odd, even);
            if(len > e - st) {
                st = i - (len - 1) / 2;
                e = i + len / 2;
            }
        }
        return s.substring(st, e + 1);
    }
    public int pal(String s, int ss, int e) {
        while(ss >= 0 && e < s.length() && s.charAt(ss) == s.charAt(e)) {
            ss--;
            e++;
        }
        return e - ss - 1;
    }
}

96. Unique Binary Search Trees 

class Solution {
    public int numTrees(int n) {
        int[] g = new int[n + 1];
        g[0] = g[1] = 1;
        for(int i = 2; i <= n; i++) {
            for(int j = 1; j <= i; j++) {
                g[i] += g[j - 1] * g[i - j];
            }
        }
        return g[n];
    }
}


343. Integer Break 

class Solution {
    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 0;
        dp[2] = 1;
        for(int i = 3; i <= n; i++) 
            for(int j = 1; j <= i; j++)
                dp[i] = Math.max(dp[i], j * Math.max(dp[i - j], i - j));
        return dp[n];
    }
}

62. Unique Paths 

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

63. Unique Paths II

class Solution {
    int[][] g;
    public int uniquePathsWithObstacles(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] ans = new int[m][n];
        ans[0][0] = 1;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(j > 0 && ans[i][j - 1] != -1) ans[i][j] = ans[i][j - 1];
                if(i > 0 && ans[i - 1][j] != -1) ans[i][j] += ans[i - 1][j];
                if(grid[i][j] == 1) ans[i][j] = 0;
            }
        }
        return ans[m - 1][n - 1];
    }
}

2301_77651729
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
Leetcode刷题笔记——多维动态规划篇
qq_42898642的博客
04-04 807
中等题给定一个包含非负整数的m x n网格grid，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
leetcode刷题笔记——最小路径和
zhujihui的博客
09-06 59
两个解法思路类似，但是使用一维动态规划能大幅压缩空间复杂度。
Leetcode刷题笔记——动态规划（背包问题）篇
qq_42898642的博客
03-13 1234
01背包与完全背包简介
Leetcode刷题笔记——动态规划之子序列问题篇
qq_42898642的博客
03-23 1105
动态规划——子序列篇
leetcode刷题笔记——股票交易问题总结
Shallowmm的博客
03-28 984
由于卖出股票后有一天的冷却时间，所以在卖出股票后先转移到sell状态，后一天才可以重新回到s0状态。由于不限制交易次数并且买入和卖出可以是同一天，因此只要第i天的股价高于前一天，我们就选择交易。在进入buy状态后可以直接卖掉股票转移到sell状态也可以选择转移到imm状态重复等待。s0表示待买入阶段，买入第i天的股票后转移到buy状态，也可以选择不购买重复等待。股票购买问题本质上就是一个有限状态机，对于这类问题，画出状态转换图即可解之。如果存在其他状态指向该状态，那么就用其他状态的前一天状态进行更新。
leetcode刷题笔记——贪心
weixin_46934960的博客
04-27 910
11. 盛最多水的容器 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 返回容器可以储存的最大水量。 说明：你不能倾斜容器。 示例 1： 输入：[1,8,6,2,5,4,8,3,7] 输出：49 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。 示例 2：
LeetCode刷题笔记
打瞌睡_的博客
01-28 1141
文章目录1.数据结构1.1字符串、数组、链表1.2队列、栈1.3堆1.4树1.4.1二叉树1.4.2二叉搜索树 4`1.4.3字典树1.4.4树状数组1.4.5线段树1.5图 2`1.6哈希表1.7Ordered Map2.简单算法2.1位运算2.2双指针2.3排序算法2.4二分查找3.复杂算法3.1递归、回溯算法、深度优先搜索（DFS）3.2广度优先搜索（BFS）3.3拓扑排序 4`3.4贪心算法3.5分治算法3.6滑动窗口算法3.7极小化极大 7`3.8并查集3.9动态规划4.其他4.1Random 6
Leetcode刷题笔记——动态规划
weixin_46934960的博客
02-28 1064
动态规划的⼀般流程就是三步：暴⼒的递归解法 -> 带备忘录的递归解法 -> 迭代的动态规划解法。 就思考流程来说，就分为⼀下⼏步：找到状态和选择 -> 明确 dp 数组/函数的定义 -> 寻找状态之间的关系。 509. Fibonacci Number The Fibonacci numbers, commonly denoted F(n) form a sequence, called the Fibonacci sequence, such that each number is
LeetCode刷题笔记——通配符匹配
喜欢散步的程序员——一支铅笔
07-31 159
LeetCode刷题笔记——通配符匹配 题目描述 给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '*' 的通配符匹配。 '?' 可以匹配任何单个字符。 '*' 可以匹配任意字符串（包括空字符串）。 两个字符串完全匹配才算匹配成功。 说明: s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。 示例 1: 输入: s = "aa" p = "a" 输出: false 解释: "a" 无法匹配 "aa" 整个字符串
谷歌高畅Leetcode刷题笔记.pdf
08-04
谷歌高畅leetcode刷题笔记
LeetCode刷题笔记——63. 不同路径 II
12-21
【LeetCode刷题笔记——63. 不同路径 II】 一、题目描述： 在LeetCode的第63题中，我们被要求计算一个有障碍物的网格中从左上角到右下角的不同路径数量。网格由一个二维整数数组`obstacleGrid`表示，其中1代表障碍...
排序算法(4)之快速排序(1)
wer24_25的博客
07-17 1115
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 212
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
最新发布
Atticus的博客
07-19 246
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
排序思想-快排
m0_58257626的博客
07-17 324
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
Java版LeetCode刷题笔记：51-100题解析
“LeetCode 刷题笔记 with Java 51-100（暗黑版）.pdf 是一本关于使用Java解决LeetCode算法题目的详细笔记，由沉默王二创作。该笔记涵盖51至100号题目，包含题解预览链接、LeetCode官方题目链接以及GitHub项目地址。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值