🌟欢迎来到 我的博客 —— 探索技术的无限可能！
🌟博客的简介（文章目录）
【题解】—— 每日一道题目栏
上接：【题解】—— LeetCode一周小结36
9.合并零之间的节点
题目链接：2181. 合并零之间的节点
给你一个链表的头节点 head ，该链表包含由 0 分隔开的一连串整数。链表的 开端 和 末尾 的节点都满足 Node.val == 0 。
对于每两个相邻的 0 ，请你将它们之间的所有节点合并成一个节点，其值是所有已合并节点的值之和。然后将所有 0 移除，修改后的链表不应该含有任何 0 。
返回修改后链表的头节点 head 。
示例 1：
输入：head = [0,3,1,0,4,5,2,0]
输出：[4,11]
解释：
上图表示输入的链表。修改后的链表包含：
- 标记为绿色的节点之和：3 + 1 = 4
- 标记为红色的节点之和：4 + 5 + 2 = 11
示例 2：
输入：head = [0,1,0,3,0,2,2,0]
输出：[1,3,4]
解释：
上图表示输入的链表。修改后的链表包含：
- 标记为绿色的节点之和：1 = 1
- 标记为红色的节点之和：3 = 3
- 标记为黄色的节点之和：2 + 2 = 4
提示：
列表中的节点数目在范围 [3, 2 * 105] 内
0 <= Node.val <= 1000
不 存在连续两个 Node.val == 0 的节点
链表的 开端 和 末尾 节点都满足 Node.val == 0
题解：
方法：模拟
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeNodes(ListNode head) {
ListNode dummy = new ListNode();
int s = 0;
ListNode tail = dummy;
for (ListNode cur = head.next; cur != null; cur = cur.next) {
if (cur.val != 0) {
s += cur.val;
} else {
tail.next = new ListNode(s);
tail = tail.next;
s = 0;
}
}
return dummy.next;
}
}
10.统计上升四元组
题目链接：2552. 统计上升四元组
给你一个长度为 n 下标从 0 开始的整数数组 nums ，它包含 1 到 n 的所有数字，请你返回上升四元组的数目。
如果一个四元组 (i, j, k, l) 满足以下条件，我们称它是上升的：
0 <= i < j < k < l < n 且
nums[i] < nums[k] < nums[j] < nums[l] 。
示例 1：
输入：nums = [1,3,2,4,5]
输出：2
解释：
- 当 i = 0 ，j = 1 ，k = 2 且 l = 3 时，有 nums[i] < nums[k] < nums[j] < nums[l] 。
- 当 i = 0 ，j = 1 ，k = 2 且 l = 4 时，有 nums[i] < nums[k] < nums[j] < nums[l] 。
没有其他的四元组，所以我们返回 2 。
示例 2：
输入：nums = [1,2,3,4]
输出：0
解释：只存在一个四元组 i = 0 ，j = 1 ，k = 2 ，l = 3 ，但是 nums[j] < nums[k] ，所以我们返回 0
。
提示：
4 <= nums.length <= 4000
1 <= nums[i] <= nums.length
nums 中所有数字 互不相同 ，nums 是一个排列。
题解：
方法：枚举
class Solution {
public long countQuadruplets(int[] nums) {
int n = nums.length;
int[][] f = new int[n][n];
int[][] g = new int[n][n];
for (int j = 1; j < n - 2; ++j) {
int cnt = 0;
for (int l = j + 1; l < n; ++l) {
if (nums[l] > nums[j]) {
++cnt;
}
}
for (int k = j + 1; k < n - 1; ++k) {
if (nums[j] > nums[k]) {
f[j][k] = cnt;
} else {
--cnt;
}
}
}
long ans = 0;
for (int k = 2; k < n - 1; ++k) {
int cnt = 0;
for (int i = 0; i < k; ++i) {
if (nums[i] < nums[k]) {
++cnt;
}
}
for (int j = k - 1; j > 0; --j) {
if (nums[j] > nums[k]) {
g[j][k] = cnt;
ans += (long) f[j][k] * g[j][k];
} else {
--cnt;
}
}
}
return ans;
}
}
11.两个线段获得的最多奖品
题目链接：2555. 两个线段获得的最多奖品
在 X轴 上有一些奖品。给你一个整数数组 prizePositions ，它按照 非递减 顺序排列，其中 prizePositions[i] 是第 i 件奖品的位置。数轴上一个位置可能会有多件奖品。再给你一个整数 k 。
你可以同时选择两个端点为整数的线段。每个线段的长度都必须是 k 。你可以获得位置在任一线段上的所有奖品（包括线段的两个端点）。注意，两个线段可能会有相交。
比方说 k = 2 ，你可以选择线段 [1, 3] 和 [2, 4] ，你可以获得满足 1 <= prizePositions[i] <= 3 或者 2 <= prizePositions[i] <= 4 的所有奖品 i 。
请你返回在选择两个最优线段的前提下，可以获得的 最多 奖品数目。
示例 1：
输入：prizePositions = [1,1,2,2,3,3,5], k = 2
输出：7
解释：这个例子中，你可以选择线段 [1, 3] 和 [3, 5] ，获得 7 个奖品。
示例 2：
输入：prizePositions = [1,2,3,4], k = 0
输出：2
解释：这个例子中，一个选择是选择线段 [3, 3] 和 [4, 4] ，获得 2 个奖品。
提示：
1 <= prizePositions.length <= 105
1 <= prizePositions[i] <= 109
0 <= k <= 109
prizePositions 有序非递减。
题解：
方法：动态规划 滑动窗口
class Solution {
public int maximizeWin(int[] prizePositions, int k) {
int n = prizePositions.length;
if (k * 2 + 1 >= prizePositions[n - 1] - prizePositions[0]) {
return n;
}
int ans = 0;
int left = 0;
int[] mx = new int[n + 1];
for (int right = 0; right < n; right++) {
while (prizePositions[right] - prizePositions[left] > k) {
left++;
}
ans = Math.max(ans, mx[left] + right - left + 1);
mx[right + 1] = Math.max(mx[right], right - left + 1);
}
return ans;
}
}
12.求出最多标记下标
题目链接：2576. 求出最多标记下标
给你一个下标从 0 开始的整数数组 nums 。
一开始，所有下标都没有被标记。你可以执行以下操作任意次：
选择两个 互不相同且未标记 的下标 i 和 j ，满足 2 * nums[i] <= nums[j] ，标记下标 i 和 j 。
请你执行上述操作任意次，返回 nums 中最多可以标记的下标数目。
示例 1：
输入：nums = [3,5,2,4]
输出：2
解释：第一次操作中，选择 i = 2 和 j = 1 ，操作可以执行的原因是 2 * nums[2] <= nums[1] ，标记下标 2
和 1 。没有其他更多可执行的操作，所以答案为 2 。
示例 2：
输入：nums = [9,2,5,4]
输出：4
解释：第一次操作中，选择 i = 3 和 j = 0 ，操作可以执行的原因是 2 * nums[3] <= nums[0] ，标记下标 3
和 0 。第二次操作中，选择 i = 1 和 j = 2 ，操作可以执行的原因是 2 * nums[1] <= nums[2] ，标记下标 1 和 2
。没有其他更多可执行的操作，所以答案为 4 。
示例 3：
输入：nums = [7,6,8]
输出：0
解释：没有任何可以执行的操作，所以答案为 0 。
提示：
1 <= nums.length <= 105
1 <= nums[i] <= 109
题解：
方法：****
13.预算内的最多机器人数目
题目链接：2398. 预算内的最多机器人数目
你有 n 个机器人，给你两个下标从 0 开始的整数数组 chargeTimes 和 runningCosts ，两者长度都为 n 。第 i 个机器人充电时间为 chargeTimes[i] 单位时间，花费 runningCosts[i] 单位时间运行。再给你一个整数 budget 。
运行 k 个机器人 总开销 是 max(chargeTimes) + k * sum(runningCosts) ，其中 max(chargeTimes) 是这 k 个机器人中最大充电时间，sum(runningCosts) 是这 k 个机器人的运行时间之和。
请你返回在 不超过 budget 的前提下，你 最多 可以 连续 运行的机器人数目为多少。
示例 1：
输入：chargeTimes = [3,6,1,3,4], runningCosts = [2,1,3,4,5], budget = 25
输出：3
解释：
可以在 budget 以内运行所有单个机器人或者连续运行 2 个机器人。
选择前 3 个机器人，可以得到答案最大值 3 。总开销是 max(3,6,1) + 3 * sum(2,1,3) = 6 + 3 * 6 =
24 ，小于 25 。可以看出无法在 budget 以内连续运行超过 3 个机器人，所以我们返回 3 。
示例 2：
输入：chargeTimes = [11,12,19], runningCosts = [10,8,7], budget = 19
输出：0
解释：即使运行任何一个单个机器人，还是会超出 budget，所以我们返回 0 。
提示：
chargeTimes.length == runningCosts.length == n
1 <= n <= 5 * 104
1 <= chargeTimes[i], runningCosts[i] <= 105
1 <= budget <= 1015
题解：
方法：滑动窗口
class Solution {
public int maximumRobots(int[] chargeTimes, int[] runningCosts, long budget) {
int ans = 0;
int left = 0;
long sum = 0;
Deque<Integer> q = new ArrayDeque<>();
for (int right = 0; right < chargeTimes.length; right++) {
// 1. 入
while (!q.isEmpty() && chargeTimes[right] >= chargeTimes[q.peekLast()]) {
q.pollLast();
}
q.addLast(right);
sum += runningCosts[right];
// 2. 出
while (!q.isEmpty() && chargeTimes[q.peekFirst()] + (right - left + 1) * sum > budget) {
if (q.peekFirst() == left) {
q.pollFirst();
}
sum -= runningCosts[left++];
}
// 3. 更新答案
ans = Math.max(ans, right - left + 1);
}
return ans;
}
}
14.从字符串中移除星号
题目链接：2390. 从字符串中移除星号
给你一个包含若干星号 * 的字符串 s 。
在一步操作中，你可以：
选中 s 中的一个星号。
移除星号 左侧 最近的那个 非星号 字符，并移除该星号自身。
返回移除 所有 星号之后的字符串。
注意：
生成的输入保证总是可以执行题面中描述的操作。
可以证明结果字符串是唯一的。
示例 1：
输入：s = “leet**cod*e”
输出：“lecoe”
解释：从左到右执行移除操作：
- 距离第 1 个星号最近的字符是 “leet**code" 中的 ‘t’ ，s 变为 "leecod*e” 。
- 距离第 2 个星号最近的字符是 “leecode” 中的 ‘e’ ，s 变为 “lecod*e” 。
- 距离第 3 个星号最近的字符是 “lecod*e” 中的 ‘d’ ，s 变为 “lecoe” 。
不存在其他星号，返回 “lecoe” 。
示例 2：
输入：s = “erase*****”
输出：“”
解释：整个字符串都会被移除，所以返回空字符串。
提示：
1 <= s.length <= 105
s 由小写英文字母和星号 * 组成
s 可以执行上述操作
题解：
方法：栈
class Solution {
public String removeStars(String s) {
StringBuilder st = new StringBuilder();
for (char c : s.toCharArray()) {
if (c == '*') {
st.deleteCharAt(st.length() - 1);
} else {
st.append(c);
}
}
return st.toString();
}
}
15.与车相交的点
题目链接：2848. 与车相交的点
给你一个下标从 0 开始的二维整数数组 nums 表示汽车停放在数轴上的坐标。对于任意下标 i，nums[i] = [starti, endi] ，其中 starti 是第 i 辆车的起点，endi 是第 i 辆车的终点。
返回数轴上被车 任意部分 覆盖的整数点的数目。
示例 1：
输入：nums = [[3,6],[1,5],[4,7]]
输出：7
解释：从 1 到 7 的所有点都至少与一辆车相交，因此答案为 7 。
示例 2：
输入：nums = [[1,3],[5,8]]
输出：7
解释：1、2、3、5、6、7、8 共计 7 个点满足至少与一辆车相交，因此答案为 7 。
提示：
1 <= nums.length <= 100
nums[i].length == 2
1 <= starti <= endi <= 100
题解：
方法：前缀和
class Solution {
public int numberOfPoints(List<List<Integer>> nums) {
int maxEnd = 0;
for (List<Integer> p : nums) {
maxEnd = Math.max(maxEnd, p.get(1));
}
int[] diff = new int[maxEnd + 2]; // 注意下面有 end+1
for (List<Integer> interval : nums) {
diff[interval.get(0)]++;
diff[interval.get(1) + 1]--;
}
int ans = 0;
int s = 0;
for (int d : diff) {
s += d;
if (s > 0) {
ans++;
}
}
return ans;
}
}
下接：【题解】—— LeetCode一周小结38
![[机器学习]决策树](https://i-blog.csdnimg.cn/direct/18d1dc8ecae242af836d06f1fa24e3a5.png)
