随想录一刷Day36——贪心算法

Day36_贪心算法

18. 无重叠区间

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) {
        int int_size = intervals.size();
        if (int_size == 0) return 0;
        sort(intervals.begin(), intervals.end(), cmp);
        int cnt = 1;
        int last_right = intervals[0][1];
        for (int i = 1; i < int_size; ++i) {
            if (intervals[i][0] >= last_right) {
                last_right = intervals[i][1];
                cnt++;
            }
        }
        return int_size - cnt;
    }
};

19. 划分字母区间

763. 划分字母区间
思路：

统计每个字母出现的最后位置，遍历字符串的过程中，统计当前划分区域中字符的最右位置，如果移动到最右位置时，还没有加入位置更靠右的字母，则把当前这部分字母作为一个划分。

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int s_len = s.length();
        vector<int> ret;
        if (s_len == 0) return ret;

        int statis_char[26];
        memset(statis_char, 0, sizeof(statis_char));

        for (int i = 0; i < s_len; ++i) { // 统计每个字母出现的最靠右的下标
            statis_char[s[i] - 'a'] = i;
        }

        int right_edge = statis_char[s[0] - 'a']; // 初始化划分右边界为第一个字母的右边界
        int start_pos = 0;
        for (int i = 0; i < s_len; ++i) {
            right_edge = max(right_edge, statis_char[s[i] - 'a']);
            if (right_edge == i) {
                ret.push_back(i - start_pos + 1);
                start_pos = i + 1;
            }
        }
        return ret;
    }
};

20. 合并区间

56. 合并区间

将所有区间按照左边界排序，从左向右遍历区间，
向结果中加入第一个区间，如果新加入的结果区间右边界大于等于遍历到的区间的左边界，则可合并，更新结果区间的右边界
如果新加入的区间右边界小于遍历到的区间的左边界，则将该区间加入结果区间继续向右合并

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        int mem_size = intervals.size();
        vector<vector<int>> ans;
        if (mem_size == 0) return ans;
        
        // 按左边界排序
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[0] < b[0];});
        ans.push_back({intervals[0][0], intervals[0][1]});
        for (int i = 0; i < mem_size; ++i) {
            if (ans.back()[1] >= intervals[i][0]) { // 合并区间，更新区间右边界
                ans.back()[1] = max(ans.back()[1], intervals[i][1]);
            } else { // 添加一个新区间
                ans.push_back(intervals[i]);
            }
        }
        return ans;
    }
};