415. 字符串相加（高精度计算、大数运算）

https://leetcode.cn/problems/add-strings/description/

模拟即可。

class Solution {public String addStrings(String num1, String num2) {StringBuilder ans = new StringBuilder();for (int i = num1.length() - 1, j = num2.length() - 1, c = 0; i >= 0 || j >= 0 || c != 0; --i, --j) {if (i >= 0) c += num1.charAt(i) - '0';if (j >= 0) c += num2.charAt(j) - '0';ans.append(c % 10);c /= 10;}return ans.reverse().toString();}
}

更多大数计算可见：
【算法基础】1.4 高精度（模拟大数运算：整数加减乘除）
Java【大数类】整理

1851. 包含每个查询的最小区间⭐⭐⭐⭐⭐

https://leetcode.cn/problems/minimum-interval-to-include-each-query/

提示：
1 <= intervals.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
1 <= lefti <= righti <= 10^7
1 <= queries[j] <= 10^7

解法1——按区间长度排序 + 离线询问 + 并查集

https://leetcode.cn/problems/minimum-interval-to-include-each-query/solutions/755131/an-qu-jian-chang-du-pai-xu-chi-xian-bing-6jzs/

换个角度，对每个区间，去回答包含这个区间的询问。

按照区间长度从小到大排序，遍历每个区间，我们可以直接回答在该区间内的尚未被回答的询问，这是因为区间是按长度从小到大排序的，这些未被回答的询问所需要找的最小区间就是当前区间。

由于一个区间内可能存在已经被回答过的询问，所以我们需要跳过这些询问，这可以用并查集来维护，当我们回答一个区间时，将区间所有元素指向其下一个元素，这样当我们用并查集查询到一个回答完毕的区间的左端点时，自然就跳到了区间的右端点的右侧。

class Solution {public int[] minInterval(int[][] intervals, int[] queries) {// 按区间长度从小到大进行排序Arrays.sort(intervals, (a, b) -> a[1] - a[0] - (b[1] - b[0]));int m = queries.length;int[][] qs = new int[m][2];for (int i = 0; i < m; ++i) {qs[i] = new int[]{queries[i], i};}Arrays.sort(qs, (a, b) -> a[0] - b[0]);     // 按查询位置从小到大进行排序// 初始化并查集int[] p = new int[m + 1];Arrays.setAll(p, e -> e);int[] ans = new int[m];Arrays.fill(ans, -1);// 对每个区间，回答所有在 [l, r] 范围内的询问// 由于每次回答询问之后，都将其指向了下一个询问// 所以若 i = find(i) 符合 i < m && qs[i][0] <= r 的条件，则必然是一个在[l, r] 范围内还没有回答过的询问for (int[] interval: intervals) {int l = interval[0], r = interval[1];   // 取出当前区间int len = r - l + 1;int i = bs(qs, l);                      // 找到查询中第一个大于等于左端点的位置// 回答所有询问位置在 [l, r] 范围内还没有被回答过的询问for (i = find(i, p); i < m && qs[i][0] <= r; i = find(i + 1, p)) {ans[qs[i][1]] = len;p[i] = i + 1;}}return ans;}public int bs(int[][] qs, int t) {int l = 0, r = qs.length;while (l < r) {int mid = l + (r - l) / 2;if (qs[mid][0] < t) l = mid + 1;else r = mid;}return l;}public int find(int x, int[] p) {if (p[x] != x) p[x] = find(p[x], p);return p[x];}
}

解法2——离线算法 + 优先队列

https://leetcode.cn/problems/minimum-interval-to-include-each-query/solutions/755628/bao-han-mei-ge-cha-xun-de-zui-xiao-qu-ji-e21j/

874. 模拟行走机器人（哈希表 + 方向数组）

https://leetcode.cn/problems/walking-robot-simulation/description/

用哈希表存储障碍物位置，然后使用方向数组模拟即可。

class Solution {public int robotSim(int[] commands, int[][] obstacles) {int[] dx = new int[]{0, 1, 0, -1}, dy = new int[]{1, 0, -1, 0};int ans = 0, t = 0, x = 0, y = 0;Set<String> s = new HashSet<String>();for (int[] obstacle: obstacles) s.add(obstacle[0] + " " + obstacle[1]);for (int c: commands) {if (c == -2) t = (t + 3) % 4;else if (c == -1) t = (t + 1) % 4;else {for (int d = 1; d <= c; ++d) {if (s.contains((x + dx[t]) + " " + (y + dy[t]))) break;x += dx[t];y += dy[t];}ans = Math.max(ans, x * x + y * y);}}return ans;}
}

918. 环形子数组的最大和⭐⭐⭐⭐⭐（升级版子数组的最大和）

https://leetcode.cn/problems/maximum-sum-circular-subarray/

提示：

n == nums.length
1 <= n <= 3 * 10^4
-3 * 10^4 <= nums[i] <= 3 * 10^4​​​​​​​

分成两种情况计算，取两种情况的最大值

第一种情况就是 普通 子数组的最大和。
第二种情况就是 前缀 + 后缀 的最大和。

class Solution {public int maxSubarraySumCircular(int[] nums) {int n = nums.length, leftSum = nums[0], pre = nums[0], res = nums[0];int[] leftMax = new int[n];leftMax[0] = nums[0];for (int i = 1; i < n; ++i) {pre = Math.max(nums[i], pre + nums[i]);res = Math.max(res, pre);leftSum += nums[i];     // leftSum是前缀和leftMax[i] = Math.max(leftMax[i - 1], leftSum);}int rightSum = 0;           // rightSum是后缀和for (int i = n - 1; i > 0; --i) {rightSum += nums[i];res = Math.max(res, rightSum + leftMax[i - 1]);}return res;}
}

1499. 满足不等式的最大值（单调队列 | 优先队列）

https://leetcode.cn/problems/max-value-of-equation/

解法1——单调队列维护窗口内的最大值

从前往后枚举 j ，使用单调队列维护 yi - xi 的最大值。

class Solution {public int findMaxValueOfEquation(int[][] points, int k) {int n = points.length, ans = Integer.MIN_VALUE;Deque<Integer> dq = new ArrayDeque<Integer>();// 从前向后枚举 x 一定大于之前的 公式变成 yi + yj + xj - xi（这里 i < j）// 所以单调队列里按 yi - xi 从大到小排序for (int j = 0; j < n; ++j) {// 移除 xj - xi < k 的 iwhile (!dq.isEmpty() && points[j][0] - points[dq.peekFirst()][0] > k) dq.pollFirst();// 更新答案if (!dq.isEmpty()) {int i = dq.peekFirst();ans = Math.max(points[j][0] + points[j][1] - points[i][0] + points[i][1], ans);}// 更新单调队列int v = points[j][1] - points[j][0];while (!dq.isEmpty() && v >= points[dq.peekLast()][1] - points[dq.peekLast()][0]) dq.pollLast();dq.offerLast(j);}return ans;}
}

解法2——优先队列/堆

使用优先队列，队列中的元素是 int[] {x - y, x}

class Solution {public int findMaxValueOfEquation(int[][] points, int k) {int n = points.length, ans = Integer.MIN_VALUE;// 堆中元素按 x - y 从小到大排序PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);for (int[] point: points) {int x = point[0], y = point[1];while (!pq.isEmpty() && pq.peek()[1] < x - k) pq.poll();if (!pq.isEmpty()) ans = Math.max(ans, x + y - pq.peek()[0]);pq.offer(new int[]{x - y, x});}return ans;}
}

860. 柠檬水找零（简单无聊模拟题）

https://leetcode.cn/problems/lemonade-change/submissions/

提示：

1 <= bills.length <= 10^5
bills[i] 不是 5 就是 10 或是 20

class Solution {public boolean lemonadeChange(int[] bills) {int[] cnt = new int[21];for (int bill: bills) {cnt[bill]++;if (bill == 10) cnt[5]--;else if (bill == 20) {if (cnt[10] > 0) {cnt[10]--;cnt[5]--;} else cnt[5] -= 3;}if (cnt[5] < 0) return false;}return true;}
}

42. 接雨水（🐂好题）

https://leetcode.cn/problems/trapping-rain-water/description/

解法1——单调栈

class Solution {public int trap(int[] height) {int n = height.length, ans = 0;Deque<Integer> stk = new ArrayDeque();for (int i = 0; i < n; ++i) {// 单调递减的栈while (!stk.isEmpty() && height[i] >= height[stk.peek()]) {int last = stk.pop();if (!stk.isEmpty()) {int second = stk.pop();ans += (Math.min(height[i], height[second]) - height[last]) * (i - second - 1);stk.push(second);}}stk.push(i);}return ans;}
}

解法2——双指针

class Solution {public int trap(int[] height) {int n = height.length, l = 0, r = n - 1, ml = height[l], mr = height[r], ans = 0;while (l <= r) {if (ml < mr) {ans += ml - height[l++];if (l <= r) ml = Math.max(ml, height[l]);} else {ans += mr - height[r--];if (r >= l) mr = Math.max(mr, height[r]);}}return ans;}
}