代码随想录算法训练营第三十九天 | LeetCode 435、763、56

---

前言

LeetCode题目：LeetCode 435、763、56
Takeaway：贪心算法，今天的题都是重叠区间问题。

---

一、435

贪心策略：先按右边界排序, 右边界小的在最前面，这样后面留的空间多。之后统计不重叠的节点的数量，总的剪掉不重叠的就是答案了。

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 ans = 1; // 记录非交叉区间的个数
        int end = intervals[0][1]; // 记录区间分割点

        // 在已经排序好的
        for(int i=1; i<intervals.size(); i++) {

            //当前结尾在下一个节点之前
            if(end <= intervals[i][0]){

                //新的结尾
                end = intervals[i][1];

                //不重叠区域+1
                ans++;
            }
        }
        //总结点 - 不重叠节点 = 重叠的节点
        return intervals.size() - ans;
    }
};

---

二、763

第一次遍历后，统计每个字母出现的最后面的位置在哪。第二次遍历发现当前位置等于前面节点中，最远的那个节点的最后位置时，完成分割。

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[27] = {0}; // i为字符，hash[i]为字符出现的最后位置
        for (int i = 0; i < s.size(); i++) { // 统计每一个字符最后出现的位置
            hash[s[i] - 'a'] = i;
        }
        vector<int> result;

        int curMax = 0;
        int left = 0;
        for (int i = 0; i < s.size(); i++) {
            curMax = max(hash[s[i]-'a'], curMax);
            if(i >= curMax){
                result.push_back(curMax-left+1);
                left = i+1;
            }
        }

        return result;
    }
};

---

三、56

合并区间问题，还是先排序，排序之后合并区间。

class Solution {
public:
    static bool cmp (const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    }

    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> result;
        if (intervals.size() == 0) 
            return result;
        sort(intervals.begin(), intervals.end(), cmp);
        bool flag = false;

        for(int i=1; i<intervals.size(); i++){
            int start = intervals[i - 1][0];    // 初始为i-1区间的左边界
            int end = intervals[i - 1][1];      // 初始i-1区间的右边界
            while (i < intervals.size() && intervals[i][0] <= end) { // 合并区间
                end = max(end, intervals[i][1]);    // 不断更新右区间
                if (i == intervals.size() - 1) 
                    flag = true;   // 最后一个区间也合并了
                i++;     // 继续合并下一个区间
            }
            // start和end是表示intervals[i - 1]的左边界右边界，所以最优intervals[i]区间是否合并了要标记一下
            result.push_back({start, end});
        }

        if (flag == false) {
            result.push_back({intervals[intervals.size() - 1][0], intervals[intervals.size() - 1][1]});
        }

        return result;
    }
};

---

总结

贪心算法，今天的题都是重叠区间问题。