- 博客(115)
- 收藏
- 关注
RSS订阅原创 Leetcode638:大礼包
Leetcode638:大礼包 题目： 在 LeetCode 商店中， 有 n 件在售的物品。每件物品都有对应的价格。然而，也有一些大礼包，每个大礼包以优惠的价格捆绑销售一组物品。 给你一个整数数组 price 表示物品价格，其中 price[i] 是第 i 件物品的价格。另有一个整数数组 needs 表示购物清单，其中 needs[i] 是需要购买第 i 件物品的数量。 还有一个数组 special 表示大礼包，special[i] 的长度为 n + 1 ，其中 special[i][j] 表示第
2022-05-11 11:43:20
519
原创 Leetcode59:螺旋矩阵II
Leetcode59:螺旋矩阵II 题目： 给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。 思路：模拟 代码如下： class Solution { public int[][] generateMatrix(int n) { int[][] res = new int[n][n]; int startX = 0; int startY = 0
2022-05-11 11:42:19
472
原创 Leetcode209:长度最小的子数组（滑动窗口）
Leetcode209:长度最小的子数组 题目： 给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。 思路：滑动窗口 代码如下： class Solution { public int minSubArrayLen(int target, int[] nums) {
2022-05-11 11:40:59
409
原创 Leetcode977:有序数组的平方(数组快慢指针)
Leetcode977:有序数组的平方 题目： 给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。 思路：数组快慢指针 代码如下： 解法1：使用数组排序函数 class Solution { public int[] sortedSquares(int[] nums) { int n = nums.length; for(int i =0; i < n; i++){
2022-05-10 22:22:31
426
原创 leetcode27：移除元素(数组快慢指针）
leetcode27：移除元素 题目： 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 思路：快慢指针 代码如下： class Solution { public int removeElement(int[] nums, int val) { int
2022-05-10 22:04:36
284
原创 Leetcode968:监控二叉树（贪心算法）
Leetcode968:监控二叉树 题目： 给定一个二叉树，我们在树的节点上安装摄像头。 节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。 计算监控树的所有节点所需的最小摄像头数量。 思路：贪心算法+代码注释 代码如下： class Solution { //0 表示 无覆盖 ;1 表示 摄像头 ;2 表示 有覆盖 int res = 0; public int minCameraCover(TreeNode root) { if
2022-05-10 20:06:41
241
原创 Leetcode738:单调递增的数字(贪心算法)
Leetcode738:单调递增的数字 题目： 当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。 给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。 思路：贪心算法 从后往前遍历，当前一个数大于后一个数时，将当前的数自减1，将后一个数改为9 代码如下： class Solution { public int monotoneIncreasingDigits(int n) { St
2022-05-10 17:50:51
374
原创 Leetcode1155:掷骰子的N种方法
Leetcode1155:掷骰子的N种方法 题目： 这里有 n 个一样的骰子，每个骰子上都有 k 个面，分别标号为 1 到 k 。 给定三个整数 n , k 和 target ，返回可能的方式(从总共 kn 种方式中)滚动骰子的数量，使正面朝上的数字之和等于 target 。 答案可能很大，你需要对 109 + 7 取模 。 思路：分组背包 代码如下： class Solution { int mod = (int)1e9+7; public int numRoll
2022-05-10 09:42:37
363
原创 Leetcode2264:字符串中最大的3个相同的数字
Leetcode2264:字符串中最大的3个相同的数字 题目： 给你一个字符串 num ，表示一个大整数。如果一个整数满足下述所有条件，则认为该整数是一个 优质整数 ： 该整数是 num 的一个长度为 3 的 子字符串 。 该整数由唯一一个数字重复 3 次组成。 以字符串形式返回 最大的优质整数 。如果不存在满足要求的整数，则返回一个空字符串 “” 。 注意： 子字符串 是字符串中的一个连续字符序列。 num 或优质整数中可能存在 前导零 。 代码如下： class Solution {
2022-05-09 20:58:24
290
原创 Leetcode56:合并区间(贪心算法）
Leetcode56:合并区间 题目： 以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。 思路：贪心算法 代码如下： class Solution { public int[][] merge(int[][] intervals) { List<int[]> res = new LinkedLi
2022-05-09 20:03:31
348
原创 leetcode763:划分字母区间(贪心算法）
leetcode763:划分字母区间 题目： 字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。 思路：贪心算法 代码如下： class Solution { public List<Integer> partitionLabels(String s) { List<Integer> res = new LinkedList<Integer>();
2022-05-09 19:07:19
263
原创 Leetcode942:增减字符串匹配（贪心算法）
Leetcode942:增减字符串匹配 题目： 由范围 [0,n] 内所有整数组成的 n + 1 个整数的排列序列可以表示为长度为 n 的字符串 s ，其中: 如果 perm[i] < perm[i + 1] ，那么 s[i] == ‘I’ 如果 perm[i] > perm[i + 1] ，那么 s[i] == ‘D’ 给定一个字符串 s ，重构排列 perm 并返回它。如果有多个有效排列perm，则返回其中 任何一个 。 思路：贪心算法 每当遇到I，则把当前的最小值给遍历的
2022-05-09 15:07:13
487
原创 Leetcode494:目标和（回溯算法）
Leetcode494:目标和 题目： 给你一个整数数组 nums 和一个整数 target 。 向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ： 例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。 返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。 思路：回溯算法 代码如下： class Solution { int
2022-05-09 15:06:10
231
原创 Leetcode442:数组中重复的数据
Leetcode442:数组中重复的数据 题目： 给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数，并以数组形式返回。 你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间的算法解决此问题。 思路： 定义一维数组且初始化所有的数据为1，每当数组的数字位置出现过1次，数组的数字位置的值减1； 当数组的数字位置的值小于0时，说明数组的数字位置出现过两次或以上次数，则将该
2022-05-08 10:00:33
338
原创 Leetcode474:一和零
Leetcode474:一和零 题目： 给你一个二进制字符串数组 strs 和两个整数 m 和 n 。 请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。 如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。 思路：动态规划、背包问题 代码如下： class Solution { public int findMaxForm(String[] strs, int m, int n) { int l
2022-05-08 09:59:24
333
原创 leetcode452：用最少数量的箭引爆气球&&leetcode435：无重叠区间（贪心算法）
两道题不同的问法，但是具有相同的解题思路 leetcode452：用最少数量的箭引爆气球 题目： 有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。 一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart.
2022-05-06 21:57:10
210
原创 leetcode933：最近的请求次数
leetcode933：最近的请求次数 题目： 写一个 RecentCounter 类来计算特定时间范围内最近的请求。 请你实现 RecentCounter 类： RecentCounter() 初始化计数器，请求数为 0 。 int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。 保证 每次对 ping 的调用都使用比之前更大的 t 值。
2022-05-06 20:45:18
128
原创 leetcode134:加油站（贪心算法）
leetcode134:加油站 题目： 在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。 给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。 思路：贪心算法+代码注释 代码如下： class Solution
2022-05-05 16:49:22
874
原创 Leetcode1005:k次取反后最大化的数组和(贪心算法)
Leetcode1005:k次取反后最大化的数组和 题目： 给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组： 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。 重复这个过程恰好 k 次。可以多次选择同一个下标 i 。 以这种方式修改数组后，返回数组 可能的最大和 。 思路：贪心算法 代码如下： class Solution { public int largestSumAfterKNegations(int[] nums, int k)
2022-05-05 11:49:31
382
原创 leetcode45:跳跃游戏II(贪心算法)
leetcode45:跳跃游戏II 题目： 给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标。 思路：贪心算法 代码如下： class Solution { public int jump(int[] nums) { int res = 0; //下一步覆盖最远距离 int nextDistance = 0; /
2022-05-05 11:22:57
1170
原创 Leetcode55:跳跃游戏（贪心算法）
Leetcode55:跳跃游戏 题目： 给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标。 思路：贪心算法+更新每次能够行走路径的覆盖范围 代码如下： class Solution { public boolean canJump(int[] nums) { int coverRange = 0; if(nums.length <= 1)
2022-05-05 10:30:41
688
原创 Leetcode713:乘积小于k的子数组（滑动窗口）
Leetcode713:乘积小于k的子数组 题目： 给你一个整数数组 nums 和一个整数 k ，请你返回子数组内所有元素的乘积严格小于 k 的连续子数组的数目。 思路：滑动窗口 代码如下： class Solution { public int numSubarrayProductLessThanK(int[] nums, int k) { int res = 0; int n = nums.length; //当k为1时，任何子数组的乘积均
2022-05-05 10:09:10
543
原创 Leetcode518:零钱兑换II
Leetcode518:零钱兑换II 题目： 给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。 请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。 假设每一种面额的硬币有无限个。 题目数据保证结果符合 32 位带符号整数。 思路：完全背包+动态规划 代码如下： class Solution { public int change(int amount, int[] coins) {
2022-05-05 10:07:46
385
原创 《JAVA并发编程的艺术》 第四章 复习
第四章 JAVA并发编程基础 线程简介 1.java内部自身引入多线程，使用多线程的原因： 更多的处理器核心 更快的响应时间 更好的编程模型 2.线程可以设置优先级，优先级范围为1-10（默认5） 说明： Java中可以为线程指定优先级，范围是1~10。但并不是所有的操作系统都支持10级的优先级划分。Java只是给操作系统提供一个优先级的参考，具体的线程在操作系统执行先后的顺序还是由操作系统决定。 Java默认的线程优先级是5，线程的优先级在线程调度之前设定，线程的执行顺序由调度程序决定。
2022-05-04 20:19:53
195
原创 leetcode122：买卖股票的最佳时机II(贪心算法）
leetcode122：买卖股票的最佳时机II 题目： 给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。 返回 你能获得的 最大 利润 。 思路：贪心算法 累加所有相邻两天能产生正收益的利润 代码如下： class Solution { public int maxProfit(int[] prices)
2022-05-04 16:53:50
269
原创 leetcode53：最大子序和（贪心算法）
leetcode53：最大子序和 题目： 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组 是数组中的一个连续部分。 思路：贪心算法+代码注释 代码如下： class Solution { public int maxSubArray(int[] nums) { int res = Integer.MIN_VALUE; int count = 0; if ( nu
2022-05-04 16:32:08
352
原创 leetcode376：摆动序列(贪心算法）
leetcode376：摆动序列 题目： 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。 例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。 相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差
2022-05-04 16:00:33
130
原创 leetcode1823：找出游戏的获胜者(约瑟夫问题)
leetcode1823：找出游戏的获胜者 题目： 共有 n 名小伙伴一起做游戏。小伙伴们围成一圈，按 顺时针顺序 从 1 到 n 编号。确切地说，从第 i 名小伙伴顺时针移动一位会到达第 (i+1) 名小伙伴的位置，其中 1 <= i < n ，从第 n 名小伙伴顺时针移动一位会回到第 1 名小伙伴的位置。 游戏遵循如下规则： 从第 1 名小伙伴所在位置 开始 。 沿着顺时针方向数 k 名小伙伴，计数时需要 包含 起始时的那位小伙伴。逐个绕圈进行计数，一些小伙伴可能会被数过不止一次。
2022-05-04 12:13:15
194
原创 leetcode322：零钱兑换
leetcode322：零钱兑换 题目： 给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。 计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。 你可以认为每种硬币的数量是无限的。 思路：动态规划+背包问题； 定义一维数组nums，nums[i] 含义：凑成总金额为i所需的最少硬币个数 代码如下： class Solution { int INF = 0x3f3f3f3f;
2022-05-04 11:03:02
3024
原创 Leetcode832:翻转图像
Leetcode832:翻转图像 题目： 给定一个 n x n 的二进制矩阵 image ，先 水平 翻转图像，然后 反转 图像并返回 结果 。 水平翻转图片就是将图片的每一行都进行翻转，即逆序。 例如，水平翻转 [1,1,0] 的结果是 [0,1,1]。 反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。 例如，反转 [0,1,1] 的结果是 [1,0,0]。 思路：先进行翻转每一行；在进行反转图像 代码如下： class Solution { pub
2022-05-03 18:43:37
192
原创 Leetcode47:全排列II(回溯算法）
Leetcode47:全排列II 知识前提：以leetcode46全排列为基础 题目： 给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。 思路：在全排列（leetcode46题的基础上进行去重） 去重最为关键的代码为：（树层相同元素进行去重） if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) { continue; } 代码如下：
2022-05-03 12:12:13
344
原创 Leetcode46:全排列问题（回溯算法）
Leetcode46:全排列问题 解法一：(推荐） 题目： 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 思路：回溯算法+代码注释 代码如下： class Solution { //定义二维数组存放结果集 List<List<Integer>> res = new ArrayList<>(); //定义一维数组存放临时路径 LinkedList<Integer> p
2022-05-03 11:25:41
542
原创 Leecode491:递增子序列（回溯算法）
Leecode491:递增子序列 题目： 给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。 数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。 思路：回溯算法+代码注释 代码如下： class Solution { //二维数组存放结果集 List<List<Integer>> res = new ArrayList<>(
2022-05-03 10:54:19
219
原创 Leetcode279:完全平方数
Leetcode279:完全平方数 题目： 给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。 完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。 思路：动态规划或背包问题 数组f[i] 表示返回和为i的完全平方数的最少数量 先考虑最坏情况，然后根据平方数（平方数<=n)递增依次进行优化 代码如下： class Solution { public in
2022-05-03 10:16:05
475
原创 《JAVA核心技术卷I（第11版）》第5章和第6章 复习
第五章 继承 1.final关键词 final修饰的类，为最终类，该类不能被继承。如String 类（线程安全） final修饰的方法可以被继承和重载，但不能被重写 final修饰的变量不能被修改，是个常量 2.Object：所有类的超类 equals()： 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。 hashcode()： 等价的两个
2022-05-02 22:38:35
774
原创 Leetcode2:两数相加
###Leetcode2:两数相加 题目： 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 思路：注释可见 代码如下： class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { Lis
2022-05-02 20:18:32
387
原创 Leetcode455:分发饼干(贪心算法)
Leetcode455:分发饼干 题目： 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。 思路：贪心算法 通过最低消耗满足小孩，实现局部最优，从而达到全局最优 对数组g和
2022-05-02 20:15:30
526
原创 Leetcode90:子集II（回溯算法）
Leetcode90:子集II 题目： 给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。 思路：回溯算法（去重：同一树层中使用过的、相同的元素） 代码如下： class Solution { List<List<Integer>> res = new ArrayList<>(); LinkedList path = ne
2022-05-02 16:17:50
244
原创 Leetcode78:子集(回溯算法）
Leetcode78:子集 题目： 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 思路：回溯算法 代码如下： class Solution { //存放二维数组结果集 List<List<Integer>> res = new ArrayList<>(); //一维数组存放临时路径 LinkedList path =
2022-05-02 15:33:36
289
原创 Leetcode93:复原IP地址（回溯算法）
Leetcode93:复原IP地址 题目： 有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。 例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。 给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘
2022-05-02 15:08:15
316
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人