leetcode之数组类之区间类-----OJ 56/57/435/239 重叠区间个数 合并区间 插入区间 滑动窗口最大值

区间类问题考察的是：对于区间的排序的运用

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;
    }
};

3、OJ57 insert intervals

已给定不重叠的区间集合，现在需要插入一个新区间，求插入后且不重叠的结果

如当前区间集合为[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;
    }
};