区间类问题考察的是:对于区间的排序的运用
OJ239不是区间相关题,但是有近似的场景和思路,故一起描述
1、OJ435 Non-overlapping intervals
给定一些区间,里边有重叠的情况,求最少删除几个,剩下的区间不会再重叠
如给定[1,2],[2,3],[3,4],[1,3],删除[1,3]后不会再重叠,当然删除掉[1,2]和[2,3],也不会重叠,但删除了2个,所以应该删除[1,3]
因为有删除最少个数的要求,所以本题很重要的思路是:
1、重叠了的两个区间,肯定要删除一个
2、删除哪一个?删除范围更大的那一个
明确这个需求后,再说明区间的排序,区间的排序非常简单,重载区间的运算符重载函数,比较方法是:比较起点大小;
对于发生重叠的两个区间(判断依据是:两个区间的首尾是否重叠),累加删除次数,同时保留范围更小的那个区间
具体的步骤:
1、区间做排序
2、第0个区间作为基准区间cur
3、依次做比较,比较是否重叠,如果没有重叠,无需任何删除,基准区间cur改为当前这个区间
如果有重叠,删除计数加1,同时比较两个区间谁的范围更大(尾巴拉的更长),选范围小的作为基准区间cur
OJ435代码:
class Solution {
public:
static bool cmp (const Interval &a, const Interval &b) {
return a.start < b.start;
}
int eraseOverlapIntervals(vector<Interval>& intervals) {
if (intervals.empty()) {
return 0;
}
int cnt = 0;
sort(intervals.begin(), intervals.end(), cmp);
Interval cur = intervals[0];
for (int i = 1; i < intervals.size(); i++) {
if (cur.end > intervals[i].start) {
++cnt;
if (cur.end > intervals[i].end) {
cur = intervals[i];
}
} else {
cur = intervals[i];
}
}
return cnt;
}
};
2、OJ56 merge intervals
合并区间,如给定[1,3],[2,5],[7,8],合并后结果为:[1,5],[7,8]
有了第一题的基础,此题思路和步骤为:
1、区间做排序
2、选第0个区间为基准区间cur
3、依次做比较,如果基准区间后边的区间和基准区间无重叠:选后边这个区间做基准区间cur,并把之前的区间插入结果集合
有重叠:扩大当前基准区间的尾巴,即合并掉了后边的区间,不插入结果集合,继续接下来的循环
循环后,别忘了加入最终的基准区间cur
OJ56代码:
class Solution {
public:
static bool cmp (const Interval &a, const Interval &b) {
return a.start < b.start;
}
vector<Interval> merge(vector<Interval>& intervals) {
vector<Interval> res;
if (intervals.empty()) {
return res;
}
sort(intervals.begin(), intervals.end(), cmp);
Interval cur = intervals[0];
for (int i = 1; i < intervals.size(); i++) {
if (cur.end < intervals[i].start) {
res.push_back(cur);
cur = intervals[i];
} else {
cur.end = std::max(cur.end, intervals[i].end);
}
}
res.push_back(cur);
return res;
}
};
已给定不重叠的区间集合,现在需要插入一个新区间,求插入后且不重叠的结果
如当前区间集合为[1,3],[5,7],插入[2,4],结果为:[1,4],[5,7]
本题其实还是区间相关,基本是OJ56合并区间的扩展,只不过思路可能容易乱;
合理思路是:整理出原区间集合中,和待插入区间有重叠的区间是哪些区间,把重叠部分的真实首尾确定好;然后在原区间集合内,删除这些有重叠的区间,并插入新的区间(以确定好的真实首尾);
如[1,3],[4,5],[6,10],[12,17],[20,21],待插入的是[7,18],那么和待插入区间有重叠的是[6,10]和[12,17],这两个区间与待插入区间[7,18]合并后的新区间的首尾是[6,18];那么现在就在原区间集合中,删除[6,10]和[12,17],再加入[7,18]即可得到结果[1,3],[4,5],[7,18],[20,21]
步骤:
1、原区间集合做排序
2、遍历排序后原区间集合,只要发现重叠时就更新首尾(min(待插入的首,第一个重叠时的首),max(待插入的尾,最后一个重叠的尾));
记录从哪开始重叠的(待插入的首 > 当前区间的尾),从哪重叠结束的(待插入的尾 <= 当前区间的首)
3、循环做2直到不再重叠(或遍历结束)为止
4、利用第2步记录的重叠起始区间,在原区间集合中,删除全部与待插入区间有重叠的区间,并插入新的区间(由更新好的首尾确定的区间)
OJ57代码:
class Solution {
public:
static bool cmp (const Interval &a, const Interval &b) {
return a.start < b.start;
}
vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
if (intervals.empty()) {
intervals.push_back(newInterval);
return intervals;
}
sort(intervals.begin(), intervals.end(), cmp);
int ed = 0, overlap_num = 0;
for (; ed < intervals.size(); ed++) {
if (intervals[ed].start > newInterval.end) {
break;
} else if (intervals[ed].end < newInterval.start) {
continue;
} else {
newInterval.start = std::min(newInterval.start, intervals[ed].start);
newInterval.end = std::max(newInterval.end, intervals[ed].end);
++overlap_num;
}
}
if (overlap_num) {
intervals.erase(intervals.begin() + ed - overlap_num, intervals.begin() + ed);
}
intervals.insert(intervals.begin() + ed - overlap_num, newInterval);
return intervals;
}
};
4、OJ239 sliding window maximum
Window position Max --------------- ----- [1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3 6 7 5 1 3 -1 [-3 5 3] 6 7 5 1 3 -1 -3 [5 3 6] 7 6 1 3 -1 -3 5 [3 6 7] 7如给定数组,同时给定滑动窗口大小k,如k=3,求数组每个滑动窗口内数据的最大值,如上图;
本题和区间类没什么关系,没有相同解题思路,但是属于同一类场景的题;
我的可AC方法是使用deque,确保deque头部为大值且不过时,每次插入时,pop掉比当前值小的元素,保证小值一直被当前值更新掉;
步骤:
1、先单独做第一轮,保证deque头部为最大值
2、然后进入循环,每次取得上一轮的最大值,然后pop掉过时元素,再push当前元素,如1一样保证deque内不存在比当前元素小的元素
3、直到全部窗口遍历完毕
OJ239代码:
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
std::vector<int> res;
if (nums.empty()) {
return res;
}
//第一个窗口, 数据进入方向永远是后入, deque的尾部去掉小于当前值的值
//这是保证deque的头部是最大的值, 供pop取窗口最大值
deque<int> dq;
for (size_t i = 0; i < k; i++) {
while (!dq.empty() && nums[dq.back()] < nums[i]) {
dq.pop_back();
}
dq.push_back(i);
}
//每次取得上一个窗口的最大值, 然后从前边pop掉过时的值, 然后继续做插入, 插入要保证头部是大值(pop掉比当前小的元素, 直到不再比当前小再插入)
//保证当前轮次的最大值不会算错
for (size_t i = k; i < nums.size(); i++) {
res.push_back(nums[dq.front()]);
while (!dq.empty() && dq.front() < i - k + 1) {
dq.pop_front();
}
while (!dq.empty() && nums[dq.back()] < nums[i]) {
dq.pop_back();
}
dq.push_back(i);
}
res.push_back(nums[dq.front()]);
return res;
}
};