代码随想录算法训练营第36天| 435. 无重叠区间 、763.划分字母区间 、56. 合并区间

代码随想录算法训练营第36天| 435. 无重叠区间 、763.划分字母区间 、56. 合并区间

435.无重叠区间

按照有边界进行排序，从左到右记录非交叉区的个数，最后用区间的总数减去非交叉区的个数就是需要移除区间的个数。

class Solution {
public:
    static bool cmp(const vector& a, const vector& b) {
        return a[1] < b[1];
    }
    int eraseOverlapIntervals(vector>& 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;
    }
};

如果是使用左边界排序，可以用来求重叠区间的个数。

class Solution {
public:
    static bool cmp(const vector& a, const vector& b) {
        return a[0] < b[0];
    }
    int getOverlapNum(vecotr>& intervals) {
        if (intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), cmp);
        int count = 0; // 初始值为0，重叠区间
        int end = intervals[0][1]; // 记录右边界
        for (int i = 1; i < intervals.size(); ++i) {
            // 无重叠情况
            if (end <= intervals[i][0]) {
                end = intervals[i][1];
            } else {
                end = min(end, intervals[i][1]);
                ++count;
            }
        }
        return count;
    }
};

763.划分字母区间

在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。

可以分为如下两步：

• 统计每一个字符最后出现的位置

• 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点

class Solution {
public:
    vector partitionLabels(string s) {
        vector hash(26, 0);
        // 记录每个字符最后出现的位置
        for (int i = 0; i < s.size(); ++i) {
            hash[s[i] - 'a'] = i;
        }
        vector res;
        int left = 0, right = 0;
        for (int i = 0; i < s.size(); ++i) {
            // 在更新字符串的同时，也在更新字符串中字符最远出现的位置
            right = max(right, hash[s[i] - 'a']);
            if (i == right) {
                // [right, left] 区间的长度就是 right - left + 1
                res.push_back(right - left + 1);
                left = i + 1;
            }
        }
        return res;
    }
};

56. 合并区间

我的思路：按照左边界进行排序，从小到大。如果当前记录的右边界值大于等于当前区间的左边界值，就说明存在区间重叠现象，可以放大区间，将当前的右边界放大为当前区间的有边界和当前右边界的最大值。

class Solution {
public:
    static bool cmp(const vector& a, const vector& b) {
        if (a[0] == b[0]) return a[1] < b[1];
        return a[0] < b[0];
    }
    vector> merge(vector>& intervals) {
       sort(intervals.begin(), intervals.end(), cmp);
        int left = intervals[0][0];
        int right = intervals[0][1];
        vector> res;
        for (int i = 1; i < intervals.size(); ++i) {
            // 有重叠，放大区间
            if (right >= intervals[i][0]) {
                right = max(right, intervals[i][1]);
            } else {
                // 无重叠
                vector pair;
                pair.push_back(left);
                pair.push_back(right);
                res.push_back(pair);
                left = intervals[i][0];
                right = intervals[i][1];
            }
        }
        // 压入最后一个区间
        vector pair;
        pair.push_back(left);
        pair.push_back(right);
        res.push_back(pair);
        return res;
    }
};

不过代码不怎么优雅，就是压入res这个操作重复了。直接在res上更新值，就比较优雅了。

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