文章目录
系列文章目录
一、 数组类型解题方法一：二分法
二、数组类型解题方法二：双指针法
三、数组类型解题方法三：滑动窗口
四、数组类型解题方法四：模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法：双指针
十、栈与队列篇之经典题目
十 一、栈与队列篇之 top-K 问题
十 二、二叉树篇之二叉树的前中后序遍历
十 三、二叉树篇之二叉树的层序遍历及相关题目
十 四、二叉树篇之二叉树的属性相关题目
十 五、 二叉树篇之二叉树的修改与构造
十 六、 二叉树篇之二叉搜索树的属性
十 七、二叉树篇之公共祖先问题
十 八、二叉树篇之二叉搜索树的修改与构造
十 九、回溯算法篇之组合问题
二 十、回溯算法篇之分割、子集、全排列问题
二十一、贪心算法篇之入门题目
更新中 … …
前言
刷题路线来自 ：代码随想录
题录
一、区间问题
55. 跳跃游戏
Leetcode 链接
给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标。
题解：
局部最优解：每次取最大跳跃步数（取最大覆盖范围）
整体最优解：最后得到整体最大覆盖范围，看是否能到终点。
class Solution {
public boolean canJump(int[] nums) {
int max = 0;
for (int i = 0; i <= max; i++) {
// 可跳跃的最远位置作为遍历的结束条件
max = Math.max(max, i + nums[i]);
// 如果最远位置大于等于最大下标，return true
if (max >= nums.length - 1) {
return true;
}
}
return false;
}
}
45. 跳跃游戏 II
Leetcode 链接
给你一个非负整数数组 nums ，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。你的目标是使用最少的跳跃次数到达数组的最后一个位置。假设你总是可以到达数组的最后一个位置。
题解：
[2, 3, 1, 1, 4]
第一次：遍历[2, 3, 1] 中 3 覆盖的距离最远
第二次：由上个区间决定的最远距离作为本次遍历区间的右边界 [1, 4], 4出界
class Solution {
public int jump(int[] nums) {
if (nums.length == 1) return 0;
int maxCover = 0; // 当前范围内 可跳远的最大覆盖范围
int count = 0; // 跳跃次数
int tempCover = 0; // 当前最大覆盖范围
for (int i = 0; maxCover < nums.length - 1; i++) {
tempCover = Math.max(tempCover, i + nums[i]);
// 遍历到了上次跳跃的最大范围时，更新下层跳跃的最大范围
if (i == maxCover) {
count++;
maxCover = tempCover;
}
}
return count;
}
}
452. 用最少数量的箭引爆气球
Leetcode 链接
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。
一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。
给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。
题解：
class Solution {
public int findMinArrowShots(int[][] points) {
// 按区间左边界排序
Arrays.sort(points, (p1, p2) -> Integer.compare(p1[0], p2[0]));
// 默认最小右边界
int right = points[0][1];
int res = 1;
for (int i = 1; i < points.length; i++) {
// 左边界小于最小右边界
if (points[i][0] <= right) {
// 有重叠区间的最小右边界
right = Math.min(right, points[i][1]);
} else {
// 否则，新的最小右边界出现
res++;
right = points[i][1];
}
}
return res;
}
}
435. 无重叠区间
Leetcode 链接
题解：
class Solution {
public int eraseOverlapIntervals(int[][] intervals) {
Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
int right = intervals[0][1];
int res = 0;
for (int i = 1; i < intervals.length; i++) {
if (intervals[i][0] < right) {
// 左边界与右边界重合，要删除一个
res++;
// 将重叠的两区间的最小右边界作为新的右边界，相当于删除了右边界大的区间
right = Math.min(right, intervals[i][1]);
} else {
// 不用删除区间，更新新的右边界
right = intervals[i][1];
}
}
return res;
}
}
763. 划分字母区间
Leetcode 链接
题解：
其实还是边界问题，同跳跃游戏Ⅱ，只不过是返回每个区间的长度
class Solution {
public List<Integer> partitionLabels(String s) {
// map 记录每个字母最后一次出现的下标即，可以使用数组
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
map.put(s.charAt(i), i);
}
List<Integer> list = new ArrayList<>();
int right = 0;
int left = 0;
for (int i = 0; i < s.length(); i++) {
// 获得当前字母的最大下标
right = Math.max(right, map.get(s.charAt(i)));
// 一个区间遍历完
if (i == right) {
// 添加长度
list.add(right - left + 1);
// 记录新的区间开始位置
left = right + 1;
}
}
return list;
}
}
56. 合并区间
Leetcode 链接
题解：
class Solution {
public int[][] merge(int[][] intervals) {
// 排序
Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
int left = intervals[0][0];
int right = intervals[0][1];
List<int[]> list = new ArrayList<>();
for (int i = 1; i < intervals.length; i++) {
// 区间重叠，更新最大右边界，否则一个重叠区间已经遍历完，添加到返回值中
if (intervals[i][0] <= right) {
// 最大右边界
right = Math.max(right, intervals[i][1]);
} else {
// 添加到返回列表中，并更新下一个重叠区间的左边界和右边界
list.add(new int[]{left, right});
left = intervals[i][0];
right = intervals[i][1];
}
}
// 最后一个区间还没添加
list.add(new int[]{left, right});
return list.toArray(new int[list.size()][]);
}
}
二、其他问题
53. 最大子数组和
Leetcode 链接
题解：
遍历并计算sum， 如果sum小于0再和后边的数相加只会让新的sum 更小，所以遇到sum 小于0，让sum=0，从新开始下一轮的计算。如果 sum 大于res(最大sum)，就可以更新res，这里不能是大于0，大于0在负数情况下无法得到最大sum。
class Solution {
public int maxSubArray(int[] nums) {
int res = Integer.MIN_VALUE;
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
if (sum > res) {
res = Math.max(res, sum);
}
if (sum < 0) {
sum = 0;
}
}
return res;
}
}
134. 加油站
在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
题解：
cost 数组和 gas 数组相减得到的值表示能剩下的油，让差值相加，如果小于0表示没有油走到下一个加油站，让下一个下标作为其实位置，和重置为0从新开始，同上一题
class Solution {
public int canCompleteCircuit(int[] gas, int[] cost) {
int res = 0;
int sum = 0; // 总和，最后判断无论怎么走是不是都油不够
int curSum = 0; // 记录和大于0的最大子串
for (int i = 0; i < gas.length; i++) {
sum += gas[i] - cost[i];
curSum += gas[i] - cost[i];
// 不行了，没油了
if (curSum < 0) {
// 从新开始
res = i + 1;
curSum = 0;
}
}
// 怎么走都不行返回 -1
if (sum < 0) return -1;
return res;
}
}
310
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
