区间问题： 这类面试题目还挺讨巧的，因为不需要掌握什么数据结构与算法的先验知识，看懂题目之后模拟一遍即可，很容易考察出应聘者到底会不会写代码。
文章目录
56. 合并区间
1. 题目描述
leetcode题目链接：56. 合并区间
2. 思路分析
- 首先对区间按照起始端点进行升序排序，
- 然后逐个判断当前区间是否与前一个区间重叠，如果不重叠的话将当前区间直接加入结果集，反之如果重叠的话，就将当前区间与前一个区间进行合并。
3. 参考代码
class Solution {
public int[][] merge(int[][] intervals) {
Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
int n = intervals.length;
int[][] res = new int[n][2];
int index = -1;
for (int[] interval : intervals) {
if (index == -1 || interval[0] > res[index][1]) {
// 结果数组为空或者当前数组的起始值大于结果数组的结尾值，说明不重叠
res[++index] = interval;
} else {
// 反之重叠，合并结果
res[index][1] = Math.max(res[index][1], interval[1]);
}
}
return Arrays.copyOf(res, index + 1);
}
}
968. 区间列表的交集
1. 题目描述
leetcode题目链接：986. 区间列表的交集
2. 思路分析
双指针模拟两个数组的左右端点。
3. 参考代码
class Solution {
public int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
int m = firstList.length, n = secondList.length;
List<int[]> res = new ArrayList<>();
int i = 0, j = 0;
while (i < m && j < n) {
int left = Math.max(firstList[i][0], secondList[j][0]);
int right = Math.min(firstList[i][1], secondList[j][1]);
if (left <= right) {
res.add(new int[]{left, right});
}
if (firstList[i][1] < secondList[j][1]) {
i++;
} else {
j++;
}
}
return res.toArray(new int[res.size()][]);
}
}
57. 插入区间
1. 题目描述
leetcode题目链接：57. 插入区间
2. 思路分析
本题中的区间已经按照起始端点升序排列，因此我们直接遍历区间列表，寻找新区间的插入位置即可。 具体步骤如下：
- 首先将新区间左边且相离的区间加入结果集（遍历时，如果当前区间的结束位置小于新区间的开始位置，说明当前区间在新区间的左边且相离）；
- 接着判断当前区间是否与新区间重叠，重叠的话就进行合并，直到遍历到当前区间在新区间的右边且相离，将最终合并后的新区间加入结果集；
- 最后将新区间右边且相离的区间加入结果集。
3. 参考代码
class Solution {
public int[][] insert(int[][] intervals, int[] newInterval) {
int n = intervals.length;
int[][] res = new int[n + 1][2];
int index = 0;
int i = 0; // intervals的索引
// 首先将新区间左边且相离的区间加入结果集
while (i < n && intervals[i][1] < newInterval[0]) {
res[index++] = intervals[i++];
}
// 接着判断当前区间是否与新区间重叠，重叠的话就进行合并，直到遍历到当前区间在新区间的右边且相离
while (i < n && intervals[i][0] <= newInterval[1]) {
newInterval[0] = Math.min(intervals[i][0], newInterval[0]);
newInterval[1] = Math.max(intervals[i][1], newInterval[1]);
i++;
}
res[index++] = newInterval;
// 最后将新区间右边且相离的区间加入结果集
while (i < n) {
res[index++] = intervals[i++];
}
return Arrays.copyOf(res, index);
}
}
1288. 删除被覆盖区间
1. 题目描述
leetcode题目链接：1288. 删除被覆盖区间
2. 思路分析
这道题的一个比较妙的处理方法就是对起点进行升序排序，如果起点相同，则对终点进行降序排序。
一个区间被另一个区间覆盖，如果我们只按照起点排序，则我们就不知道是哪个区间覆盖哪个区间，因此，我们还需要对终点进行排序。
如果两个区间起点相同，则将终点较大的放在前面。
这样，我们就能更好的实现解析。
之后的实现：
起点相同的只保留第一个，不同的，要判断末端点和上一个的大小比较。
只需要判断右端点是否在上一个最大范围内即可，因为左端点不用判断，肯定在前边的范围内。
3. 参考代码
class Solution {
public int removeCoveredIntervals(int[][] intervals) {
int n = intervals.length;
// 起点升序，终点降序
Arrays.sort(intervals, (v1, v2) -> v1[0] == v2[0] ? v2[1] - v1[1] : v1[0] - v2[0]);
int count = n;
//起点相同的只保留第一个，不同的，要判断末端点和上一个的大小比较
//只需要判断右端点是否在上一个最大范围内即可，因为左端点不用判断，肯定在前边的范围内
int tmp = intervals[0][1];
for (int i = 1; i < n; i++) {
if (intervals[i][0] == intervals[i - 1][0] || intervals[i][1] <= tmp) {
count--;
} else {
tmp = intervals[i][1];
}
}
return count;
}
}
228. 汇总区间
1. 题目描述
leetcode题目链接：228. 汇总区间
2. 思路分析
本题是在有序数组中，找出连续递增的区间。
- 可以通过模拟操作进行实现，判断下一个元素和当前元素是否连续。使用
StringBuilder来判断是否连续。 - 也可以使用双指针来进行求解。
3. 参考代码
class Solution {
public List<String> summaryRanges(int[] nums) {
List<String> res = new ArrayList<>();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < nums.length; i++) {
if (!(i + 1 < nums.length && nums[i] == nums[i + 1] - 1)) {
if (sb.length() > 0) sb.append("->");
sb.append(nums[i]);
res.add(sb.toString());
sb = new StringBuilder();
} else {
if (sb.length() == 0) sb.append(nums[i]);
}
}
return res;
}
}
双指针：
class Solution {
public List<String> summaryRanges(int[] nums) {
List<String> res = new ArrayList<>();
for (int i = 0, j = 0; j < nums.length; j++) {
if (j + 1 < nums.length && nums[j + 1] == nums[j] + 1) {
continue;
}
if (i == j) {
res.add(nums[i] + "");
} else {
res.add(nums[i] + "->" + nums[j]);
}
i = j + 1;
}
return res;
}
}
354. 俄罗斯套娃信封问题
1. 题目描述
leetcode题目链接：354. 俄罗斯套娃信封问题
2. 思路分析
看到这道题，可能会联想到最长递增子序列问题，只不过这道题是二维的。想办法转化为一维问题，就是排序。排序后就可以使用动态规划来解决一维最长递增子序列的方法了。
-
首先对整个数组按照宽度由小到大
排序，排序同时，对于宽度相同的项，根据高度由大到小排序。（如果高度按从小到大，对于形如
[4,4]和[4,5]的两项，由于[4,4]排序在[4,5]之前，这就导致仅考虑h时，我们认为[4,4]和[4,5]可以构成一组“套娃”。但是按照“二维严格升序”的定义，两个矩形的宽相等，不属于严格升序。为了规避上述的问题，我们对宽度相等的两个矩形，使用高度降序排序，这样一来，上述问题的排列将变成：[4,5],[4,4]。在我们计算最长上升子序列时，由于 5>4，也就不会出现“错误套娃”。） -
然后就是
动态规划来计算信封的最大套娃数。
dp[i] 表示仅使用信封 [0,i] (这里是区间的意思，表示前 i+1 个信封)，且以第 i 个信封为顶端信封时的最大高度。
- 当
envelopes[j][1]>envelopes[i][1]时：认为信封 j严格大于信封 i，此时尝试更新dp[i] : dp[i] = max(dp[i], dp[j] + 1) - 当信封 j 不严格大于信封 i 时：跳过。
但这样的时间复杂度是O(n^2)，因此需要优化。
在搜索插入位置的时候，可以使用二分法查找优化到 O(logN)。
3. 参考代码
方法一：排序+动态规划
class Solution {
public int maxEnvelopes(int[][] envelopes) {
int n = envelopes.length;
Arrays.sort(envelopes, (a, b) -> (a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]));
int[] dp = new int[n];
Arrays.fill(dp, 1); // 初始化为1，表示当前信封
int max = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (envelopes[i][1] > envelopes[j][1]) {
dp[i] = Math.max(dp[i], dp[j] + 1);
}
}
max = Math.max(dp[i], max);
}
return max;
}
}
结果提交超时。
方法二：排序+动态规划+二分查找
class Solution {
public int maxEnvelopes(int[][] envelopes) {
int n = envelopes.length;
Arrays.sort(envelopes, (a, b) -> (a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]));
int[] dp = new int[n];
Arrays.fill(dp, 1); // 初始化为1，表示当前信封
int max = 0;
// 二分查找
for (int[] env : envelopes) {
int left = 0, right = max;
while (left < right) {
int mid = (right - left) / 2 + left;
if (dp[mid] < env[1]) { // 要找的是dp数组中第一个小于当前h的位置
left = mid + 1;
} else {
right = mid;
}
}
dp[left] = env[1];
if (left == max) {
max++;
}
}
return max;
}
}
参考：
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
