目录
56. 合并区间
判断重叠区间问题,与452和435是一个套路
方法1:fff
看方法2:fff优化版
- 使用
currentInterval
来追踪当前合并的区间,而不是在原数组上修改值。 - 每当找到一个不重叠的区间时,将
currentInterval
添加到result
,并开始一个新的currentInterval
。
class Solution {
public int[][] merge(int[][] intervals) {
// 方法1:fff
// if (intervals.length == 1){
// return intervals;
// }
// Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));
// int[][] result = new int[intervals.length][];
// int row = 0;
// for (int i = 0; i < intervals.length - 1; i++) {
// if (intervals[i + 1][0] <= intervals[i][1]){
// intervals[i + 1][0] = Math.min(intervals[i][0],intervals[i + 1][0]);
// intervals[i + 1][1] = Math.max(intervals[i][1],intervals[i + 1][1]);
// } else {
// result[row++] = intervals[i];
// }
// }
// result[row] = intervals[intervals.length - 1];
// int[][] res = new int[row+1][];
// int i = 0;
// for (int[] r : result){
// if (r == null){
// break;
// }
// res[i++] = r;
// }
// return res;
// 方法2:fff优化版
if (intervals.length == 1){
return intervals;
}
// 排序的时间复杂度是O(n log n), n是intervals数组的长度。
Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));
List<int[]> result = new LinkedList<>();
int[] currentInterval = intervals[0]; // 使用currentInterval来追踪当前合并的区间,而不是在原数组上修改值。
for (int i = 1; i < intervals.length ; i++) {
if (intervals[i][0] <= currentInterval[1]){
// 合并
currentInterval[1] = Math.max(currentInterval[1], intervals[i][1]);
} else {
result.add(currentInterval);
currentInterval = intervals[i];
}
}
result.add(currentInterval);
return result.toArray(new int[result.size()][]);
}
}
方法3:
看方法2或者3都可以,复杂度是一样的。都挺好的。
- 代码结构:方法3实现直接使用
LinkedList<int[]>
的getLast()
和removeLast()
来获取和更新最后一个合并区间,代码更加简洁且避免了在原数组上修改数据。 - 操作顺序:方法3实现中,每次更新最后一个区间的值时,先移除再添加,这样减少了代码复杂性;而方法2实现会在原数组上更新,代码稍显繁琐。
class Solution {
public int[][] merge(int[][] intervals) {
//方法3:
LinkedList<int[]> res = new LinkedList<>();
Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
res.add(intervals[0]);
for (int i = 1; i < intervals.length; i++) {
if (intervals[i][0] <= res.getLast()[1]) {
int start = res.getLast()[0];
int end = Math.max(intervals[i][1], res.getLast()[1]);
res.removeLast();
res.add(new int[]{start, end});
} else {
res.add(intervals[i]);
}
}
return res.toArray(new int[res.size()][]);
}
}
738.单调递增的数字
思路:
例如98,一旦出现strNum[i - 1] > strNum[i]的情况(非单调递增),首先想让strNum[i - 1]减一,strNum[i]赋值9,这样这个整数就是89。
并且需要注意:用一个flag来标记从哪里开始赋值9。后面的都要赋值9。
遍历顺序:从后向前遍历
从前向后遍历的话,遇到strNum[i - 1] > strNum[i]的情况,让strNum[i - 1]减一,但此时如果strNum[i - 1]减一了,可能又小于strNum[i - 2]。
这么说有点抽象,举个例子,数字:332,从前向后遍历的话,那么就把变成了329,此时2又小于了第一位的3了,真正的结果应该是299。
那么从后向前遍历,就可以重复利用上次比较得出的结果了,从后向前遍历332的数值变化为:332 -> 329 -> 299
class Solution {
public int monotoneIncreasingDigits(int n) {
if (n < 10) {
return n;
}
String str = n + "";
char[] ch = str.toCharArray();
int index = ch.length;
for (int i = ch.length - 1; i > 0; i--) {
if (ch[i] < ch[i-1]) {
index = i;
ch[index-1]--;
}
}
for (int i = index; i < ch.length; i++) {
ch[i] = '9';
}
String res = new String(ch);
return Integer.parseInt(res);
}
}
968.监控二叉树(贪心+二叉树)
思路:
摄像头可以覆盖上中下三层,如果把摄像头放在叶子节点上,就浪费的一层的覆盖。
所以把摄像头放在叶子节点的父节点位置,才能充分利用摄像头的覆盖面积。
那么有同学可能问了,为什么不从头结点开始看起呢,为啥要从叶子节点看呢?
因为头结点放不放摄像头也就省下一个摄像头, 叶子节点放不放摄像头省下了的摄像头数量是指数阶别的。
所以我们要从下往上看,局部最优:让叶子节点的父节点安摄像头,所用摄像头最少,整体最优:全部摄像头数量所用最少!
大体思路就是从低到上,先给叶子节点父节点放个摄像头,然后隔两个节点放一个摄像头,直至到二叉树头结点。
此时这道题目还有两个难点:
- 二叉树的遍历 (后序遍历)
- 如何隔两个节点放一个摄像头
- 如何隔两个节点放一个摄像头
此时需要状态转移的公式,大家不要和动态的状态转移公式混到一起,本题状态转移没有择优的过程,就是单纯的状态转移!
来看看这个状态应该如何转移,先来看看每个节点可能有几种状态,分别有三个数字来表示:
- 0:该节点无覆盖
- 1:本节点有摄像头
- 2:本节点有覆盖
(空节点的状态只能是有覆盖,这样就可以在叶子节点的父节点放摄像头了)
- 单层逻辑处理。
主要有如下四类情况:
- 情况1:左右节点都有覆盖
左孩子有覆盖,右孩子有覆盖,那么此时中间节点应该就是无覆盖的状态了。
- 情况2:左右节点至少有一个无覆盖的情况
此时摄像头的数量要加一,并且return 1,代表中间节点放摄像头。
- 情况3:左右节点至少有一个有摄像头
如果是以下情况,其实就是 左右孩子节点有一个有摄像头了,那么其父节点就应该是2(覆盖的状态)
- left == 1 && right == 2 左节点有摄像头,右节点有覆盖
- left == 2 && right == 1 左节点有覆盖,右节点有摄像头
- left == 1 && right == 1 左右节点都有摄像头
- 情况4:头结点没有覆盖
以上都处理完了,递归结束之后,可能头结点 还有一个无覆盖的情况,如图:
所以递归结束之后,还要判断根节点,如果没有覆盖,result++
class Solution {
int res = 0;
public int minCameraCover(TreeNode root) {
// 对根节点的状态做检验,防止根节点是无覆盖状态
if (minCame2(root) == 0) {
res++;
}
return res;
}
/**
* 节点的状态值:
* 0 表示 无覆盖
* 1 表示 有摄像头
* 2 表示 有覆盖
* 后序遍历,根据左右节点的情况,来判读 自己的状态
*/
// 流程清晰版
public int minCame(TreeNode root) {
if (root == null) {
// 空节点默认为 有覆盖状态,避免在叶子节点上放摄像头
return 2;
}
int left = minCame(root.left);
int right = minCame(root.right);
//中,逻辑处理
// 如果左右节点都覆盖了的话, 那么本节点的状态就应该是无覆盖,没有摄像头
if (left == 2 && right == 2) {
return 0;
} else if (left == 0 || right == 0) {
// 左右节点是无覆盖状态,那 根节点此时应该放一个摄像头
res++;
return 1;
} else {
//左右节点至少存在 1个摄像头,那么本节点就是处于被覆盖状态
return 2;
}
}
// 简化分支版本
public int minCame2(TreeNode root) {
if (root == null) {
return 2;
}
int left = minCame2(root.left);
int right = minCame2(root.right);
// 有任意一个子节点为无覆盖,就需要当前节点放相机
if (left == 0 || right == 0) {
res++;
return 1;
}
if (left == 2 && right == 2) { // 左右子树都是有覆盖,那么此时返回无覆盖
return 0;
}
return 2; // 剩下情况就是左右子树有可能为 1 有摄像头,即当前节点被监控
}
}
第三十一天的总算是结束了,直冲Day32!