算法训练营day36

贪心算法以来久违的写了笔记，因为重叠区间相对来说还是比较有规律的

题目部分

435.无重叠区间

可以使用左右边界排序两种方法，每种排序还可以使用计算重叠区间和计算无重叠区间两种

class Solution {
public:
    static bool cmp (const vector<int>& a, const vector<int>& b) {
        if(a[0]==b[0])return a[1]<b[1];
        return a[0] < b[0]; // 改为左边界排序
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), cmp);
        int count = 0; 
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals[i][0] < intervals[i-1][1]) { //重叠情况
                intervals[i][1] = min(intervals[i][1],intervals[i-1][1]);
                count++;
            }
        }
        return count;
    }
};

class Solution {
public:
    static bool cmp (const vector<int>& a, const vector<int>& b) {
        if(a[0]==b[0])return a[1]<b[1];
        return a[0] < b[0]; // 改为左边界排序
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), cmp);
        int count = 1; 
        int end = intervals[0][1];
        for (int i = 1; i < intervals.size(); i++) {
            if (end <= intervals[i][0]) { //无重叠情况
                end = intervals[i][1];
                count++;
            }else{
                end = min(end,intervals[i][1]);
            }
        }
        return intervals.size()-count;
    }
};

上面两种都是左边界排序，需要注意的是左边界排序需要注意第二三个都跟第一个重叠但是第二三个不重叠的情况，也就是要更新min边界

class Solution {
public:
    // 按照区间右边界排序
    static bool cmp (const vector<int>& a, const vector<int>& b) {
        return a[1] < b[1];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), cmp);
        int count = 0; // 记录非交叉区间的个数
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals[i][0] < intervals[i-1][1]) {
                intervals[i][1] = min(intervals[i-1][1],intervals[i][1]);
                count++;
            }
        }
        return count;
    }
};

class Solution {
public:
    // 按照区间右边界排序
    static bool cmp (const vector<int>& a, const vector<int>& b) {
        return a[1] < b[1];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), cmp);
        int count = 1; // 记录非交叉区间的个数
        int end = intervals[0][1]; // 记录区间分割点
        for (int i = 1; i < intervals.size(); i++) {
            if (end <= intervals[i][0]) {
                end = intervals[i][1];
                count++;
            }
        }
        return intervals.size() - count;
    }
};

右边界排序的直接记录交叉区间的方法和左边界排序基本一样，需要更新min，但是记录非交叉区间的个数的话不需要记录min，因为不可能发生第二三个都跟第一个重叠但是第二三个不重叠的情况，第三个只要跟第一个重叠，就一定跟第二个重叠，因为右边界是有序的。这点比较特殊

763.划分字母区间

主要是要想到用哈希表记录最远字母位置作为边界条件

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[27]{};
        for(int i=0;i<s.size();i++){
            hash[s[i]-'a']=i;
        }
        int left = 0,right =0;
        int length;
        vector<int> result;
        for(int i=0;i<s.size();i++){
            right = max(right,hash[s[i]-'a']);
            if(i==right){
                length = right-left+1;
                result.push_back(length);
                left=i+1;
            }
        }
        return result;
    }
};

56.合并区间

实际上不难，但是一开始犹豫了怎么在原来数组处理，在新数组里操作就容易多了

class Solution {
    static bool cmp(vector<int> a,vector<int> b){
        return a[0]<b[0];
    }
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end(),cmp);
        result.push_back(intervals[0]);
        for(int i=1;i<intervals.size();i++){
            if(intervals[i][0]<=result.back()[1]){
                result.back()[1]=max(result.back()[1],intervals[i][1]);
            }else{
                result.push_back(intervals[i]);
            }
        }
        return result;
    }
private:
    vector<vector<int>> result;
};