「这是我参与2022首次更文挑战的第19天，活动详情查看：2022首次更文挑战」。
LeetCode习题集 有些题可能直接略过了，整理一下之前刷leetcode
731. 我的日程安排表 II
实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内不会导致三重预订时，则可以存储这个新的日程安排。
MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时间内增加一个日程安排，注意，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end。
当三个日程安排有一些时间上的交叉时（例如三个日程安排都在同一时间内），就会产生三重预订。
每次调用 MyCalendar.book方法时，如果可以将日程安排成功添加到日历中而不会导致三重预订，返回 true。否则，返回 false 并且不要将该日程安排添加到日历中。
请按照以下步骤调用MyCalendar 类: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)
示例：
MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(50, 60); // returns true
MyCalendar.book(10, 40); // returns true
MyCalendar.book(5, 15); // returns false
MyCalendar.book(5, 10); // returns true
MyCalendar.book(25, 55); // returns true
解释：
前两个日程安排可以添加至日历中。 第三个日程安排会导致双重预订，但可以添加至日历中。
第四个日程安排活动（5,15）不能添加至日历中，因为它会导致三重预订。
第五个日程安排（5,10）可以添加至日历中，因为它未使用已经双重预订的时间10。
第六个日程安排（25,55）可以添加至日历中，因为时间 [25,40] 将和第三个日程安排双重预订；
时间 [40,50] 将单独预订，时间 [50,55）将和第二个日程安排双重预订。
提示：
每个测试用例，调用 MyCalendar.book 函数最多不超过 1000次。 调用函数 MyCalendar.book(start, end)时， start 和 end 的取值范围为 [0, 10^9]。
PS:
与上一题类似，创建结构体的时候多声明一个变量看是不是三重预订
class MyCalendarTwo {
class BSTNode{
int start, end;
//这个变量用来看是不是三重的
//开始是false，插入一个就是true，在插入的话如果是true就是三重
boolean overlap;
BSTNode left, right;
public BSTNode(int s, int e) {
this.start = s; this.end = e;
this.overlap = false;
}
}
BSTNode root;
public MyCalendarTwo() {
}
public boolean book(int start, int end) {
if (!insertable(root, start, end)) return false;
root = insert(root, start, end);
return true;
}
private boolean insertable(BSTNode node, int start, int end) {
if (start >= end || node == null)
return true;
if (start >= node.end)
return insertable(node.right, start, end);
if (end <= node.start)
return insertable(node.left, start, end);
if (node.overlap) return false;
if (node.start <= start && end <= node.end)
return true;
return insertable(node.left, start, node.start) &&
insertable(node.right, node.end, end);
}
private BSTNode insert(BSTNode node, int start, int end) {
if (start >= end) return node;
if (node == null) {
return new BSTNode(start, end);
}
if (node.start >= end) {
node.left = insert(node.left, start, end);
return node;
}
if (node.end <= start) {
node.right = insert(node.right, start, end);
return node;
}
int minS = Math.min(start, node.start);
int maxS = Math.max(start, node.start);
int minE = Math.min(end, node.end);
int maxE = Math.max(end, node.end);
node.start = maxS;
node.end = minE;
node.overlap = true;
node.left = insert(node.left, minS, maxS);
node.right = insert(node.right, minE, maxE);
return node;
}
}
732. 我的日程安排表 III
实现一个 MyCalendar 类来存放你的日程安排，你可以一直添加新的日程安排。
MyCalendar 有一个 book(int start, int end)方法。它意味着在start到end时间内增加一个日程安排，注意，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end。
当 K 个日程安排有一些时间上的交叉时（例如K个日程安排都在同一时间内），就会产生 K 次预订。
每次调用 MyCalendar.book方法时，返回一个整数 K ，表示最大的 K 次预订。
请按照以下步骤调用MyCalendar 类: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)
示例 1:
MyCalendarThree();
MyCalendarThree.book(10, 20); // returns 1
MyCalendarThree.book(50, 60); // returns 1
MyCalendarThree.book(10, 40); // returns 2
MyCalendarThree.book(5, 15); // returns 3
MyCalendarThree.book(5, 10); // returns 3
MyCalendarThree.book(25, 55); // returns 3
解释:
前两个日程安排可以预订并且不相交，所以最大的K次预订是1。
第三个日程安排[10,40]与第一个日程安排相交，最高的K次预订为2。
其余的日程安排的最高K次预订仅为3。
请注意，最后一次日程安排可能会导致局部最高K次预订为2，但答案仍然是3，原因是从开始到最后，时间[10,20]，[10,40]和[5,15]仍然会导致3次预订。
说明:
每个测试用例，调用 MyCalendar.book 函数最多不超过 400次。 调用函数 MyCalendar.book(start, end)时， start 和 end 的取值范围为 [0, 10^9]。
PS:
暴力
class MyCalendarThree {
private TreeMap<Integer, Integer> calendar;
public MyCalendarThree() {
calendar = new TreeMap<>();
}
public int book(int start, int end) {
// 添加至日程中
calendar.put(start, calendar.getOrDefault(start, 0) + 1);
calendar.put(end, calendar.getOrDefault(end, 0) - 1);
// 记录最大活跃的日程数
int max = 0;
// 记录活跃的日程数
int active = 0;
for (Integer d : calendar.values()) {
// 以时间线统计日程
active += d;
// 找到活跃事件数量最多的时刻，记录下来。
if (active > max) {
max = active;
}
}
return max;
}
}
PS： 二叉树
class MyCalendarThree {
public static class SegmentTree {
public static class Node {
private int lo;
private int hi;
private int range;
private int maxCover = 0;
private int lazy = 0;
private Node left;
private Node right;
public Node(int lo, int hi) {
this.lo = lo;
this.hi = hi;
this.range = hi - lo;
}
}
Node root = null;
public int addRange(int qLo, int qHi) {
checkRoot(qLo, qHi);
update(root, qLo, qHi, 1);
return root.maxCover;
}
private void update(Node root, int qLo, int qHi, int diff) {
if (root == null) {
return;
}
checkLazy(root);
if (qHi <= root.lo || root.hi <= qLo) {
return;
}
checkChildren(root);
if (qLo <= root.lo && root.hi <= qHi) {
root.maxCover += diff;
if (root.left != null) {
root.left.lazy += diff;
}
if (root.right != null) {
root.right.lazy += diff;
}
return;
}
update(root.left, qLo, qHi, diff);
update(root.right, qLo, qHi, diff);
root.maxCover = Math.max(root.left.maxCover, root.right.maxCover);
}
private void checkChildren(Node root) {
if (root.range <= 1) {
return;
}
if (root.left != null && root.right != null) {
return;
}
int mid = root.lo + (root.hi - root.lo) / 2;
if (root.left == null) {
int r = root.right == null ? mid : root.right.lo;
root.left = new Node(root.lo, r);
}
if (root.right == null) {
root.right = new Node(root.left.hi, root.hi);
}
}
private void checkLazy(Node root) {
if (root.lazy == 0) {
return;
}
root.maxCover += root.lazy;
checkChildren(root);
//propagation
if (root.left != null) {
root.left.lazy += root.lazy;
root.right.lazy += root.lazy;
}
//reset lazy
root.lazy = 0;
}
private void checkRoot(int qLo, int qHi) {
if (root == null) {
root = new Node(qLo, qHi);
return;
}
while (qHi > root.hi) {
Node newR = new Node(root.lo, Math.min(1000000000, root.hi + root.range));
newR.left = root;
newR.maxCover=root.maxCover;
root = newR;
}
while (qLo < root.lo) {
Node newR = new Node(Math.max(0, root.lo - root.range), root.hi);
newR.right = root;
newR.maxCover=root.maxCover;
root = newR;
}
}
}
SegmentTree st = new SegmentTree();
public MyCalendarThree() {
}
public int book(int start, int end) {
return st.addRange(start, end);
}
}
733. 图像渲染
有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。
给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。
为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。
最后返回经过上色渲染后的图像。
示例 1:
输入:
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析:
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。
注意:
image 和 image[0] 的长度在范围 [1, 50] 内。 给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。 image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535]内。
PS:
经典DFS
保存要更改点的原始色素，
然后带着原始色素一起四个方向进行遍历，如果越界，或者原始色素不同，则直接返回，不上色
class Solution {
public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
int tar = image[sr][sc];
if (newColor == tar) {
return image;
}
fill(image, sr, sc, newColor, tar);
return image;
}
private void fill(int[][] image, int sr, int sc, int newColor, int tar) {
if (sr < 0 || sc < 0 || sr >= image.length || sc >= image[0].length || image[sr][sc] != tar) {
return;
}
image[sr][sc] = newColor;
fill(image, sr - 1, sc, newColor, tar);
fill(image, sr, sc - 1, newColor, tar);
fill(image, sr + 1, sc, newColor, tar);
fill(image, sr, sc + 1, newColor, tar);
}
}
735. 行星碰撞
给定一个整数数组 asteroids，表示在同一行的行星。
对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向（正表示向右移动，负表示向左移动）。每一颗行星以相同的速度移动。
找出碰撞后剩下的所有行星。碰撞规则：两个行星相互碰撞，较小的行星会爆炸。如果两颗行星大小相同，则两颗行星都会爆炸。两颗移动方向相同的行星，永远不会发生碰撞。
示例 1:
输入: asteroids = [5, 10, -5] 输出: [5, 10] 解释: 10 和 -5 碰撞后只剩下 10。 5 和 10 永远不会发生碰撞。 示例 2:
输入: asteroids = [8, -8] 输出: [] 解释: 8 和 -8 碰撞后，两者都发生爆炸。 示例 3:
输入: asteroids = [10, 2, -5] 输出: [10] 解释: 2 和 -5 发生碰撞后剩下 -5。10 和 -5 发生碰撞后剩下 10。 示例 4:
输入: asteroids = [-2, -1, 1, 2] 输出: [-2, -1, 1, 2] 解释: -2 和 -1 向左移动，而 1 和 2 向右移动。 由于移动方向相同的行星不会发生碰撞，所以最终没有行星发生碰撞。 说明:
数组 asteroids 的长度不超过 10000。 每一颗行星的大小都是非零整数，范围是 [-1000, 1000] 。
PS：
用栈会慢一点，还是数组快一些，栈运行的是6ms，数组是1ms，既然动动手能提高效率，肯定要提高一下了，
(●ˇ∀ˇ●)
class Solution {
public int[] asteroidCollision(int[] arr) {
// stack
int n = arr.length;
int[] stack = new int[n];
int stackSize = 0;
for (int num : arr) {
if (num > 0) {
stack[stackSize++] = num;
} else {
while (stackSize > 0 && stack[stackSize - 1] > 0 && stack[stackSize - 1] < -num) {
stackSize--;
}
if (stackSize == 0) {
stack[stackSize++] = num;
} else {
int top = stack[stackSize - 1];
if (top < 0) {
stack[stackSize++] = num;
} else if (top == -num) {
stackSize--;
}
}
}
}
return Arrays.copyOf(stack, stackSize);
}
}
736. Lisp 语法解析
给定一个类似 Lisp 语句的表达式 expression，求出其计算结果。
表达式语法如下所示:
表达式可以为整数，let 语法，add 语法，mult 语法，或赋值的变量。表达式的结果总是一个整数。 (整数可以是正整数、负整数、0)
let 语法表示为 (let v1 e1 v2 e2 ... vn en expr), 其中 let语法总是以字符串 "let"来表示，接下来会跟随一个或多个交替变量或表达式，也就是说，第一个变量 v1被分配为表达式 e1 的值，第二个变量 v2 被分配为表达式 e2 的值，以此类推；最终 let 语法的值为 expr表达式的值。
add 语法表示为 (add e1 e2)，其中 add 语法总是以字符串 "add"来表示，该语法总是有两个表达式e1、e2, 该语法的最终结果是 e1 表达式的值与 e2 表达式的值之和。
mult 语法表示为 (mult e1 e2) ，其中 mult 语法总是以字符串"mult"表示， 该语法总是有两个表达式 e1、e2，该语法的最终结果是 e1 表达式的值与 e2 表达式的值之积。
在该题目中，变量的命名以小写字符开始，之后跟随0个或多个小写字符或数字。为了方便，"add"，"let"，"mult"会被定义为"关键字"，不会在表达式的变量命名中出现。
最后，要说一下作用域的概念。计算变量名所对应的表达式时，在计算上下文中，首先检查最内层作用域（按括号计），然后按顺序依次检查外部作用域。我们将保证每一个测试的表达式都是合法的。有关作用域的更多详细信息，请参阅示例。
示例：
输入: (add 1 2)
输出: 3
输入: (mult 3 (add 2 3))
输出: 15
输入: (let x 2 (mult x 5))
输出: 10
输入: (let x 2 (mult x (let x 3 y 4 (add x y))))
输出: 14
解释:
表达式 (add x y), 在获取 x 值时, 我们应当由最内层依次向外计算, 首先遇到了 x=3, 所以此处的 x 值是 3.
输入: (let x 3 x 2 x)
输出: 2
解释: let 语句中的赋值运算按顺序处理即可
输入: (let x 1 y 2 x (add x y) (add x y))
输出: 5
解释:
第一个 (add x y) 计算结果是 3，并且将此值赋给了 x 。
第二个 (add x y) 计算结果就是 3+2 = 5 。
输入: (let x 2 (add (let x 3 (let x 4 x)) x))
输出: 6
解释:
(let x 4 x) 中的 x 的作用域仅在()之内。所以最终做加法操作时，x 的值是 2 。
输入: (let a1 3 b2 (add a1 1) b2)
输出: 4
解释:
变量命名时可以在第一个小写字母后跟随数字.
注意:
我们给定的 expression 表达式都是格式化后的：表达式前后没有多余的空格，表达式的不同部分(关键字、变量、表达式)之间仅使用一个空格分割，并且在相邻括号之间也没有空格。我们给定的表达式均为合法的且最终结果为整数。 我们给定的表达式长度最多为 2000 (表达式也不会为空，因为那不是一个合法的表达式)。 最终的结果和中间的计算结果都将是一个 32 位整数。
PS：
let 是 赋值语句
我也不清楚为什么，刚开始就是没看懂let（留下了菜鸟的眼泪）
class Solution {
public int evaluate(String expression) {
return eval(expression, new HashMap<>());
}
private int eval(String exp, Map<String, Integer> parent) {
if (exp.charAt(0) != '(') {
if (exp.charAt(0) == '-' || Character.isDigit(exp.charAt(0))) {
return Integer.valueOf(exp);
}
return parent.get(exp);
}
Map<String, Integer> map = new HashMap<>();
map.putAll(parent);
List<String> list = parse(exp.substring(exp.charAt(1) == 'm' ? 6 : 5, exp.length() - 1));
//相加的语句
if (exp.startsWith("(a")) {
return eval(list.get(0), map) + eval(list.get(1), map);
//乘的语句
} else if (exp.startsWith("(m")) {
return eval(list.get(0), map) * eval(list.get(1), map);
} else {
//赋值语句
for (int i = 0; i < list.size() - 2; i += 2) {
map.put(list.get(i), eval(list.get(i + 1), map));
}
return eval(list.get(list.size() - 1), map);
}
}
//每一次拆分一个括号
private List<String> parse(String exp) {
List<String> res = new ArrayList<>();
StringBuilder sb = new StringBuilder();
int count = 0;
for (int i = 0; i < exp.length(); i++) {
char c = exp.charAt(i);
if (c == '(') count++;
else if (c == ')') count--;
if (c == ' ' && count == 0) {
res.add(sb.toString());
sb = new StringBuilder();
} else {
sb.append(c);
}
}
res.add(sb.toString());
return res;
}
}
738. 单调递增的数字
给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。
（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）
示例 1:
输入: N = 10 输出: 9 示例 2:
输入: N = 1234 输出: 1234 示例 3:
输入: N = 332 输出: 299 说明: N 是在 [0, 10^9] 范围内的一个整数。
class Solution {
public int monotoneIncreasingDigits(int N) {
int res = 0, tmp = 1000000000, last = 0, except = 0;
while (tmp > 0) {
//一共就只能有10^9，直接一位一位的算
int c = N / tmp;
//如果发现右面的比左面的大，证明是这一位违反了，
//这一位直接-1后面的都变成9，也就是例子：1000-1=999，这样是最大的
if (c < last) {
return except;
}
res += c * tmp;
//res是10的倍数，所以-1后面就都是9了
if (c > last) {
last = c;
except = res - 1;
}
//如果没有的话，减去当前这一位，然后tmp在/10相当于往下降一位
N -= c * tmp;
tmp /= 10;
}
return res;
}
}
739. 每日温度
根据每日 气温 列表，请重新生成一个列表，对应位置的输出是需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置用 0 来代替。
例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。
提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。
PS:
倒叙循环
第一层：从最后一位开始
第二层：从当前位置向后循环，如果循环到大于当前位置值的，把下标差给当前dp数组
class Solution {
public int[] dailyTemperatures(int[] T) {
int len = T.length;
int[] dp = new int[len];
dp[len - 1] = 0;
int j = 0;
for (int i = len - 2; i >= 0; i--){
j = i + 1;
while (j < len){
if (T[i] < T[j]){
dp[i] = j - i;
break;
}else if (dp[j] == 0){
dp[i] = 0;
break;
}else j = j + dp[j];
}
}
return dp;
}
}
740. 删除与获得点数
给定一个整数数组 nums ，你可以对它进行一些操作。
每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除每个等于 nums[i] - 1 或 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
示例 1:
输入: nums = [3, 4, 2] 输出: 6 解释: 删除 4 来获得 4 个点数，因此 3 也被删除。 之后，删除 2 来获得 2 个点数。总共获得 6 个点数。 示例 2:
输入: nums = [2, 2, 3, 3, 3, 4] 输出: 9 解释: 删除 3 来获得 3 个点数，接着要删除两个 2 和 4 。 之后，再次删除 3 获得 3 个点数，再次删除 3 获得 3 个点数。 总共获得 9 个点数。 注意:
nums的长度最大为20000。 每个整数nums[i]的大小都在[1, 10000]范围内。
PS:
其实这个题，看着是挺复杂的，
其实就是打家劫舍
我们把数组内的数，用计数排序法，然后每个数都计算一下数量
打家劫舍，不能取相邻的数，每次取都是拿目标值
初始化数组，第一个位置只能拿第一个，第二个位置可以选择第一个还是拿第二个
剩下的就循环，每个位置可以选择上一个位置拿的值（本次不拿）
或者拿当前位置的值，和上上位置的值（本次拿）
class Solution {
public int deleteAndEarn(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
} else if (nums.length == 1) {
return nums[0];
}
int len = nums.length;
int max = nums[0];
for (int i = 0; i < len; ++i) {
max = Math.max(max, nums[i]);
}
int[] all = new int[max + 1];
for (int item : nums) {
all[item] ++;
}
int[] dp = new int[max + 1];
dp[1] = all[1] * 1;
dp[2] = Math.max(dp[1], all[2] * 2);
for (int i = 2; i <= max; ++i) {
dp[i] = Math.max(dp[i - 1], dp[i - 2] + i * all[i]);
}
return dp[max];
}
}
