目录
数组
1. LCR 121. 寻找目标值 - 二维数组
2. LCR 120. 寻找文件副本
3. LCR 128. 库存管理 I
4. LCR 131. 砍竹子 I
5. LCR 132. 砍竹子 II
6. LCR 135. 报数
7. LCR 139. 训练计划 I
8. LCR 158. 库存管理 II
9. LCR 159. 库存管理 III
10. LCR 160. 数据流中的中位数
11. LCR 164. 破解闯关密码
12. LCR 168. 丑数
13. LCR 170. 交易逆序对的总数
14. LCR 172. 统计目标成绩的出现次数
15. LCR 173. 点名
16. LCR 179. 查找总价格为目标值的两个商品
17. LCR 180. 文件组合
18. LCR 183. 望远镜中最高的海拔
19. LCR 186. 文物朝代判断
20. LCR 189. 设计机械累加器
21. LCR 191. 按规则计算统计结果
字符串
22. LCR 122. 路径加密
23. LCR 138. 有效数字
24. LCR 157. 套餐内商品的排列顺序
25. LCR 167. 招式拆解 I
26. LCR 169. 招式拆解 II
27. LCR 181. 字符串中的单词反转
28. LCR 182. 动态口令
29. LCR 192. 把字符串转换成整数 (atoi)
链表
30. LCR 123. 图书整理 I
31. LCR 136. 删除链表的节点
32. LCR 140. 训练计划 II
33. LCR 141. 训练计划 III
34. LCR 142. 训练计划 IV
35. LCR 171. 训练计划 V
36. LCR 154. 复杂链表的复制
栈和队列
37. LCR 147. 最小栈
38. LCR 125. 图书整理 II
39. LCR 184. 设计自助结算系统
40. LCR 148. 验证图书取出顺序
树
41. LCR 124. 推理二叉树
42. LCR 143. 子结构判断
43. LCR 144. 翻转二叉树
44. LCR 145. 判断对称二叉树
45. LCR 149. 彩灯装饰记录 I
46. LCR 150. 彩灯装饰记录 II
47. LCR 151. 彩灯装饰记录 III
48. LCR 152. 验证二叉搜索树的后序遍历序列
49. LCR 153. 二叉树中和为目标值的路径
50. LCR 155. 将二叉搜索树转化为排序的双向链表
51. LCR 156. 序列化与反序列化二叉树
52. LCR 174. 寻找二叉搜索树中的目标节点
53. LCR 175. 计算二叉树的深度
54. LCR 176. 判断是否为平衡二叉树
55. LCR 193. 二叉搜索树的最近公共祖先
56. LCR 194. 二叉树的最近公共祖先
位运算
57. LCR 133. 位 1 的个数
58. LCR 134. Pow(x, n)
59. LCR 177. 撞色搭配
60. LCR 178. 训练计划 VI
61. LCR 190. 加密运算
动态规划
62. LCR 126. 斐波那契数
63. LCR 127. 跳跃训练
64. LCR 137. 模糊搜索验证
65. LCR 161. 连续天数的最高销售额
66. LCR 165. 解密数字
67. LCR 166. 珠宝的最高价值
68. LCR 185. 统计结果概率
69. LCR 187. 破冰游戏
图
70. LCR 129. 字母迷宫
71. LCR 130. 衣橱整理编辑
72. LCR 146. 螺旋遍历二维数组
贪心算法
73. LCR 188. 买卖芯片的最佳时机
找规律
74. LCR 162. 数字 1 的个数
75. LCR 163. 找到第 k 位数字
数组
1. LCR 121. 寻找目标值 - 二维数组
就是根据矩阵特性，来查找矩阵值，每行从左到右是递增的，每一列从上到下是递增的。
我们可以从数组的右上角 arr[i][j] 开始，如果 target 大于arr[i][j]，那就 i++ 往后走，如果比它小，那就 j-- 往前走，如果相等返回 true，数组越界了也没找到该值就返回 false。
代码实现：
class Solution {
public boolean findTargetIn2DPlants(int[][] plants, int target) {
// 注意数组没有值的情况
if (plants.length == 0) return false;
// 找到右上角的值
int i = 0;
int j = plants[0].length - 1;
while (i >= 0 && i < plants.length && j >= 0 && j < plants[0].length) {
if (plants[i][j] > target) {
j--;
} else if (plants[i][j] < target) {
i++;
} else {
return true;
}
}
return false;
}
}
2. LCR 120. 寻找文件副本
寻找重复出现数字，直接两层遍历暴力破解即可。
或者直接调用库函数给数组排下序，然后再相邻两两比较，相同就返回。
或者用 set 来做，遍历数组，如果元素在 set 中存在，则返回元素，如果不存在，就把元素添加进 set 里。
代码实现：
class Solution {
public int findRepeatDocument(int[] documents) {
for (int i = 0; i < documents.length - 1; i++) {
for (int j = i + 1; j < documents.length; j++) {
if (documents[i] == documents[j]) {
return documents[i];
}
}
}
return -1;
}
}
class Solution {
public int findRepeatDocument(int[] documents) {
Arrays.sort(documents);
for (int i = 0; i < documents.length - 1; i++) {
if (documents[i] == documents[i + 1]) {
return documents[i];
}
}
return -1;
}
}
class Solution {
public int findRepeatDocument(int[] documents) {
Set<Integer> set = new HashSet<>();
for (int i = 0; i < documents.length; i++) {
int x = documents[i];
if (set.contains(x)) {
return x;
} else {
set.add(x);
}
}
return -1;
}
}
3. LCR 128. 库存管理 I
这个简单，直接遍历数组找最小元素即可。
也可以用二分查找，因为是部分区间是升序的，就可以利用二分查找来完成。
以 s[right] 为参照物， 用中间值 s[mid] 与 s[right] 比较，如果 s[mid] > s[right] ，如例 1 ，则说明最小元素在 mid + 1, right 区间，如果小于，则说明最小元素在 left, mid 区间，如果相等，就无法以判断 right 来判断最小元素在哪里，所以 right-- 往前找另一个参照物。最后 left 与 right 重合时就是最小值的下标。
代码实现：
class Solution {
public int stockManagement(int[] stock) {
int min = Integer.MAX_VALUE;
for (int i = 0; i < stock.length; i++) {
if (stock[i] < min) {
min = stock[i];
}
}
return min;
}
}
// 二分查找
class Solution {
public int stockManagement(int[] stock) {
int left = 0;
int right = stock.length - 1;
while (left < right) {
int mid = (left + right) / 2;
if (stock[mid] > stock[right]) {
left = mid + 1;
} else if (stock[mid] == stock[right]) {
right--;
} else {
right = mid;
}
}
return stock[right];
}
}
4. LCR 131. 砍竹子 I
可以用动态规划来做，dp[i] 就是长度为 i 的竹子拆分两段或以上的最大乘积
i 拆分分两种情况，第一，只拆分成 2 段，j 和 i - j。 乘积就是 j * (i - j)
第二，拆分成两段以上，j ， i - j 还继续拆分，乘积就是 j * dp[i - j]
所以 dp[i] 就是上面两种情况的结果集合中最大值。
初始化：因为 i = 0 和 i = 1 时不能拆分，所以 dp[0] = dp[1] = 0。
最后返回 dp[bl] 即可。
代码实现：
class Solution {
public int cuttingBamboo(int bamboo_len) {
// dp[i] 是长度为 i 的竹子拆分为两段或以上的最大乘积
int[] dp = new int[bamboo_len + 1];
// 初始化 dp[0] = dp[1] = 0
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= bamboo_len; i++) {
// 分两种情况，一种是竹子 i 只拆分成两个数字 3 = 2 + 1
// 分别是 j 和 i - j，另一种是 j，和 i - j 继续拆分成更细的 3 = 1 + 1 + 1
// 所以需要 j 从 i - 1 开始遍历，j 》= 1，然后求以上结果集合中的最大的那一个
for (int j = i - 1; j >= 1; j--) {
int max = Math.max(j * (i - j), j * dp[i - j]);
dp[i] = Math.max(dp[i], max);
}
}
return dp[bamboo_len];
}
}
5. LCR 132. 砍竹子 II
因为范围变大了，所以就不能用动态规划了。
看题解大佬的思路是将绳子长度尽可能分为多个 3，这样乘积才最大。
所以当 n < 4 的时候，返回 n - 1，当 n 等于 4 的时候，返回 4，当 n > 4 的时候，就要切割成 3 的小端，只要 n > 4，就进行切割，然后将切割出来的 3 累乘，然后取模。
代码实现：
class Solution {
public int cuttingBamboo(int n) {
if (n < 4) {
return n - 1;
} else if (n == 4) {
return n;
} else {
long ans = 1;
while (n > 4) {
ans *= 3;
ans %= 1000000007;
n -= 3;
}
return (int) (ans * n % 1000000007);
}
}
}
6. LCR 135. 报数
就是算出一共有几个数字，然后数组赋值即可。
第二种方法就是全排列，参考大佬的解答，假如数字特别大，就无法用整型来存储数据了，那此时就可以用字符串来存储数据，要生成从 1 到 10^n - 1 的数，我们可以看作是数字 0~9 的排列问题，要循环生成 n 位数，首先是生成第一位数字，第一位一定是 1 ~ 9，然后再递归生成剩下的数字，从 0 ~ 9 中取值，
代码实现：
class Solution {
public int[] countNumbers(int cnt) {
int len = (int) Math.pow(10, cnt);
int[] arr = new int[len - 1];
for (int i = 0; i < arr.length; i++) {
arr[i] = i + 1;
}
return arr;
}
}
// 全排列
class Solution {
int count = 0;
int ret[];
public int[] countNumbers(int cnt) {
int len = (int) Math.pow(10, cnt) - 1;
ret = new int[len];
// i 表示要生成 i 位数
for (int i = 1; i <= cnt; i++) {
// 首先生成第一位
for (char first = '1'; first <= '9'; first++) {
// 创建个字符数组存储生成的数字
char[] num = new char[i];
num[0] = first;
// 然后递归生成剩下的数字
dfs(1, num, i);
}
}
return ret;
}
// digit 表示要生成 digit 位数
public void dfs(int index, char[] num, int digit) {
if (index == digit) {
// 接下来要生成 index 下标的数字，
// 此时说明已经生成了 digit 位数，将其存入数组中并返回即可
ret[count++] = Integer.valueOf(String.valueOf(num));
return;
}
// 生成范围是 0 ~ 9
for (char i = '0'; i <= '9'; i++) {
num[index] = i;
// 继续生成剩下的数字
dfs(index + 1, num, digit);
}
}
}
7. LCR 139. 训练计划 I
这个简单，用双指针就行，left 从 0 下标开始找偶数，right 从最后一个位置开始找奇数，然后交换 left 和 right 下标的值，然后 left 和 right 再继续往后找下一组，直到 left 和 right 相遇。
代码实现：
class Solution {
public int[] trainingPlan(int[] actions) {
// 这个简单
int left = 0;
int right = actions.length - 1;
while (left < right) {
// left 往后走找偶数
while (left < right && actions[left] % 2 == 1) {
left++;
}
// right 往前找奇数
while (left < right && actions[right] % 2 == 0) {
right--;
}
// 此时 left 一定是偶数， right 一定是奇数，交换
int tmp = actions[left];
actions[left] = actions[right];
actions[right] = tmp;
}
return actions;
}
}
8. LCR 158. 库存管理 II
这个也简单，将数组排序，排完序后，下标为 arr.length / 2 的元素就一定是出现次数超过一半的数字。还有另一种方法，叫做摩尔投票法，简单来说就是假设该数是众数 x ，那么遇到 x 就 count++，不是 x 就 count--，如果此时 count 为 0 了，那么说明 x 一定不是众数，因为众数的出现次数大于数组的一半，所以遍历完数组，最后 count 应该是大于 0 的。
代码实现：
class Solution {
public int inventoryManagement(int[] stock) {
Arrays.sort(stock);
return stock[stock.length / 2];
}
}
// 投票法
class Solution {
public int inventoryManagement(int[] stock) {
int count = 1;
int x = stock[0];
for (int i = 1; i < stock.length; i++) {
if (count == 0) {
// 当票数为 0 时，则说明此时 x 不是众数
// 就需要重新假设当前数字为众数
x = stock[i];
}
if (x == stock[i]) {
// 数字相同，则票数++
count++;
} else {
// 数字不同，则票数--
count--;
}
}
return x;
}
}
9. LCR 159. 库存管理 III
这个简单，就是先排序，然后返回范围从 0 到 cnt - 1 下标的数组即可。
也可以用优先级队列来做，求前 k 大的元素，建立小根堆，然后遍历数组，前 k 个入队，从 第 k+1 个元素开始与堆顶元素比较，如果 k+1 元素大于堆顶元素，那么堆顶元素出队，第 k+1 元素入队，遍历完数组后，堆顶元素就是第 k 大的元素。求前 k 小元素，就建立大根堆，与上面思路类似。
代码实现：
class Solution {
public int[] inventoryManagement(int[] stock, int cnt) {
Arrays.sort(stock);
return Arrays.copyOfRange(stock, 0, cnt);
}
}
// 利用优先级队列解决 top-k 问题
class Solution {
public int[] inventoryManagement(int[] stock, int cnt) {
if (stock == null || stock.length == 0 || cnt <= 0) return new int[0];
// 或者利用大根堆来做，就是 tok-k 问题
PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
for (int i = 0; i < stock.length; i++) {
if (i < cnt) {
queue.offer(stock[i]);
} else {
int top = queue.peek();
if (top > stock[i]) {
queue.poll();
queue.offer(stock[i]);
}
}
}
// 最后队列里就是前 cnt 个小的元素
int[] ret = new int[cnt];
for (int i = cnt - 1; i >= 0; i--) {
ret[i] = queue.poll();
}
return ret;
}
}
10. LCR 160. 数据流中的中位数
如图，题目让你找有序数组中的中位数，那就是先定义一个数组 arr 用来存放数据，然后再定义 usedSize 记录数组大小，然后写新增元素方法，那就是先判断数组满没满，满了就扩容，然后再新增元素，写寻找中位数时，可以先排序这个数组，使用直接插入排序即可，然后再来找到中位数。
看了大佬的题解，发现可以用两个优先级队列来做，队列 A 存储较大的一半数字(小根堆)，队列 B 存储较小的一半数字(大根堆)。
新增元素 num 时，当 A 的元素个数等于 B 的元素个数时，需要往 A 队列增加元素，先把 num 添加进 B 队列中，然后再让 B 队列的堆顶元素添加进 A 队列中。当 A 的元素个数不等于 B 的元素个数时，需要往 B 添加元素，将 num 放入 A 队列中，然后再将 A 队列的堆顶元素放入 B 队列中。
查找中位数，如果两个队列的元素个数不相等，那就返回 A 队列的堆顶元素，如果元素个数相等，那就返回两队列的堆顶元素的和除以 2.0。
代码实现：
class MedianFinder {
/**
* initialize your data structure here.
*/
int usedSize = 0;
int[] arr;
public MedianFinder() {
arr = new int[10];
}
public void addNum(int num) {
// 扩容
if (usedSize == arr.length) {
this.arr = Arrays.copyOf(arr, arr.length * 2);
}
arr[usedSize] = num;
usedSize++;
}
public double findMedian() {
if (usedSize == 0) {
return -1.0;
}
// 直接插入排序
for (int i = 1; i < usedSize; i++) {
int j = i - 1;
int tmp = arr[i];
for (; j >= 0; j--) {
if (arr[j] > tmp) {
arr[j + 1] = arr[j];
} else {
break;
}
}
arr[j + 1] = tmp;
}
if (usedSize % 2 == 1) {
return (double) arr[usedSize / 2];
} else {
double sum = arr[usedSize / 2] + arr[usedSize / 2 - 1];
return sum / 2;
}
}
}
// 利用两个优先级队列来解决
class MedianFinder {
PriorityQueue<Integer> A, B;
/**
* initialize your data structure here.
*/
public MedianFinder() {
// A 是小根堆，B 是大根堆
A = new PriorityQueue<Integer>();
B = new PriorityQueue<Integer>(new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
}
public void addNum(int num) {
if (A.size() == B.size()) {
// 则需要往 A 队列中添加元素
B.offer(num);
A.offer(B.poll());
} else {
// 需要往 B 队列添加元素
A.offer(num);
B.offer(A.poll());
}
}
public double findMedian() {
if (A.size() == B.size()) {
return (A.peek() + B.peek()) / 2.0;
} else {
return A.peek();
}
}
}
11. LCR 164. 破解闯关密码
这道题本质上就是排序问题，字符串之间的排序，可以用冒泡排序来写。
比如示例 2：
0，3，30，34，5，9
0 和 3 不需要交换，因为 03 <= 30 ， 0，3，30，34，5，9
3 和 30 需要交换，因为 330 > 303， 0，30，3，34，5，9
3 和 34 不需要交换，因为 334 <= 343， 0，30，3，34，5，9
34 和 5 不需要交换，因为 345 <= 543， 0，30，3，34，5，9
5 和 9 不需要交换，因为 59 <= 95， 0，30，3，34，5，9
那假设数组后面还有个 1 的话：0，3，30，34，5，9，1
那么 9 和 1 需要交换，0，30，3，34，5，1，9，而 1 很明显应该要在 0 之后，所以排序需要多来几趟，就可以用冒泡排序，根据相邻两个数字的拼接顺序的后的大小，来判断两个数字要不要交换。排完序后就再次遍历数组，拼接数组中元素，然后返回字符串即可。
代码实现：
class Solution {
public String crackPassword(int[] password) {
// 冒泡排序
for (int i = 0; i < password.length - 1; i++) {
boolean flg = true;
for (int j = 0; j < password.length - 1 - i; j++) {
// 8 和 7 --> 87 和 78 , 87 > 78, 则需要交换
String s1 = password[j] + "" + password[j + 1];
String s2 = password[j + 1] + "" + password[j];
if (s1.compareTo(s2) > 0) {
int tmp = password[j];
password[j] = password[j + 1];
password[j + 1] = tmp;
flg = false;
}
}
if (flg) break;
}
// 最后遍历数组，拼接字符串即可
StringBuilder s = new StringBuilder();
for (int i = 0; i < password.length; i++) {
s.append(password[i]);
}
return s.toString();
}
}
// 解法二：重写排序方法
class Solution {
public String crackPassword(int[] password) {
List<String> arr = new ArrayList<>();
for (int num : password) {
arr.add(String.valueOf(num));
}
arr.sort(new Comparator<String>() {
public int compare(String s1, String s2) {
return (s1 + s2).compareTo(s2 + s1);
}
});
StringBuilder ans = new StringBuilder();
for (String x : arr) {
ans.append(x);
}
return ans.toString();
}
}
12. LCR 168. 丑数
根据题目可以发现，第 n 个丑数其实就是通过前面的丑数 * 2，或者丑数 * 3，或者丑数 * 5，并且按照升序排列得到的，所以这道题可以用动态规划来做，dp[i] 就表示第 i 个丑数的值。
我们可以先定义三个指针，p2，p3，p5。
p2 表示 dp 数组中还没使用过乘 2 机会的，数字的下标(p2 前面的下标对应的数字都使用过 * 2 得到了一个丑数)。p3 和 p5 同理。所以在一开始，p2 和 p3 和 p5 都指向初始位置 1，dp[1] = 1。
然后 dp[i] 就等于 还没使用过乘 2 机会的数字 * 2，还没使用过乘 3 机会的数字 * 3，还没使用过乘 5 机会的数字 * 5，中的最小值，然后判断使用这三个指针是否得到了 dp[i]，如果是，那么对应的下标往后走。最后返回 dp[n] 即可。
代码实现：
class Solution {
public int nthUglyNumber(int n) {
int[] dp = new int[n + 1];
dp[1] = 1;
// p2 表示 dp 数组中还没使用乘 2 机会的第一个数字所对应的下标
int p2 = 1, p3 = 1, p5 = 1;
for (int i = 2; i <= n; i++) {
int num2 = dp[p2] * 2, num3 = dp[p3] * 3, num5 = dp[p5] * 5;
// dp[i] 就是这三个数字中最小的那个
dp[i] = Math.min(num2, num3);
dp[i] = Math.min(dp[i], num5);
if (dp[i] == num2) {
// 当前下标的数字已经使用过乘 2 机会了，那么 p2 需要往后走
p2++;
}
if (dp[i] == num3) {
p3++;
}
if (dp[i] == num5) {
p5++;
}
}
return dp[n];
}
}
13. LCR 170. 交易逆序对的总数
第一眼，看上就就是两次遍历，前一个大于后一个，那就 count++，最后返回 count，但是超时了。看题解发现能用归并排序来做，在合并数组的时候，如果 arr[i] (i >= left && i <= mid)大于 arr[j] (j > mid && j <= right) ，则说明至少有 mid - i + 1 个逆序对，用 count 来记录，最后返回 count 即可。
代码实现：
class Solution {
int count = 0;
public int reversePairs(int[] record) {
// 可以用归并排序来做
mergeSort(record, 0, record.length - 1);
return count;
}
public void mergeSort(int[] arr, int left, int right) {
// 只有一个元素，不用排序
if (left >= right) return;
// 二分
int mid = (left + right) / 2;
// 分割左边
mergeSort(arr, left, mid);
// 分割右边
mergeSort(arr, mid + 1, right);
// 合并
merge(arr, left, mid, right);
}
public void merge(int[] arr, int left, int mid, int right) {
int[] tmpArr = new int[right - left + 1];
// 合并有序数组
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
tmpArr[k++] = arr[i++];
} else {
// 因为 arr[i] > arr[j]
// 所以 left 到 mid 区间的所有元素都比 arr[j] 大
// [1,3,5,9] [2,6,7]
// 3 > 2, 所以 3,5,9 也大于 2
count += (mid - i + 1);
tmpArr[k++] = arr[j++];
}
}
while (i <= mid) {
tmpArr[k++] = arr[i++];
}
while (j <= right) {
tmpArr[k++] = arr[j++];
}
// 拷贝回原数组
for (i = left; i <= right; i++) {
arr[i] = tmpArr[i - left];
}
}
}
14. LCR 172. 统计目标成绩的出现次数
这个很简单，直接遍历数组，看看当前元素与 target 是否相同，相同就 count++，最后返回 count 即可。还可以用二分查找来做，先查找出数组最前面的 target 的下标，然后再找出最后面 target 的下标，然后返回下标差 + 1 即可。
代码实现：
class Solution {
public int countTarget(int[] scores, int target) {
int count = 0;
for (int i = 0; i < scores.length; i++) {
if (scores[i] == target) {
count++;
}
}
return count;
}
}
// 二分查找
class Solution {
public int countTarget(int[] scores, int target) {
if (scores == null || scores.length == 0) return 0;
// 通过二分查找找出 target 的左边界
int left = 0, right = scores.length - 1;
while (left < right) {
int mid = (left + right) / 2;
if (scores[mid] >= target) {
right = mid;
} else {
left = mid + 1;
}
}
// 如果没找到，说明数组没有 target
if (scores[left] != target) return 0;
int l = left;
// 通过二分查找找出 target 的右边界
left = 0;
right = scores.length - 1;
while (left < right) {
int mid = (left + right + 1) / 2;
if (scores[mid] <= target) {
left = mid;
} else {
right = mid - 1;
}
}
return right - l + 1;
}
}
15. LCR 173. 点名
这个简单，可以把 n 位同学的学号加起来得到 sum (从 1 加到 n)，然后再遍历数组，用 sum 减去数组的和就能得到缺席的同学学号。
也可以用哈希表的方法来写，记录数组中每个元素的出现次数，然后遍历哈希表，第一次遇到出现次数为 0 的就是缺失的数字。
也可以看题能得知，数组下标与数组学号是相同的，如果不相同，那么数组下标就是缺失的数字。
也可以用二分查找，缺失的元素在数组的右区间，如果 mid == arr[mid] ，则说明左边不存在缺失元素，所以会来到 [mid + 1， right] 区间来寻找缺失元素。如果不相等，则说明缺失元素很可能就是 mid 本身，所以 right = mid
代码实现：
class Solution {
public int takeAttendance(int[] records) {
int sum = 0;
for (int i = 0; i <= records.length; i++) {
sum += i;
}
for (int i = 0; i < records.length; i++) {
sum -= records[i];
}
return sum;
}
}
// 哈希表
class Solution {
public int takeAttendance(int[] records) {
int[] hash = new int[records.length + 1];
for (int i = 0; i < records.length; i++) {
hash[records[i]]++;
}
for (int i = 0; i < hash.length; i++) {
if (hash[i] == 0) return i;
}
return 0;
}
}
class Solution {
public int takeAttendance(int[] records) {
for (int i = 0; i < records.length; i++) {
if (i != records[i]) return i;
}
return records[records.length - 1] + 1;
}
}
// 二分查找
class Solution {
public int takeAttendance(int[] records) {
int left = 0, right = records.length - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (mid == records[mid]) {
// 去右边找，不见的元素在数组右边
left = mid + 1;
} else {
right = mid;
}
}
// 0 1 2 3 4
if (records[left] == left) return left + 1;
return left;
}
}
16. LCR 179. 查找总价格为目标值的两个商品
第一眼就是直接用两次遍历完成，但是发现超时了，可以用双指针来写，定义 left 指向数组最左边，right 指向数组最右边，数组递增，如果 arr[left] + arr[right] > target，说明从arr[left] 与 right 往后的值相加得到的结果还是大于 target，所以此时 right 应该往前走。如果 arr[left] + arr[right] < target，说明 arr[left] 太小了，所以应该 left++ 往后走，当 arr[left] + arr[right] == target 时，直接返回即可。
代码实现：
class Solution {
public int[] twoSum(int[] price, int target) {
int left = 0, right = price.length - 1;
while (left < right) {
if (price[left] + price[right] > target) {
right--;
} else if (price[left] + price[right] < target) {
left++;
} else {
return new int[]{price[left], price[right]};
}
}
return new int[]{0, 0};
}
}
17. LCR 180. 文件组合
直接暴力枚举，用两层 for 循环搞定。
还可以用滑动窗口来做，大致思路就是进窗口，判断，出窗口。
代码实现：
class Solution {
public int[][] fileCombination(int target) {
ArrayList<int[]> ret = new ArrayList<>();
for (int i = 1; i < target; i++) {
int sum = i;
for (int j = i + 1; j < target; j++) {
if (sum == target) {
int[] arr = new int[j - i];
for (int k = i; k < j; k++) {
arr[k - i] = k;
}
ret.add(arr);
break;
} else if (sum > target) {
break;
} else {
sum += j;
}
}
}
return ret.toArray(new int[ret.size()][]);
}
}
class Solution {
public int[][] fileCombination(int target) {
ArrayList<int[]> ret = new ArrayList<>();
int left = 1, right = 1;
int sum = 0;
while (left <= target / 2) {
// 说明此时值太小，需要 right 往后挪动
while (right < target && sum < target) {
sum += right;
right++;
}
if (sum == target) {
// 记录结果
int[] arr = new int[right - left];
for (int i = left; i < right; i++) {
arr[i - left] = i;
}
// 此时说明 right 再往后走，sum 也一定大于 target，
// 则需要寻找下一组 sum，那么 left 就需要往后走
ret.add(arr);
sum -= left;
left++;
} else if (sum > target) {
// 此时值太大，需要减去一些值，就可以减去 left
sum -= left;
left++;
}
}
return ret.toArray(new int[ret.size()][]);
}
}
18. LCR 183. 望远镜中最高的海拔
如图，题目明示你用滑动窗口，那这道题就可以用滑动窗口来做。
代码实现：
class Solution {
public int[] maxAltitude(int[] heights, int limit) {
// 如果数组没有元素，那么返回的数组也不能有元素
if (heights.length == 0) return new int[0];
// left 为窗口起点，right 为窗口终点
int left = 0, right = 0;
// count 为当前窗口大小
int count = 0;
// 记录返回值，k 为 ret 当前存放元素个数
int[] ret = new int[heights.length - limit + 1];
int k = 0;
while (left <= heights.length - limit) {
if (count < limit) {
// 没到窗口大小，那就入元素
right++;
count++;
} else if (count == limit) {
// 从窗口起点到终点找最大值
int max = Integer.MIN_VALUE;
for (int i = left; i < right; i++) {
max = Math.max(max, heights[i]);
}
ret[k++] = max;
// 出窗口
left++;
count--;
} else {
// 超过窗口容量，出窗口
left++;
count--;
}
}
return ret;
}
}
19. LCR 186. 文物朝代判断
问你数组的数字是否连续，0 可以当作万能牌，问你 5 张牌能不能组成顺子。
看到这我第一想法就是排序，然后遍历数组，看看数组是否是连续的，如果不是，那就记录差了多少个数字，然后如果万能牌 0 的个数大于等于差的数字个数，则说明数组是连续的，但是还得注意，如果有相同牌，并且相同牌不是 0 的话，则说明数组不是连续的。
看大佬的题解，发现能直接通过找数组最大值和最小值(除 0 外)，然后 max - min < 5 则说明连续，那这样就好办了，可以用 set 来判重，遍历数组找最大最小值，然后判断即可。
代码实现：
class Solution {
public boolean checkDynasty(int[] places) {
// 先排序，然后遍历数组
Arrays.sort(places);
int count = 0;
int sum = 0;
for (int i = 0; i < places.length - 1; i++) {
if (places[i] == 0) {
count++;
} else {
// 不能有相同牌，有相同牌就不是顺子了
if (places[i] == places[i + 1]) return false;
// 0,0,6,7,9
if (places[i] + 1 != places[i + 1]) {
sum += places[i + 1] - 1 - places[i];
}
}
}
if (count >= sum) return true;
else return false;
}
}
// set 去重
class Solution {
public boolean checkDynasty(int[] places) {
Set<Integer> set = new HashSet<>();
int min = 14;
int max = 0;
for (int x : places) {
if (x == 0) continue;
// 重复牌
if (set.contains(x)) {
return false;
}
max = Math.max(x, max);
min = Math.min(x, min);
set.add(x);
}
return max - min < 5;
}
}
20. LCR 189. 设计机械累加器
我们可以利用短路逻辑，用递归来写，递归出口就是当 target = 1 时，那么我们可以利用短路逻辑与，当 target > 1 && (写要执行的代码)，最后再将后面部分改成值恒为真的布尔表达式，最后再返回即可。
代码实现：
class Solution {
public int mechanicalAccumulator(int target) {
// 用递归，可以利用短路逻辑来写
// 如果 target <= 1，则递归停止，否则返回就相加
boolean flg = target > 1 && (target += mechanicalAccumulator(target - 1)) > 0;
return target;
}
}
21. LCR 191. 按规则计算统计结果
这道题不算难，让你求 arrB[i] 为数组 arrA 中除了 arrA[i] 外所有元素的乘积，只需要把 arrA 数组遍历一遍，求出除了 0 外所有元素的乘积 mul，并记录 arrA 中 0 的个数，然后用 mul / arrA[i] 就能得到对应的 arrB[i]，然后返回 arrB 即可。
但是有个毒点，那就是要考虑 arrA 中含有元素 0 的情况，但是这个 0 也要分情况讨论：
如果 0 只有一个，那么其他元素相乘就都是 0，而 0 对应的元素既是其他元素的乘积。
如果 0 有两个及以上，那么返回的数组 arrB 的所有元素就都是 0 了。
根据以上思路，代码就很好写啦。
还有另一种方法，看题解知道的可以创建个数组 left 和 right，left[i] 表示 arrA[i] 以前的元素乘积(不包括 arrA[i])，right[i] 表示 arrA[i] 以后的元素乘积(不包括 arrA[i])，这样 arrB[i] = left[i] * right[i]。
代码实现：
class Solution {
public int[] statisticalResult(int[] arrayA) {
int mul = 1;
// 记录数组中 0 的个数
int count = 0;
int[] arrB = new int[arrayA.length];
// 求出数组每个元素的乘积(除 0 外)
for (int i = 0; i < arrayA.length; i++) {
if (arrayA[i] == 0) {
count++;
continue;
}
mul *= arrayA[i];
}
if (count >= 2) {
// 说明数组中有两个及以上的 0 ,则值一定全是 0
return new int[arrayA.length];
}
for (int i = 0; i < arrB.length; i++) {
if (count > 0) {
// 此时说明数组中含有一个 0，则除 0 外所有数组都是 0
if (count == 1) {
if (arrayA[i] != 0) {
arrB[i] = 0;
} else {
arrB[i] = mul;
}
}
} else {
// 数组中没 0，正常执行
arrB[i] = mul / arrayA[i];
}
}
return arrB;
}
}
class Solution {
public int[] statisticalResult(int[] arrayA) {
// 边界情况
if (arrayA == null || arrayA.length == 0) return new int[0];
int[] left = new int[arrayA.length];
left[0] = 1;
// 遍历数组初始化 left 的值
for (int i = 1; i < arrayA.length; i++) {
left[i] = left[i - 1] * arrayA[i - 1];
}
// 记录右边的元素乘积
int right = 1;
for (int i = left.length - 1; i >= 0; i--) {
left[i] *= right;
right *= arrayA[i];
}
return left;
}
}
字符串
22. LCR 122. 路径加密
这个很简单，遍历判断即可然后用 StringBuilder 即可。
代码实现：
class Solution {
public String pathEncryption(String path) {
StringBuilder str = new StringBuilder();
for (int i = 0; i < path.length(); i++) {
char ch = path.charAt(i);
if (ch != '.') {
str.append(ch);
} else {
str.append(' ');
}
}
return str.toString();
}
}
23. LCR 138. 有效数字
一种比较简单的做法，就是判断该字符串不是有效数字的情况，严格按照题目规定的顺序来判断字符串：按照 空格，(正负号)，数字，(点)，数字，(eE，数字)，空格
定义四个 flg 来判断字符串中是否有数字，E/e，正负号，点。
先从 0 下标开始遍历字符串，一直跳过空格。
从非空格的地方开始判断，如果是数字，那就将数字 flg 置为 true，然后跳过这一连续的数字，然后判断下标是否已经遍历完字符串，如果是，就返回 true。
如果当前字符是 E/e，如果已经出现过 E/e 之前没有出现过数字，则返回 false，否则将 E/e flg 置为 true，再将其他三个 flg 置为 false，往 E 之后重新开始找数字。
如果当前字符是正负号，如果已经出现过符号，数字，点，就返回 false，否则将 符号 flg 置为 true。
如果当前字符是空格，则说明下标已经遍历到字符串末尾的空格，或者空格被字符之间夹起来了，则退出循环，单独判断。
如果是上述以外的字符，就返回 false。
出了循环，就处理末尾空格的情况，一直跳过空格，如果 下标为字符串长度并且数字 flg 是 true，则返回 true，否则返回 false
代码实现：
class Solution {
public boolean validNumber(String s) {
// 是否有数字，E，正负号，点
boolean hasNum = false;
boolean hasE = false;
boolean hasSign = false;
boolean hasDot = false;
// 先跳过开头的空格
int index = 0, len = s.length();
while (index < len && s.charAt(index) == ' ') {
index++;
}
// 从非空格的字符开始判断
// 顺序严格按照 空格，正负号，数字，(点)，数字，eE，数字 空格
while (index < len) {
if (isNum(s.charAt(index))) {
hasNum = true;
// 如果是数字
while (index < len && isNum(s.charAt(index))) {
index++;
}
// 说明字符串全是数字
if (index == len) return true;
}
// 到这里就字符就一定是非数字的
char c = s.charAt(index);
if (c == 'e' || c == 'E') {
// 如果出现多个 E，或者之前没有出现过数字
if (hasE || !hasNum) {
return false;
}
hasE = true;
// 将其他三个 flg 置为 false，继续从 E 往后找新的数字
hasNum = false;
hasSign = false;
hasDot = false;
} else if (c == '+' || c == '-') {
// 如果之前出现过符号或者数字或者'.'，则返回 false
if (hasSign || hasNum || hasDot) {
return false;
}
hasSign = true;
} else if (c == '.') {
// 如果之前出现过点或者 eE
if (hasDot || hasE) {
return false;
}
hasDot = true;
} else if (c == ' ') {
// 说明此时可能到了字符串末尾的空格，也可能是夹在字符间的空格，需要额外处理。
break;
} else {
// 其他非法字符
return false;
}
index++;
}
// 处理末尾空格
while (index < len && s.charAt(index) == ' ') {
index++;
}
if (index == len && hasNum) {
return true;
}
return false;
}
public boolean isNum(char c) {
if (c >= '0' && c <= '9') return true;
return false;
}
}
24. LCR 157. 套餐内商品的排列顺序
这道题可以用深搜来做，还是用那一套模板，定义 flg 数组表示对应的 str[j] 是否被遍历过，注意去重可以用 是否是从左往右第一个未被填入的字符来判断( j > 0 && flg[j - 1] = false && flg[j - 1] == flg[j])，所以需要先对数组 str 进行排序，再从 0 下标开始遍历，如果该字符已经遍历过，或者不是从左往右第一个未被填入的字符，那就 continue，否则就将该字符 append 进 tmp 中，然后继续生成下一个位置的字符，然后就是回溯，将 flg[j] = false，并且将 str[j] 从 tmp 中删除。递归的出口就是当要生成的字符位置为 str.length 时，则说明字符生成完毕，将 tmp 添加进结果集合中，然后返回。
代码实现：
class Solution {
List<String> arr;
boolean[] flg;
public String[] goodsOrder(String goods) {
arr = new ArrayList<>();
int len = goods.length();
flg = new boolean[len];
// 用深搜 + 回溯
char[] str = goods.toCharArray();
Arrays.sort(str);
StringBuilder tmp = new StringBuilder();
dfs(str, 0, len, tmp);
String[] ret = new String[arr.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = arr.get(i);
}
return ret;
}
public void dfs(char[] str, int i, int len, StringBuilder tmp) {
if (i == len) {
// 说明已经生成完 len 个字符了
arr.add(tmp.toString());
return;
}
// 从 0 开始生成，第 i 位置的字符一共有 len 中可能性
for (int j = 0; j < len; j++) {
// 判断是否已经生成过该字符, 是否是从左往右第一个未被填入的字符
if (flg[j] || (j > 0 && !flg[j - 1] && str[j - 1] == str[j])) {
continue;
}
tmp.append(str[j]);
flg[j] = true;
// 生成下一个字符
dfs(str, i + 1, len, tmp);
// 回溯
tmp.deleteCharAt(tmp.length() - 1);
flg[j] = false;
}
}
}
25. LCR 167. 招式拆解 I
可以用滑动窗口和哈希表来做，定义 count 来记录最长连续不重复字符，定义 left 和 right 两个指针指向 0，用 set 来记录连续不重复字符，如果 arr[right] 是不重复字符，则添加到 set 里，然后 right++，直到遇到重复字符，那就先判断 set 的大小与 count 谁大，如果 set 大，则更新 count，然后再让 left 跳过重复字符，right++ 跳过重复字符，往后开始找新的连续不重复字符，最后返回 count 即可。
代码实现：
class Solution {
public int dismantlingAction(String arr) {
if (arr == null || arr.length() == 0) return 0;
// 感觉可以用滑动窗口来做
int count = 1;
int left = 0;
int right = 0;
int len = arr.length();
// set 用来记录连续不重复的字符
Set<Character> set = new HashSet<>();
while (right < len) {
// 如果 arr[right] 不在 set 里，说明它不是重复字符
// 则将 arr[right] 添加进 set 中，并让 right 往后走
while (right < len && !set.contains(arr.charAt(right))) {
set.add(arr.charAt(right++));
}
if (right >= len) {
break;
}
// 如果 arr[right] 是重复字符 x ，则让 left 一直往后走
// 直到跳过这个重复字符，然后最后再将重复字符 x 添加进 set 中
// right 继续往后找连续不重复字符
if (set.contains(arr.charAt(right))) {
// 判断更新
if (set.size() > count) {
count = set.size();
}
// 出窗口
char ch = arr.charAt(right);
while (left < right && arr.charAt(left) != ch) {
set.remove(arr.charAt(left++));
}
// set.remove(arr.charAt(left++));
// set.add(ch);
// left++ 跳过该重复字符
left++;
// 从重复字符往后开始找新的连续不重复字符
right++;
}
}
// 还需判断一次，防止漏掉最后的连续不重复字符
if (set.size() > count) count = set.size();
return count;
}
}
26. LCR 169. 招式拆解 II
这个简单，用哈希表来做就行，记录每个字符出现的次数，然后再次遍历字符串，第一个出现次数为 1 的字母就是结果，如果到最后都没出现，则返回空格。
代码实现：
class Solution {
public char dismantlingAction(String arr) {
int[] hash = new int[26];
for (int i = 0; i < arr.length(); i++) {
char ch = arr.charAt(i);
hash[ch - 'a']++;
}
for (int i = 0; i < arr.length(); i++) {
char ch = arr.charAt(i);
if (hash[ch - 'a'] == 1) {
return ch;
}
}
char c = ' ';
return c;
}
}
27. LCR 181. 字符串中的单词反转
这个也简单，整体思路就是先将整个字符串逆序，然后再分别逆序每个单词，可以用双指针来做，i 为 单词的开始下标，end 为单词的结束下标的下一个，先让 i 一直跳过空格找到字母或数字，然后 end 从 i 开始，只要不是空格，end 就往后走，当 end 停下来时，end - 1 就是单词结尾，逆序 i 到 end - 1 范围的字符，然后 i 再从 end 开始走。最后 i 重新遍历字符串数组，不是空格就一直添加进 ret 中，是空格就跳过，然后判断 i 是否越界，越界就跳出循环，然后如果 ret 不为空就添加一个空格到 ret 中，最后返回 ret.toString() 即可。
代码实现：
class Solution {
public String reverseMessage(String message) {
char[] arr = message.toCharArray();
// 逆序整个字符串
reverse(arr, 0, arr.length - 1);
// 每个单词逆序
int i = 0;
while (i < arr.length) {
// 跳过空格
while (i < arr.length && arr[i] == ' ') {
i++;
}
// 到这里 i 一定是数字或者字母
int end = i;
while (end < arr.length && arr[end] != ' ') {
end++;
}
// 到这里 end 一定是空格，i 到 end - 1 则是单词
reverse(arr, i, end - 1);
i = end;
}
StringBuilder str = new StringBuilder();
for (i = 0; i < arr.length; ) {
while (i < arr.length && arr[i] != ' ') {
str.append(arr[i++]);
}
while (i < arr.length && arr[i] == ' ') {
i++;
}
// 防止句尾添加多余空格
if (i >= arr.length) {
break;
}
// 防止开头添加空格
if (str.length() != 0) {
str.append(' ');
}
}
return str.toString();
}
public void reverse(char[] arr, int left, int right) {
while (left < right) {
char tmp = arr[left];
arr[left++] = arr[right];
arr[right--] = tmp;
}
}
}
28. LCR 182. 动态口令
这个也很简单，直接使用 substring 方法，截取字符串，最后拼接返回即可。
要是不让使用 substring 方法，那就自己遍历字符串即可。这个还可以简化一下，通过求余运算来简化。还有另一种方法，那就是先逆序整个字符串，然后再分别逆序 (0，len - t) 和 (len - t ，len)。
代码实现：
class Solution {
public String dynamicPassword(String password, int target) {
String str2 = password.substring(0, target);
String str1 = password.substring(target);
String ret = str1 + str2;
return ret;
}
}
class Solution {
public String dynamicPassword(String password, int target) {
StringBuilder ret = new StringBuilder();
for(int i = target; i < password.length(); i++){
ret.append(password.charAt(i));
}
for(int i = 0; i < target; i++){
ret.append(password.charAt(i));
}
return ret.toString();
}
}
// 简化后
class Solution {
public String dynamicPassword(String password, int target) {
StringBuilder ret = new StringBuilder();
for(int i = target; i < password.length() + target; i++){
ret.append(password.charAt(i % password.length()));
}
return ret.toString();
}
}
// 逆序
class Solution {
public String dynamicPassword(String password, int t) {
// a b c d e t = 2,len = 5
// c d e a b (2)
// e d c b a (3)
// 要从 3 变到 2，需要逆序 (0,len - t) 和 (len - t, len)
char[] arr = password.toCharArray();
int len = arr.length;
reverse(arr, 0, len - 1);
reverse(arr, 0, len - 1 - t);
reverse(arr, len - t, len - 1);
return new String(arr);
}
public void reverse(char[] arr, int left, int right) {
while (left < right) {
char tmp = arr[left];
arr[left++] = arr[right];
arr[right--] = tmp;
}
}
}
29. LCR 192. 把字符串转换成整数 (atoi)
直接严格按照题目要求来写，
1. 首先跳过字符串的前导空格
2. 然后看下一个字符，是不是正号，负号
3. 然后再从下一个字符开始，一直读数字字符，如果该字符不是数字字符，就直接返回
4. 将上面读到的数字串转化为 int，且跳过前导 0。
5. 如果最后数字大于 int 最大值，返回 int 最大值，如果数字小于 int 最小值，返回 int 最小值，如果没有读到数字，返回 0。
代码实现：
class Solution {
public int myAtoi(String str) {
int i = 0;
int len = str.length();
// 是否是负数
boolean flg = false;
// 记录正负号数量
int flgOp = 0;
// 记录数字串
StringBuilder num = new StringBuilder();
// 跳过前导空格
while (i < len && str.charAt(i) == ' ') {
i++;
}
// 下一个字符是否是正负号，如果正负号或点号大于等于 2，则返回 0
if (i < len && str.charAt(i) == '-') {
flgOp++;
flg = true;
i++;
}
if (i < len && str.charAt(i) == '+') {
flgOp++;
i++;
}
// 如果该字符不是数字，则返回 0
if (i < len && !isNum(str.charAt(i))) {
return 0;
}
// 记录 从 i 开始一直到非数字的整个数字范围
int end = i;
while (end < len && isNum(str.charAt(end))) {
end++;
}
String tmp = str.substring(i, end);
// 添加进数字字符串中
num.append(tmp);
// 到这里就是非数字部分，直接退出
// 正负号数量大于 1，则说明字符串不合法
if (flgOp >= 2) {
return 0;
}
double sum = 0;
// 用 i 遍历 num 数字串
i = 0;
// 根据 num 字符串，计算结果
// 跳过前导 0
while (i < num.length() && num.charAt(i) == '0') {
i++;
}
while (i < num.length()) {
int t = num.charAt(i) - '0';
sum = (sum * 10 + t);
i++;
}
// 如果是负数
if (flg) {
sum *= -1;
}
if (sum > Integer.MAX_VALUE - 1) {
return Integer.MAX_VALUE;
} else if (sum < Integer.MIN_VALUE) {
return Integer.MIN_VALUE;
} else {
return (int) sum;
}
}
public boolean isNum(char c) {
return c >= '0' && c <= '9';
}
}
链表
30. LCR 123. 图书整理 I
这个简单，直接翻转链表，然后添加到数组中即可。
还可以用递归实现。
代码实现：
class Solution {
public int[] reverseBookList(ListNode head) {
if (head == null) return new int[0];
// 头插法
ListNode prev = head;
ListNode cur = head.next;
prev.next = null;
int len = 1;
while (cur != null) {
ListNode curNext = cur.next;
cur.next = prev;
prev = cur;
cur = curNext;
len++;
}
int[] ret = new int[len];
int i = 0;
cur = prev;
while (cur != null) {
ret[i++] = cur.val;
cur = cur.next;
}
return ret;
}
}
// 递归
class Solution {
public int[] reverseBookList(ListNode head) {
getList(head);
int[] ret = new int[arr.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = arr.get(i);
}
return ret;
}
public List<Integer> arr = new ArrayList<>();
public void getList(ListNode cur) {
if (cur == null) return;
getList(cur.next);
arr.add(cur.val);
}
}
31. LCR 136. 删除链表的节点
这道题很简单，只要删除第一次出现的 val 元素即可，定义两个指针 prev 和 cur，prev 指向 cur 的前一个元素，cur 遍历链表，如果此时 cur.val == val，那就删除 cur，然后直接返回头节点，否则就让 prev 和 head 一直往后走，到最后，如果 head.val == val，那就返回 head.next 即可。
代码实现：
class Solution {
public ListNode deleteNode(ListNode head, int val) {
if (head == null) return null;
ListNode prev = head;
ListNode cur = head.next;
while (cur != null) {
if (cur.val == val) {
prev.next = cur.next;
cur = cur.next;
return head;
} else {
prev = cur;
cur = cur.next;
}
}
if (head.val == val) head = head.next;
return head;
}
}
32. LCR 140. 训练计划 II
这个可以用快慢指针来做，定义 slow 和 fast 指向 head，先让 fast 走 cnt - 1 步，然后再让 fast 和 slow 一起走，当 fast 走到链表最后一个节点的位置时，slow 就是倒数第 cnt 个节点的位置。
代码实现：
class Solution {
public ListNode trainingPlan(ListNode head, int cnt) {
ListNode fast = head;
ListNode slow = head;
while (cnt - 1 != 0) {
fast = fast.next;
if (fast == null) {
return null;
}
cnt--;
}
while (fast.next != null) {
fast = fast.next;
slow = slow.next;
}
return slow;
}
}
33. LCR 141. 训练计划 III
这个简单，直接逆序链表，采用头插法即可。
代码实现：
class Solution {
public ListNode trainningPlan(ListNode head) {
// 采用头插法即可
if (head == null || head.next == null) return head;
ListNode prev = head;
ListNode cur = head.next;
// 防止代码成环
prev.next = null;
while (cur != null) {
ListNode curNext = cur.next;
cur.next = prev;
prev = cur;
cur = curNext;
}
return prev;
}
}
34. LCR 142. 训练计划 IV
思路跟合并有序链表大差不差。
代码实现：
class Solution {
public ListNode trainningPlan(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
if (l2 == null) return l1;
// 虚拟头节点，返回时返回 dummy.next
ListNode dummy = new ListNode(-1);
ListNode cur = dummy;
// 其实跟合并有序数组差不多
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
cur.next = l1;
l1 = l1.next;
cur = cur.next;
} else {
cur.next = l2;
l2 = l2.next;
cur = cur.next;
}
}
if (l1 != null) {
cur.next = l1;
}
if (l2 != null) {
cur.next = l2;
}
return dummy.next;
}
}
35. LCR 171. 训练计划 V
找链表相交节点，这个可以用快慢指针来做，先让 fast 走差值步，然后 fast 和 slow 一起走，当 fast 和 slow 相遇时，就是链表相交节点。
代码实现：
class Solution {
ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null) return null;
int countA = 0;
int countB = 0;
ListNode fast = headA;
ListNode slow = headB;
while (fast != null) {
fast = fast.next;
countA++;
}
while (slow != null) {
slow = slow.next;
countB++;
}
fast = headA;
slow = headB;
int len = countA - countB;
if (len < 0) {
len = countB - countA;
fast = headB;
slow = headA;
}
while (len != 0) {
fast = fast.next;
len--;
}
while (fast != slow) {
fast = fast.next;
slow = slow.next;
}
return fast;
}
}
36. LCR 154. 复杂链表的复制
让你复制一份链表，可以用哈希表来做，将老节点与新节点的对应关系存入哈希表中，最后重新遍历链表，根据哈希表来获取新节点，然后建立联系即可。
代码实现：
class Solution {
public Node copyRandomList(Node head) {
if (head == null) return null;
Node dummy = new Node(-1);
Node cur = head;
Map<Node, Node> hash = new HashMap<>();
// 将老节点与新节点的关系存起来
while (cur != null) {
Node node = new Node(cur.val);
hash.put(cur, node);
cur = cur.next;
}
cur = head;
while (cur != null) {
hash.get(cur).next = hash.get(cur.next);
hash.get(cur).random = hash.get(cur.random);
cur = cur.next;
}
return hash.get(head);
}
}
栈和队列
37. LCR 147. 最小栈
可以用两个栈来实现，一个栈当做正常的栈，另一个栈来存储最小值的栈。
入栈时，正常栈正常入栈，如果最小栈为空，那么也入栈，如果不为空，那么入栈的值 val 就需要与最小栈的栈顶元素比较，如果小于等于栈顶元素，那么 val 就入最小栈。
出栈时，首先需要判断两个栈是否为空，如果两个栈都为空，则不能出栈，否则正常栈正常出栈即可。获取栈顶元素也同理。
如果是获取最小栈栈顶元素，那还是得先判断最小栈是否为空，为空的话返回 -1，如果不为空，直接返回最小栈.peek() 即可。
代码实现：
class MinStack {
// 可以用一个栈当正常栈
// 一个栈当最小栈
Stack<Integer> s1 = new Stack<>();
Stack<Integer> s2 = new Stack<>();
/**
* initialize your data structure here.
*/
public MinStack() {
s1 = new Stack<>();
s2 = new Stack<>();
}
public void push(int x) {
s1.push(x);
if (s2.empty()) {
s2.push(x);
} else {
int top = s2.peek();
if (x <= top) {
s2.push(x);
}
}
}
public void pop() {
if (s1.empty()) {
return;
}
int top = s1.pop();
if (!s2.empty() && s2.peek() == top) {
s2.pop();
}
}
public int top() {
if (s1.empty()) {
return -1;
}
return s1.peek();
}
public int getMin() {
if (s2.empty()) {
return -1;
}
return s2.peek();
}
}
38. LCR 125. 图书整理 II
简单来说，就是让你用栈实现队列，那这个也简单，大体思路就是：直接定义两个栈，固定一个栈 1 入元素，另一个栈 2 出元素，如果栈 2 为空，那么就把栈 1 的所有元素出栈，并入到栈 2 2中，此时 栈 2 再出栈。
代码实现：
class CQueue {
// 用栈来实现队列
Stack<Integer> s1 = new Stack<>();
Stack<Integer> s2 = new Stack<>();
public CQueue() {
s1 = new Stack<>();
s2 = new Stack<>();
}
public void appendTail(int value) {
s1.push(value);
}
public int deleteHead() {
if (s1.empty() && s2.empty()) {
return -1;
}
if (s2.empty()) {
while (!s1.empty()) {
s2.push(s1.pop());
}
}
return s2.pop();
}
}
39. LCR 184. 设计自助结算系统
这道题的难点是如何用 O(1) 的时间获取的最大值，因为最大值的候补者有许多个，如何在删除最大值的时候，快速找到下一个最大值。我们可以用普通队列和双端队列实现，双端队列用来存储最大值的候补者，并将这些最大值的候补者按照降序来排序，那么双端队列的第一个元素就一定是最大值。而普通队列就正常进行操作就行，但是双端队列进行操作时就需要进行判断。
在新增元素时，双端队列如果为空，那么该元素可能是最大值，则从尾巴入队。如果双端队列不为空，就需要判断队列的尾巴元素与当前元素 val 比较，如果 val 比尾巴元素要大，则说明尾巴元素就一定不可能是最大值了，所以一直出队，直到遇到尾巴元素比当前元素 val 大，或者等于当前元素。那么此时当前元素就可以从尾巴入队了。
删除元素时，首先判断正常队列是否为空，如果为空，则直接返回，如果不为空，则正常队列出队得到了 top 元素，还需要去看看双端队列的头元素是否与 top 相同，如果相同，则双端队列把头元素出队。
代码实现：
class Checkout {
// 可以用队列和双端队列实现
Queue<Integer> queue;
// 双端队列存储可能是最大值的元素，并且按照降序存储
Deque<Integer> maxQueue;
public Checkout() {
queue = new LinkedList<>();
maxQueue = new LinkedList<>();
}
public int get_max() {
if (maxQueue.isEmpty()) {
return -1;
}
// 取出双端队列的头元素就是最大值
return maxQueue.peekFirst();
}
public void add(int value) {
queue.offer(value);
// 如果双端队列为空，则当前元素可能是最大值，入队
if (maxQueue.isEmpty()) {
maxQueue.offerLast(value);
return;
}
// 如果不为空，则需要判断，如果当前 val 大于双端队列的尾巴元素，
// 说明此时双端队列的尾巴元素一定不可能是最大值，要保持最大值降序排序
// 那就把双端队列的尾巴元素删掉，然后把 val 添加进来
while (!maxQueue.isEmpty() && value > maxQueue.peekLast()) {
maxQueue.pollLast();
}
maxQueue.offerLast(value);
}
public int remove() {
if (queue.isEmpty()) {
return -1;
}
// 删除时也同理，需要判断删除的元素是否与 max 的头元素相同，
// 如果相同，则 max 也需要出队
int top = queue.poll();
if (top == maxQueue.peekFirst()) {
maxQueue.pollFirst();
}
return top;
}
}
40. LCR 148. 验证图书取出顺序
这道题不难，就是遍历入栈数组，先将里面的元素入栈，然后判断栈顶元素与出栈元素是否相同，如果是，那就出栈，并且用 j 来遍历出栈数组，j++。
如果最后栈里为空，则返回 true，否则返回 false。
代码实现：
class Solution {
public boolean validateBookSequences(int[] putIn, int[] takeOut) {
Stack<Integer> stack = new Stack<>();
int j = 0;
for (int i = 0; i < putIn.length; i++) {
stack.push(putIn[i]);
while (!stack.empty() && stack.peek() == takeOut[j]) {
stack.pop();
j++;
}
}
if (stack.empty()) {
return true;
}
return false;
}
}
树
41. LCR 124. 推理二叉树
代码实现：
class Solution {
public int preIndex;
public TreeNode deduceTree(int[] preorder, int[] inorder) {
TreeNode root = createTree(inorder, preorder, 0, preorder.length - 1);
return root;
}
public TreeNode createTree(int[] inorder, int[] preorder, int start, int end) {
if (start > end) return null;
TreeNode root = new TreeNode(preorder[preIndex]);
// 找下标
int rootIndex = getRootIndex(inorder, start, end, preorder[preIndex]);
preIndex++;
if (rootIndex == -1) return root;
// 按照前序遍历来创建二叉树
root.left = createTree(inorder, preorder, start, rootIndex - 1);
root.right = createTree(inorder, preorder, rootIndex + 1, end);
return root;
}
// 在中序遍历中找到根节点
public int getRootIndex(int[] inorder, int start, int end, int key) {
for (int i = start; i <= end; i++) {
if (inorder[i] == key) {
return i;
}
}
return -1;
}
}
42. LCR 143. 子结构判断
这道题思路跟找子树差不多，区别就是找子树时，树 1 和树 2 的结构必须完全相同，并且对应的值也必须相同，但是这里如图例 2 ，这里当树 2 为空时，树 1 可以不为空。所以在写找子树代码时还可以分以下情况，修改修改。
总体思路就是，找子树，子树要结构相同，并且值相同，左子树相同并且右子树相同才是子树，可以用前序遍历来做，每遍历到一个节点，都去看看当前节点是否就是子树。但是得注意，当两棵树都为空时，要返回 false。
代码实现：
class Solution {
public boolean isSubStructure(TreeNode A, TreeNode B) {
// 题目要求，如果两棵树都为空，则返回 false
if (A == null && B == null) {
return false;
}
if (A == null && B != null || A != null && B == null) return false;
return isSubTree(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);
}
public boolean isSubTree(TreeNode p, TreeNode q) {
// 1. 值相同 2. 结构相同
if (p == null && q == null) return true;
if (p == null && q != null) return false;
// 当 q 为空时，p 可以不为空
if (p != null && q == null) return true;
// 值不相同
if (p.val != q.val) return false;
return isSubTree(p.left, q.left) && isSubTree(p.right, q.right);
}
}
43. LCR 144. 翻转二叉树
这个很简单，就是左子树跟右子树交换即可。用前序遍历，每一个节点的左孩子和右孩子交换即可。
代码实现：
class Solution {
public TreeNode mirrorTree(TreeNode root) {
if (root == null) return null;
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
mirrorTree(root.left);
mirrorTree(root.right);
return root;
}
}
44. LCR 145. 判断对称二叉树
这道题就是判断二叉树是否对称，前提条件就是得判断结构对称，并且值也得对称，并且左孩子 1的左孩子 2 和右孩子 1 的右孩子 2 对称，并且左孩子 1 的右孩子 2 与右孩子 1 的左孩子 2 对称。
代码实现：
class Solution {
public boolean checkSymmetricTree(TreeNode root) {
if (root == null) return true;
return isSymmetricTree(root.left, root.right);
}
public boolean isSymmetricTree(TreeNode p, TreeNode q) {
// 1. 结构相同 2. 值相同
if (p == null && q == null) return true;
if (p == null && q != null || p != null && q == null) return false;
if (p.val != q.val) return false;
// 对称，如图示例一
return isSymmetricTree(p.left, q.right) && isSymmetricTree(p.right, q.left);
}
}
45. LCR 149. 彩灯装饰记录 I
就是二叉树层序遍历，利用队列实现即可，如果队列不为空，那就先出队 top，如果左子树不为空，那就将左子树入队，如果右子树不为空，那就将右子树入队，然后再将 top 添加到数组中，最后返回数组即可。
代码实现：
class Solution {
public int[] decorateRecord(TreeNode root) {
if (root == null) return new int[0];
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
List<Integer> arr = new ArrayList<>();
while (!queue.isEmpty()) {
TreeNode top = queue.poll();
arr.add(top.val);
if (top.left != null) {
queue.offer(top.left);
}
if (top.right != null) {
queue.offer(top.right);
}
}
int[] ret = new int[arr.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = arr.get(i);
}
return ret;
}
}
46. LCR 150. 彩灯装饰记录 II
与上一题代码基本一致，就是在进入循环时，判断队列中有多少元素 size，队列中 size 的个数就是这一层节点的个数，然后循环出队 size 次，就把这层节点元素全部拿到了，最后添加进数组中，然后返回数组即可。
代码实现：
class Solution {
public List<List<Integer>> decorateRecord(TreeNode root) {
List<List<Integer>> ret = new ArrayList<>();
if (root == null) return ret;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> arr = new ArrayList<>();
int size = queue.size();
while (size != 0) {
TreeNode top = queue.poll();
arr.add(top.val);
if (top.left != null) {
queue.offer(top.left);
}
if (top.right != null) {
queue.offer(top.right);
}
size--;
}
ret.add(arr);
}
return ret;
}
}
47. LCR 151. 彩灯装饰记录 III
跟层序遍历差不多，就是逆转了下双数层的值的顺序，可以利用 Collections.reverse 方法来完成。
代码实现：
class Solution {
public List<List<Integer>> decorateRecord(TreeNode root) {
List<List<Integer>> ret = new ArrayList<>();
if (root == null) return ret;
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
boolean flg = true;
while (!queue.isEmpty()) {
int size = queue.size();
List<Integer> arr = new ArrayList<>();
while (size != 0) {
TreeNode top = queue.poll();
arr.add(top.val);
if (top.left != null) {
queue.add(top.left);
}
if (top.right != null) {
queue.add(top.right);
}
size--;
}
if (!flg) {
Collections.reverse(arr);
}
flg = !flg;
ret.add(arr);
}
return ret;
}
}
48. LCR 152. 验证二叉搜索树的后序遍历序列
二叉搜索树就是左子树小于根节点，右子树大于根节点，所以只需要判断通过递归来判定所有节点都符合上面的要求，那么这棵树就是二叉搜索树。先划分左右子树的区间，找到第一个右子树的节点(节点值大于根节点)，然后再判断右子树区间的值是否全都比根节点大，如果不是，返回 false，如果是，则递归去判断左子树和右子树。
代码实现：
class Solution {
public boolean verifyTreeOrder(int[] postorder) {
return verifyTreeOrder(postorder, 0, postorder.length - 1);
}
public boolean verifyTreeOrder(int[] postorder, int start, int end) {
if (start >= end) return true;
// 以 end 为根节点，划分左子树和右子树
int root = postorder[end];
// 往后找大于 root 的值, 找到第一个右子树节点
int cur = start;
while (postorder[cur] < postorder[end]) cur++;
// 此时 postorder[cur] 一定大于 root
int mid = cur;
// mid, end 就是右子树范围
while (postorder[cur] > postorder[end]) cur++;
// 到这里，start, mid - 1 是左子树, m,end - 1 是右子树
return cur == end && verifyTreeOrder(postorder, start, mid - 1) && verifyTreeOrder(postorder, mid, end - 1);
}
}
49. LCR 153. 二叉树中和为目标值的路径
可以用深搜来做，定义一个数组 arr 来存放遍历的节点，定义一个 sum 用来记录当前遍历过所有节点的和，用前序遍历去遍历每一个节点，先将 root 的值添加进 arr 和 sum 中，如果 sum 等于 target 并且此时是叶子节点，就添加进返回结果中，然后再删除数组 arr 当前节点，sum 减等当前节点值，最后返回结果，其他情况就继续遍历左子树，并将遍历的结果添加进返回结果中，右子树同理，最后再删除 arr 里当前节点值，sum 减去当前节点值，最后再返回结果即可。
代码实现：
class Solution {
public List<List<Integer>> pathTarget(TreeNode root, int target) {
dfs(root, target);
return ret;
}
public int sum = 0;
public List<Integer> arr = new ArrayList<>();
public List<List<Integer>> ret = new ArrayList<>();
public void dfs(TreeNode root, int target) {
if (root == null) return;
arr.add(root.val);
sum += root.val;
if (sum == target && root.left == null && root.right == null) {
ret.add(new ArrayList<>(arr));
arr.remove(arr.size() - 1);
sum -= root.val;
return;
}
dfs(root.left, target);
dfs(root.right, target);
arr.remove(arr.size() - 1);
sum -= root.val;
}
}
50. LCR 155. 将二叉搜索树转化为排序的双向链表
将二叉搜索树转化为排序的双向链表，可以利用二叉搜索树的中序遍历是有序的特点，可以定义 cur 和 prev 两个指针，prev 是 cur 的中序遍历的前一个节点，先递归往 cur 的右边走，然后判断 prev 是否为空，如果为空，说明此时 cur 就是链表头节点，记录一下。如果不为空，就可以进行修改指向了，prev.right = cur。 cur.left = prev，然后再让 prev 往后走，继续递归 cur 的右边。递归结束后，prev 就是链表的尾巴节点，只需要修改一下链表头节点和尾巴节点的指向，最后再返回即可。
代码实现：
class Solution {
public Node treeToDoublyList(Node root) {
if (root == null) return null;
dfs(root);
// 最后 prev 一定就是尾巴节点
head.left = prev;
prev.right = head;
return head;
}
public Node prev = null;
public Node head = null;
// 中序遍历
public void dfs(Node cur) {
if (cur == null) return;
dfs(cur.left);
if (prev == null) {
head = cur;
} else {
prev.right = cur;
}
cur.left = prev;
// prev 往后走
prev = cur;
dfs(cur.right);
}
}
51. LCR 156. 序列化与反序列化二叉树
序列化就是将二叉树转化成字符串，反序列化就是将字符串转化成二叉树，这道题可以用层序遍历来做，在序列化时，可以将节点为空的情况也添加到字符串中，每个节点以逗号分隔。
可以从第一层节点开始，从左到右从上到下都编一个号，从 0 开始编号，那么当前节点 cur 编号为 i，则 2*i + 1 是 cur 的左孩子，2*i + 2 是 cur 右孩子，根据这个来进行反序列化，因为是按照层序遍历的方式序列化的，所以也是按照层序遍历的方式来反序列化，将创建的节点都添加到队列中，先按照 "," 来分隔字符串，这样每个字符串 str[i] 就都是一个节点，i 从 0 开始，如果队列不为空，就出队一个元素 top，如果 top 不为空，说明 top 是一个节点，就说明 top 可能会有左右孩子，就分别判断 2*i + 1 和 2*i + 2 是否越界，如果没有越界，并且对应的 str[2*i + 1] 不为空和 str[2*i + 2] 不为空，则说明存在左孩子或者右孩子，则将左孩子和右孩子添加进队列中，并让 top 的 left 和 right 分别指向左右孩子。然后 i++ 往后走，最后返回 root 即可。
代码实现：
public class Codec {
// Encodes a tree to a single string.
public String serialize(TreeNode root) {
if (root == null) return "[]";
// 可以利用层序遍历实现
Queue<TreeNode> queue = new LinkedList<>();
StringBuilder str = new StringBuilder("[");
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode top = queue.poll();
if (top != null) {
str.append(top.val + ",");
queue.offer(top.left);
queue.offer(top.right);
} else
str.append("null,");
}
str.deleteCharAt(str.length() - 1);
str.append("]");
return str.toString();
}
// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {
if (data.equals("[]")) {
return null;
}
// 点号分隔，那就是每个节点 [1,2,3,null,null,4,5,null,null]
String[] arr = data.substring(1, data.length() - 1).split(",");
TreeNode root = new TreeNode(Integer.valueOf(arr[0]));
// 用层序遍历的方式解析
// 从 0 下标开始编号，如果该节点不为空，则:
// 左子树 2*i + 1
// 右子树 2*i + 2
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
int i = 0;
while (!queue.isEmpty()) {
TreeNode top = queue.poll();
if (2 * i + 1 < arr.length && !arr[2 * i + 1].equals("null")) {
TreeNode left = new TreeNode(Integer.valueOf(arr[2 * i + 1]));
queue.offer(left);
top.left = left;
}
if (2 * i + 2 < arr.length && !arr[2 * i + 2].equals("null")) {
TreeNode right = new TreeNode(Integer.valueOf(arr[2 * i + 2]));
queue.offer(right);
top.right = right;
}
// i++ 去遍历后一个节点
i++;
}
return root;
}
}
52. LCR 174. 寻找二叉搜索树中的目标节点
一眼看到求第 k 大元素，那就可以用优先级队列来解决，创建小根堆，用前序遍历，当小堆元素个数小于 cnt 时，那就入堆，如果元素个数大于等于 cnt，那就判断一下 root.val 与堆顶元素谁大，如果 root.val 大，那么小堆出队，然后将 root.val 添加进小堆中，然后继续遍历左子树和右子树。
遍历完成后，小堆的堆顶元素就是第 cnt 大元素。
代码实现：
class Solution {
public int findTargetNode(TreeNode root, int cnt) {
PriorityQueue<Integer> queue = new PriorityQueue<>();
getKMax(root, cnt, queue);
return queue.peek();
}
public int i;
public void getKMax(TreeNode root, int cnt, PriorityQueue<Integer> queue) {
if (root == null) return;
if (i < cnt) {
queue.offer(root.val);
} else {
int top = queue.peek();
int val = root.val;
if (val > top) {
queue.poll();
queue.offer(val);
}
}
i++;
getKMax(root.left, cnt, queue);
getKMax(root.right, cnt, queue);
}
}看了大佬的题解后，发现可以利用二叉搜索树的中序遍历是有序的来做,求第 K 大元素，那我们就可以中序遍历反着遍历，此时遇到的第 K 个元素就是第 K 大元素。
代码实现：
class Solution {
public int findTargetNode(TreeNode root, int cnt) {
getMax(root, cnt);
return kMax;
}
public int i = 1;
public int kMax = 0;
public void getMax(TreeNode root, int cnt) {
if (root == null) return;
// 中序: 左根右
// 反着来:右根左
getMax(root.right, cnt);
if (i == cnt) {
kMax = root.val;
}
i++;
if (i > cnt) return;
getMax(root.left, cnt);
}
}
53. LCR 175. 计算二叉树的深度
这个很简单，让你计算二叉搜索树的高度，可以用递归来做，整棵树的高度就等于左子树高度和右子树的高度的最大值，再加上自己这个节点本身，也就是 +1 。
代码实现：
class Solution {
public int calculateDepth(TreeNode root) {
if (root == null) return 0;
int leftHeight = calculateDepth(root.left);
int rightHeight = calculateDepth(root.right);
return Math.max(leftHeight, rightHeight) + 1;
}
}
54. LCR 176. 判断是否为平衡二叉树
这个也很简单，可以在计算树的高度的时候，去判断是否是平衡二叉树。如果是，则正常返回高度，如果不是，则返回 -1 即可，最后只需要判断得到的高度是否大于等于 0。
代码实现：
class Solution {
public boolean isBalanced(TreeNode root) {
// 可以在计算树的高度时，也判断是否是平衡二叉树
return getHeight(root) >= 0;
}
public int getHeight(TreeNode root) {
if (root == null) return 0;
int leftHeight = getHeight(root.left);
int rightHeight = getHeight(root.right);
if (leftHeight >= 0 && rightHeight >= 0 && Math.abs(leftHeight - rightHeight) <= 1) {
return Math.max(leftHeight, rightHeight) + 1;
} else {
// 说明不是平衡二叉树，那高度返回负数即可
return -1;
}
}
}
55. LCR 193. 二叉搜索树的最近公共祖先
这道题得分情况讨论，第一种情况是 p == root 或者 q == root，则此时最近公共祖先就是 root
第二种情况是如果 p 和 q 都在 root 的左边，或者 p 和 q 都在 root 的右边，如例子2，就看谁在前头就是谁。
第三种情况就是 p 和 q 分别在 root 的两边，那此时这种情况最近公共祖先就是 root，如例子1。
代码实现：
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
// 分三种情况，第一种是 p 或者 q 中有一个是 root
// 一种是 p 和 q 都在 root 的左边或者右边
// 另一种是 p 和 q 分别在 root 的两边
if (root == p || root == q) return root;
if (root == null || p == null || q == null) return null;
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if (left != null && right != null) {
return root;
} else if (left == null) {
return right;
} else {
return left;
}
}
}
56. LCR 194. 二叉树的最近公共祖先
这道题和上面那道题是解法一模一样，还有另一种做法。
如图：
代码实现：
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null) return null;
Stack<TreeNode> s1 = new Stack<>();
Stack<TreeNode> s2 = new Stack<>();
getPath(root, p, s1);
getPath(root, q, s2);
int len = s1.size() - s2.size();
if (len < 0) {
len = s2.size() - s1.size();
while (len != 0) {
s2.pop();
len--;
}
} else {
while (len != 0) {
s1.pop();
len--;
}
}
while (!s1.empty() && !s2.empty()) {
TreeNode top1 = s1.pop();
TreeNode top2 = s2.pop();
if (top1 == top2) return top1;
}
return null;
}
public boolean getPath(TreeNode root, TreeNode target, Stack<TreeNode> stack) {
if (root == null) return false;
stack.push(root);
if (root == target) return true;
boolean left = getPath(root.left, target, stack);
if (left) return true;
boolean right = getPath(root.right, target, stack);
if (right) return true;
// 到这里说明左子树和右子树都没找到 target
// 说明不是路径上的节点, 删除节点返回 false
stack.pop();
return false;
}
}
位运算
57. LCR 133. 位 1 的个数
这个简单，直接利用 n &= (n - 1) 消除 n 中二进制 1 的个数，并且用计数器记录下来即可。
代码实现：
public class Solution {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {
int count = 0;
while (n != 0) {
n &= (n - 1);
count++;
}
return count;
}
}
58. LCR 134. Pow(x, n)
可以用快速幂来做，就是 x^n = (x*x)^(n/2)（n 为偶数）或者 x*(x*x)^(n/2)
那就可以利用这个来做题。
代码实现：
class Solution {
public double myPow(double x, int n) {
if (x == 0.0) return 0.0;
// 用快速幂
// 2^9 = (2)* 4^4 = (2)* 16^2 = (2)* 256^1 = (2*256)* (256*256)^0 = 512
// 用来记录多出来的 x，也就是当 n 为奇数时，res *= x
double res = 1.0;
boolean flg = false;
// n 可能会很大，将 n 赋给 tmp 防止越界(-2147483648)
long tmp = n;
if (tmp < 0) {
tmp = -tmp;
flg = true;
}
while (tmp != 0) {
if (tmp % 2 == 1) {
res *= x;
}
x = x * x;
tmp /= 2;
}
if (flg) {
return 1.0 / res;
}
return res;
}
}
59. LCR 177. 撞色搭配
这个可以用分组异或的方式来做，先将数组所有元素异或一遍 得到 ret，ret 中的二进制为 1 的那一位说明就是两个只出现一次的数字的区分点，然后根据这个区分点，来分组异或，最后返回异或得到的结果即可。
代码实现：
class Solution {
public int[] sockCollocation(int[] sockets) {
int tmp = 0;
for (int i = 0; i < sockets.length; i++) {
tmp ^= sockets[i];
}
// 分组异或
int index = 0;
while (tmp != 0) {
if (tmp % 2 == 1) {
break;
}
tmp >>= 1;
index++;
}
int num1 = 0;
int num2 = 0;
for (int i = 0; i < sockets.length; i++) {
if (((sockets[i] >> index) & 1) == 1) {
num1 ^= sockets[i];
} else {
num2 ^= sockets[i];
}
}
return new int[]{num1, num2};
}
}
60. LCR 178. 训练计划 VI
这道题可以用哈希表来做，不会超时，遍历数组记录每个数字出现的次数，然后再次遍历数组，如果当前数字出现了一次，就返回该数字。
代码实现：
class Solution {
public int trainingPlan(int[] actions) {
Map<Integer, Integer> hash = new HashMap<>();
for (int i = 0; i < actions.length; i++) {
int value = hash.getOrDefault(actions[i], 0);
hash.put(actions[i], value + 1);
}
for (int i = 0; i < actions.length; i++) {
int value = hash.getOrDefault(actions[i], 0);
if (value == 1) {
return actions[i];
}
}
return -1;
}
}
61. LCR 190. 加密运算
这个就是让你求两个数的和，但是不能使用加减乘除，那就可以使用位运算来做，a ^ b 就是 a 和 b 不进位相加的和，那我们可以定义一个变量来记录 a 和 b 的进位，然后就一直进行异或直到进位为 0.
3 和 5
011 3
101 5
001 a & b 这就是进位，需要往前进位, 001 --> 010，所以两数之和 = 不进位和 + 进位和
所以进位的计算公式为 (a & b) << 1
010 (a & b) << 1
110 a ^ b
100 上面两个异或之后得到不进位和，再求进位
100 (a & b) << 1 进位
0000 上面两个异或之后得到不进位和，再求进位
1000 (a & b) << 1 进位
1000 异或和
0000 进位，当进位为 0，上面两数之和计算完毕
代码实现：
class Solution {
public int encryptionCalculate(int dataA, int dataB) {
if (dataA == 0) return dataB;
if (dataB == 0) return dataA;
// 两个数不进位相加的结果 a ^ b
while (dataB != 0) {
int carry = (dataA & dataB) << 1; // 计算进位
dataA = dataA ^ dataB;// 计算两数不进位相加和
dataB = carry;
}
return dataA;
}
}
动态规划
62. LCR 126. 斐波那契数
这个很简单，公式给你了，按照公式求解就行。
代码实现：
class Solution {
public int fib(int n) {
if (n == 0 || n == 1) return n;
int a = 0;
int b = 1;
int c = 0;
while (n >= 2) {
c = (a + b) % 1000000007;
a = b;
b = c;
n--;
}
return c;
}
}
63. LCR 127. 跳跃训练
这个很简单，就是青蛙跳台阶问题，跟斐波那契问题的解法一模一样。
代码实现：
class Solution {
public int trainWays(int num) {
if (num < 2) return 1;
int[] dp = new int[num + 1];
dp[0] = 1;
dp[1] = 1;
for (int i = 2; i <= num; i++) {
dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
}
return dp[num];
}
}
64. LCR 137. 模糊搜索验证
这道题用动态规划来做，大体分两种情况，当 input 的第 j-1 个字符是 * 以及不是 * 的情况。
首先是明确 dp[i][j]，根据题目可知表示以 article 的第 i 个字符结尾的串与以 input 的第 j 个字符结尾的串是否匹配。然后推导状态转移方程 dp[i][j] = ?
当 input[j - 1] != '*' 时，如果 article[i-1] == input[j-1] 或者有个字符是点号，则 dp[i][j] = dp[i - 1][j - 1] (看以 article 的第 i 个字符结尾的串与以 input 的第 j 个字符结尾的串的状态)
当 input[j - 1] 等于 '*' 时，dp[i][j] = dp[i][j-2] (因为 input[j-1] 是 '*', 所以关注 intput[j - 2] 结尾的串即可)，如果 article[i-1] == input[j-2] 或者其中一个字符是'*' 或者点号，则 dp[i][j] = dp[i][j] || dp[i - 1][j]。初始化就是当两字符串都是空串时，dp[0][0] = true。
代码实现：
class Solution {
public boolean articleMatch(String a, String b) {
// 用动态规划来做，dp[i][j] 代表在 a 中以 i 个字符结尾的字符串与在 b 中第 j 个字符结尾的字符串是否匹配
int len1 = a.length();
int len2 = b.length();
boolean[][] dp = new boolean[len1 + 1][len2 + 1];
// 初始化
dp[0][0] = true;
char[] arr1 = a.toCharArray();
char[] arr2 = b.toCharArray();
for (int i = 0; i <= len1; i++) {
for (int j = 1; j <= len2; j++) {
if (arr2[j - 1] == '*') {
dp[i][j] = dp[i][j - 2];
if (i > 0) {
if (charMatch(arr1[i - 1], arr2[j - 2])) {
dp[i][j] = dp[i][j] || dp[i - 1][j];
}
}
} else {
if (i > 0 && charMatch(arr1[i - 1], arr2[j - 1])) {
dp[i][j] = dp[i - 1][j - 1];
}
}
}
}
return dp[len1][len2];
}
public boolean charMatch(char a, char b) {
if (a == '*' || b == '*' || a == '.' || b == '.') return true;
return a == b;
}
}
65. LCR 161. 连续天数的最高销售额
这道题可以用动态规划来做，求连续数组最大和，dp[i] 就是以 i 下标结尾天数的最大和。
dp[i] = Math.max(sales[i], dp[i - 1] + sales[i])，因为 sales[i] 可能是负数。
初始化，dp[0] = sales[0]，最后遍历 dp 找最大值并返回即可。
代码实现：
class Solution {
public int maxSales(int[] sales) {
// dp[i] 表示以 i 下标结尾的天数的最大和
int[] dp = new int[sales.length];
dp[0] = sales[0];
for (int i = 1; i < dp.length; i++) {
dp[i] = Math.max(dp[i - 1] + sales[i], sales[i]);
}
int max = Integer.MIN_VALUE;
for (int i = 0; i < dp.length; i++) {
if (dp[i] > max) {
max = dp[i];
}
}
return max;
}
}
66. LCR 165. 解密数字
这道题也可以用动态规划来做，dp[i] 代表以第 i 个数字结尾的字符串有多少种解密方案。
一个数字就代表一个字母，但是这个数字范围是 0-25。
所以根据数字，这个解密方式 dp[i] = dp[i - 1]。当 str[i - 1] 和 str[i] 能够组合数字时(num >= 10 && num <= 25)，则 dp[i] = dp[i - 1] + dp[i - 2] 。
初始化，dp[0] = dp[1] = 1。那这里跟斐波那契问题有点像，就可以定义三个变量 a,b,c 来替代 dp 数组。
代码实现：
class Solution {
public int crackNumber(int ciphertext) {
String str = String.valueOf(ciphertext);
// int[] dp = new int[str.length() + 1];
// dp[i] 表示以第 i 个字符结尾的解密方案数量
int a = 1, b = 1, c = 1;
int len = str.length();
int i = 2;
while (i <= len) {
c = b;
// 如果 str[i - 2] 存在, 则可以组合 str[i - 2]str[i - 1]
String tmp = str.substring(i - 2, i);
if (tmp.compareTo("10") >= 0 && tmp.compareTo("25") <= 0) {
c += a;
}
a = b;
b = c;
i++;
}
return c;
}
}
67. LCR 166. 珠宝的最高价值
可以用动态规划来做，先定义 dp[i][j] 为从 frame[0][0] 到 frame[i][j] 的珠宝最大值，然后再来推断dp[i][j] = ?，到达 dp[i][j] 有两种可能，第一种是从上面来到，第二种是从左边来的。
所以 dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]) + frame[i][j] 。但还要考虑边界情况比如在左上角和在右上角的情况，此时就只有一个方向。最后就是初始化 dp[0][0] = frame[0][0]
代码实现：
class Solution {
public int jewelleryValue(int[][] frame) {
int row = frame.length;
int col = frame[0].length;
int[][] dp = new int[row][col];
dp[0][0] = frame[0][0];
// dp[i][j] 代表到 i，j 的最大珠宝值
// 1 3 1
// 1 5 1
// 4 2 1
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
dp[i][j] = frame[i][j];
if (i - 1 >= 0) {
dp[i][j] = dp[i - 1][j] + frame[i][j];
}
if (j - 1 >= 0) {
dp[i][j] = Math.max(dp[i][j], dp[i][j - 1] + frame[i][j]);
}
}
}
return dp[row - 1][col - 1];
}
}
68. LCR 185. 统计结果概率
这道题，可以去看看大佬的题解。
代码实现：
class Solution {
public double[] statisticsProbability(int num) {
// prev 表示 n - 1 个骰子点数
double[] prev = {1 / 6d, 1 / 6d, 1 / 6d, 1 / 6d, 1 / 6d, 1 / 6d};
for (int i = 2; i <= num; i++) {
// 第 n 个骰子点数
double[] cur = new double[5 * i + 1];
// [n, 6n] -> 5*n + 1
for (int j = 0; j < prev.length; j++) {
// 每个骰子有 6 点
// 第 n 个骰子点数 = 第 n-1 个骰子点数 + 当前骰子点数
for (int k = 0; k < 6; k++) {
cur[j + k] += prev[j] * 1 / 6;
}
}
prev = cur;
}
return prev;
}
}
69. LCR 187. 破冰游戏
约瑟夫环问题，dp[i] = (dp[i -1] + target) % num.
代码实现：
class Solution {
public int iceBreakingGame(int num, int target) {
// 用动态规划
// dp[i] = (dp[i - 1] + target) % num
// dp[i] 表示以 i 个成员为约瑟夫环，最后剩下的成员编号
int dp = 0;
for (int i = 2; i <= num; i++) {
dp = (dp + target) % i;
}
return dp;
}
}
图
70. LCR 129. 字母迷宫
这种找路径的问题，一般用深搜来做，因为图中的每个节点都可能是单词开头，所以需要遍历图，然后对图中的每个节点进行深搜即可。
代码实现：
class Solution {
public boolean wordPuzzle(char[][] grid, String target) {
int row = grid.length;
int col = grid[0].length;
char[] arr = target.toCharArray();
// 遍历图
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
boolean[][] flg = new boolean[row][col];
// 对每个节点进行深搜
if (dfs(grid, flg, i, j, row, col, arr, 0)) {
return true;
}
}
}
return false;
}
public boolean dfs(char[][] arr, boolean[][] flg, int i, int j, int row, int col, char[] target, int k) {
// 越界或者已经访问过或者对应的字符不一致，则返回 false
if (i < 0 || i >= row || j < 0 || j >= col || flg[i][j] || arr[i][j] != target[k]) {
return false;
}
// 标记遍历过
flg[i][j] = true;
if (k == target.length - 1) {
return true;
}
// 往四个方向继续
boolean ans = dfs(arr, flg, i - 1, j, row, col, target, k + 1)
|| dfs(arr, flg, i + 1, j, row, col, target, k + 1)
|| dfs(arr, flg, i, j - 1, row, col, target, k + 1)
|| dfs(arr, flg, i, j + 1, row, col, target, k + 1);
// 回溯
flg[i][j] = false;
return ans;
}
}
71. LCR 130. 衣橱整理
可以用深搜来做。
代码实现：
class Solution {
public int wardrobeFinishing(int m, int n, int cnt) {
boolean[][] flg = new boolean[m][n];
return dfs(m, n, 0, 0, flg, cnt);
}
public int dfs(int m, int n, int i, int j, boolean[][] flg, int cnt) {
// 判断越界以及是否遍历过以及是否符合整理要求
if (i < 0 || i >= m || j < 0 || j >= n || flg[i][j] || (numSum(i) + numSum(j) > cnt)) {
return 0;
}
// 标记一下
flg[i][j] = true;
return dfs(m, n, i, j + 1, flg, cnt) + dfs(m, n, i + 1, j, flg, cnt) + 1;
}
public int numSum(int num) {
int sum = 0;
while (num != 0) {
sum += num % 10;
num /= 10;
}
return sum;
}
}
72. LCR 146. 螺旋遍历二维数组
代码实现：
class Solution {
public int[] spiralArray(int[][] array) {
if (array.length == 0)
return new int[0];
int x1 = 0, y1 = 0;
int x2 = array.length - 1, y2 = array[0].length - 1;
int k = 0;
int[] ret = new int[(x2 + 1) * (y2 + 1)];
while (x1 <= x2 && y1 <= y2) {
// 第一行
for (int i = y1; i <= y2; i++) {
ret[k++] = array[x1][i];
}
// 最后一列
for (int i = x1 + 1; i <= x2; i++) {
ret[k++] = array[i][y2];
}
// 最后一行
if (x1 < x2) {
for (int i = y2 - 1; i >= y1; i--) {
ret[k++] = array[x2][i];
}
}
// 第一列
if (y1 < y2) {
for (int i = x2 - 1; i > x1; i--) {
ret[k++] = array[i][y1];
}
}
x1++;
y1++;
x2--;
y2--;
}
return ret;
}
}
贪心算法
73. LCR 188. 买卖芯片的最佳时机
让你求最大值，第一眼就是两层遍历搞定。
但是还有另一种方法，要想获得利润最大值，一般是低买高卖，低价买入高价卖出，所以我们可以定义一个变量 minPrice 记录股票的最小值，再定义一个 max 来记录最大利润，只要当前股票 - minPrice 比 max 大，max 就更新。最后返回 max 即可。
代码实现：
class Solution {
public int bestTiming(int[] prices) {
int max = 0;
for (int i = 0; i < prices.length - 1; i++) {
for (int j = i + 1; j < prices.length; j++) {
int tmp = prices[j] - prices[i];
if (tmp > max) {
max = tmp;
}
}
}
return max;
}
}
class Solution {
public int bestTiming(int[] prices) {
int max = 0;
// 记录最低股票值
int minPrice = Integer.MAX_VALUE;
// 低买高卖
for (int i = 0; i < prices.length; i++) {
if (prices[i] < minPrice) {
minPrice = prices[i];
}
if (prices[i] - minPrice > max) {
max = prices[i] - minPrice;
}
}
return max;
}
}
找规律
74. LCR 162. 数字 1 的个数
可以去看看大佬的题解。
代码实现：
class Solution {
public int digitOneInNumber(int num) {
int digit = 1, count = 0;
int high = num / 10, cur = num % 10, low = 0;
while (high != 0 || cur != 0) {// 当 cur 和高位都是 0，则说明已经遍历完该数字了
if (cur == 0) {
// 当前位是 0
count += high * digit;
} else if (cur == 1) {
// 当前位是 1
count += high * digit + low + 1;
} else {
count += (high + 1) * digit;
}
// 1 2 3 4
// high cur low
low += cur * digit;
cur = high % 10;// 为 high 的最后一位
high /= 10;
digit *= 10;
}
return count;
}
}
75. LCR 163. 找到第 k 位数字
可以去看看大佬题解。
代码实现：
class Solution {
public int findKthNumber(int k) {
// 几位数
int digit = 1;
// 从哪里开始
long start = 1;
// digit 位数一共有几个
long count = 9;
// 获取第 k 位数 是几位数
while (k > count) {
k -= count;
digit++;
start *= 10;
count = 9 * start * digit;
}
// 确定 k 所在的数字
// start + (k - 1) / digit 用来计算从 start 开始跳过多少个完整的数字
long num = start + (k - 1) / digit;
return Long.toString(num).charAt((k - 1) % digit) - '0';
}
}
