训练营第三十三天贪心（第五部分重叠区间问题）

训练营第三十三天贪心（第五部分重叠区间问题）

435.无重叠区间

力扣题目链接

题目

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。
1
2
3

示例 2:

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
1
2
3

示例 3:

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。
1
2
3

提示:

• 1 <= intervals.length <= 105
• intervals[i].length == 2
• -5 * 104 <= starti < endi <= 5 * 104

解答

方法一：自己写的，比较慢

先根据第一个元素进行排序，如果第一个的右区间大于第二个的左区间就说明重叠，如果相等或者小于不算重叠，那么就要移除这两个区间中右边界更大的

局部最优：每次遇到重叠区间就移除右边界更大的

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
		Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
		int count = 0;
		for (int i = 0; i < intervals.length - 1; i++) {
			if (intervals[i][1] > intervals[i + 1][0]){
				count++;
				intervals[i + 1][1] = Math.min(intervals[i][1],intervals[i + 1][1]);
			}
		}
		return count;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

763.划分字母区间

力扣题目链接

题目

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：

输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 
1
2
3
4
5
6

示例 2：

输入：s = "eccbbbbdec"
输出：[10]
1
2

提示：

• 1 <= s.length <= 500
• s 仅由小写英文字母组成

解答

局部最优：当前的范围内能跳到的最远距离，即见上图，第一个元素能跳到8，那么遍历在0到8的范围内的元素能跳到的最大值，那么最终的终点就是当前分割出来的最长字符串

模拟过程

1. a的最大索引为8，索引当前的end为8
2. b的最大索引为5，小于当前的end，不变
3. 依次类推，每次更新end，当end==i时，即达到位置8时，当前的切割字符串已经找到，记录并更新start索引为下一轮的起点
4. 重复1、2、3步骤

class Solution {
    public List<Integer> partitionLabels(String s) {
		List<Integer> results = new ArrayList<>();//存放最后的结果
		int[] mapIndex = new int[26];//相当于map集合，对应26个英文字母的最终索引
        
		for (int i = 0; i < s.length(); i++) {//为每一个元素赋值最远索引
			mapIndex[s.charAt(i) - 'a'] = i;
		}
        
		int end = 0;//每一轮切割的结束索引
		int start = 0;//每一轮切割的第一个元素
		for (int i = 0; i < s.length(); i++) {
			end = Math.max(end,mapIndex[s.charAt(i) - 'a']);//如果大于当前的最大索引，那么就更新
			if (i == end){//如果达到了最终的最大索引，表示这一轮切割完成
				results.add(end - start + 1);
				start = i + 1;//更新下一轮的起点
			}
		}
		return results;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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].
1
2
3

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
1
2
3

提示：

• 1 <= intervals.length <= 104
• intervals[i].length == 2
• 0 <= starti <= endi <= 104

解答

方法一：自己写的

局部最优：左侧最小，右侧最大

class Solution {
    public int[][] merge(int[][] intervals) {
		Arrays.sort(intervals,Comparator.comparingInt(a -> a[0]));
		for (int i = 0; i < intervals.length - 1; i++) {
			if (intervals[i][1] >= intervals[i + 1][0]){
				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]);
				intervals[i] = null;//因为i + 1位置为合并后的，i位置已经没有用了
			}
		}
		
		List<int[]> result = new ArrayList<>();
		for (int[] interval : intervals) {
			if (interval != null)
				result.add(interval);
		}
		return result.toArray(new int[result.size()][]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

方法二（并没有比方法一好）

直接通过移除链表的最后一个元素来达到方法一的目的

class Solution {
    public int[][] merge(int[][] intervals) {
        LinkedList<int[]> res = new LinkedList<>();
        Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[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()][]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

总结

遇到重叠区间的问题即二维数组的重叠区域等问题一定要先固定一头，然后在考虑另一头