代码随想录训练营第三十六天| ● 435. 无重叠区间 ● 763.划分字母区间 ● 56. 合并区间

435. 无重叠区间

代码随想录

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

这道题要求最小的移除区间数量，也就是求重合区间的数量。

首先按照左边界进行排序，之后进行遍历操作，使用当前元素的左边界与前一个元素的右边界进行比较，若边界重合了，就像当前元素的右边界修改成这两个边界的最小右边界值（相当于移除了一个更小的重合边界），同时将result++。之后进行下一次遍历，继续寻找重合边界。

但上面是我的方法，在力扣中数据量最大的一个测试中会超时！

思考发现，是我在排序的时候没有使用const vector<int>& a，而使用的是值复制的方法进行比较，这样每次都需要将数组中的值重新复制一遍，导致运行速度变慢，改为常引用变量就可通过时间了。

 763.划分字母区间

代码随想录

vector<int> partitionLabels(string s) {
        vector<int> result;
        int hash[27] = {0}; // i为字符，hash[i]为字符出现的最后位置
        for (int i = 0; i < s.size(); i++) {
            hash[s[i] - 'a'] = i;
        }
        int left = 0, right = 0;        //记录左右边界
        for (int i = 0; i < s.size(); i++) {
            right = max(right, hash[s[i] - 'a']);
            if (right == i) {
                result.push_back(right-left+1);
                left = i + 1;
            }
        }
        return result;
    }

 这道题只能说做过了就能做出来，没做过很难想到思路。

首先先建立哈希表，将字符串中每个相同元素的最远的下标记录在哈希数组当中。之后进行遍历，在遍历的过程中，有一个左边界一个右边界，右边界随哈希数组的值进行更新，当右边界和索引相等时，说明已经到达了当前搜索区域的最右边界，就应该将当前边界记录至结果之中了，然后更新左边界继续遍历。

可以总结为如下两步：

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

 56. 合并区间

代码随想录

class Solution {
static bool cmp(const vector<int>& a, const vector<int>& b) {
    return a[0] < b[0];
}
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> result;
        sort(intervals.begin(), intervals.end());
        int left = intervals[0][0], right = intervals[0][1];
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals[i][0] > right) {
                vector<int> range{left, right};
                result.push_back(range);
                left = intervals[i][0];
                right = intervals[i][1];
            }
            else {
                right = max(right, intervals[i][1]);
            }
        }
        vector<int> range{left, right};
        result.push_back(range);     //将最后一个区间放入结果之中
        return result;
    }
};

 这是我的代码，首先进行左边界的排序，然后初始化两个左右边界，在遍历的过程中进行边界判断，若当前元素的左边界大于现有右边界，说明边界不存在重合，因此要将当前边界加入结果之中，然后根据当前元素更新左右边界；若当前元素的左边界小于等于现有右边界，说明边界存在重合，要更新当前的右边界了，取当前右边界和当前元素右边界中最大的那一个当做合并区间的右边界即可。在遍历完最后一个区间后，再将最后一个边界加入结果中即可。

vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> result;
        if (intervals.size() == 0) return result; // 区间集合为空直接返回
        // 排序的参数使用了lambda表达式
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[0] < b[0];});

        // 第一个区间就可以放进结果集里，后面如果重叠，在result上直接合并
        result.push_back(intervals[0]); 

        for (int i = 1; i < intervals.size(); i++) {
            if (result.back()[1] >= intervals[i][0]) { // 发现重叠区间
                // 合并区间，只更新右边界就好，因为result.back()的左边界一定是最小值，因为我们按照左边界排序的
                result.back()[1] = max(result.back()[1], intervals[i][1]); 
            } else {
                result.push_back(intervals[i]); // 区间不重叠 
            }
        }
        return result;
    }

示例代码是通过对结果数组最后一个元素（也就是当前区间的右边界）来进行对重叠边界的合并操作。思路大体一致。