[LeetCode] 56. 合并区间
[LeetCode] 56. 合并区间 文章解释[LeetCode] 56. 合并区间 视频解释
题目:
以数组
intervals
表示若干个区间的集合,其中单个区间为intervals[i] = [starti, endi]
。请你合并所有重叠的区间,并返回 一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间 。示例 1:
输入:intervals = [[1,3],[2,6],[8,10],[15,18]] 输出:[[1,6],[8,10],[15,18]] 解释:区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].示例 2:
输入:intervals = [[1,4],[4,5]] 输出:[[1,5]] 解释:区间 [1,4] 和 [4,5] 可被视为重叠区间。提示:
1 <= intervals.length <= 10^4
intervals[i].length == 2
0 <= starti <= endi <= 10^4
按照边界排序,从头往后遍历列表,如果当前节点和处理完重叠的到的区间依旧有重叠, 则继续合并并扩大区间。 直到当前节点和区间不重叠,则保存一次结果。
和第一想法差不多。
class Solution {
public int[][] merge(int[][] intervals) {
Arrays.sort(intervals, new Comparator() {
@Override
public int compare(int[] a, int[] b) {
return a[0] - b[0];
}
});
LinkedList result = new LinkedList<>();
for (int i = 1; i < intervals.length; i++) {
if (intervals[i][0] <= intervals[i - 1][1]) {
intervals[i][0] = intervals[i - 1][0];
intervals[i][1] = Math.max(intervals[i][1], intervals[i - 1][1]);
} else {
result.add(intervals[i - 1]);
}
}
result.add(intervals[intervals.length - 1]);
return result.toArray(new int[result.size()][2]);
}
}
无。
[LeetCode] 738. 单调递增的数字
[LeetCode] 738. 单调递增的数字 文章解释[LeetCode] 738. 单调递增的数字 视频解释
题目:
当且仅当每个相邻位数上的数字
x
和y
满足x <= y
时,我们称这个整数是单调递增的。给定一个整数
n
,返回 小于或等于n
的最大数字,且数字呈 单调递增 。示例 1:
输入: n = 10 输出: 9示例 2:
输入: n = 1234 输出: 1234示例 3:
输入: n = 332 输出: 299提示:
0 <= n <= 10^9
从最低位开始往前比, 如果地位比高位小的话, 高位 -1, 地位变成9. Duang-》 100 的时候出现异常了。最右边的零没有比从右往左数第二位的0小, 因此不处理。 从右往左数第二个0比1小, 因此变成9, 1变成0.最后得到结果90, 期望值99。
然后想说, 如果遇到1变为0, 那就要把1后面的都变成9,但是要怎么变呢?这里可以思考一下, 当1变为0时,为了数字最大, 1后面的一定要变成9,当1后面的数字变成9,9后面的数字要不小于9,因此就全部是9了。这里脑子就已经转偏了, 一直想着处理100时, 当1变成0的时候有问题。
然而其实只要出现高位-1的情况,低位为了最大值都应该变成9. 这样这一题就特别简单了。
豁然开朗,真的是又简单又直接。
class Solution {
public int monotoneIncreasingDigits(int n) {
// 这里的小巧思真妙,一开始思考怎么分割数字还耗费了不少时间。
int nineStart = -1;
char[] chars = new String(n + "").toCharArray();
for (int i = chars.length - 2; i >= 0; i--) {
if (chars[i] - '0' > chars[i + 1] - '0') {
chars[i]--;
nineStart = i + 1;
}
}
for (int i = nineStart; i >= 0 && i < chars.length; i++) {
chars[i] = '9';
}
return Integer.parseInt(new String(chars));
}
}
无。
[LeetCode] 968. 监控二叉树
[LeetCode] 968. 监控二叉树 文章解释
[LeetCode] 968. 监控二叉树 视频解释
题目:
给定一个二叉树,我们在树的节点上安装摄像头。
节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。
计算监控树的所有节点所需的最小摄像头数量。
示例 1:
输入:[0,0,null,0,0] 输出:1 解释:如图所示,一台摄像头足以监控所有节点。示例 2:
输入:[0,0,null,0,null,0,null,null,0] 输出:2 解释:需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。
提示:
- 给定树的节点数的范围是
[1, 1000]
。- 每个节点的值都是 0。
不就是递归一下吗, 一个 traversal(root, !needCamera) 函数就可以了, 为什么说是困难呢?
提交后才发现需要最小的摄像头数量。
难倒是不难, 重要的是想法。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
// 0 无覆盖 1 有摄像头 2 有覆盖
// 无覆盖 无覆盖 -》 有摄像头 0 0 -〉1
// 无覆盖 有摄像头 -》 有摄像头 0 1 -〉1
// 无覆盖 有覆盖 -》 有摄像头 0 2 -〉1
// 有摄像头 无覆盖 -》 有摄像头 1 0 -〉1
// 有摄像头 有摄像头 -》 有覆盖 1 1 -〉2
// 有摄像头 有覆盖 -》 有覆盖 1 2 -〉2
// 有覆盖 无覆盖 -》有摄像头 2 0 -〉1
// 有覆盖 有摄像头 -》 有覆盖 2 1 -〉2
// 有覆盖 有覆盖 -》无覆盖 2 2 -〉0
// 综上,有1不一定为2,但是当排除掉有0一定为1后,剩余的有1就一定为2
// 因此可以得出状态推倒公式:0 || 0 -》1 1||1 =〉2 2&&2 =》0
int count = 0;
public int minCameraCover(TreeNode root) {
int childState = traversal(root);
if (childState == 0) {
count++;
}
return count;
}
private int traversal(TreeNode node) {
// 这里很关键,空节点要赋值为有覆盖。无覆盖和有摄像头都会导致叶子结点状态异常。
// 空节点为无覆盖, 叶子结点就需要有摄像头。
// 空节点为有摄像头,叶子结点的福节点就变成无覆盖。而实际这时候叶子结点就变为无覆盖了。ERROR。
if (node == null) {
return 2;
}
int left = traversal(node.left);
int right = traversal(node.right);
if (left == 0 || right == 0) {
count++;
return 1;
} else if (left == 1 || right == 1) {
return 2;
} else {
return 0;
}
}
}
想不出来, 根本想不出来。 这一题关键不在于实现有难度, 而在于思路,在于状态推导公式这个思路根本想不到。