代码随想录Day36 | 435. 无重叠区间 763.划分字母区间 56. 合并区间

435.无重叠区间

文档讲解：代码随想录
视频讲解： 贪心算法，依然是判断重叠区间 | LeetCode：435.无重叠区间
状态

本质和昨天的射箭差不多，只不过需要注意这次两个区间的左值和右值相同不属于重叠。可以通过先寻找不重叠的区间，然后让总区间数-不重叠区间数就是需要移除的区间

//两个区域 左边界和另一个区域右边界相同不算重叠
class Solution {
public:
    static bool cmp(vector& a,vector& b)
    {
        return a[0]>& intervals) {
        int leave = 1;
        sort(intervals.begin(),intervals.end(),cmp);
        for(int i = 1;i=intervals[i-1][1])
            {
                leave++;
            }
            else
            {
                intervals[i][1] = min(intervals[i][1],intervals[i-1][1]);
            }
        }
        //重叠个数就是总个数-不重叠个数
        return intervals.size()-leave;

    }
};

763.划分字母区间

文档讲解：代码随想录
视频讲解： 贪心算法，寻找最远的出现位置！ LeetCode：763.划分字母区间
状态

我们需要知道每个字母在字符串中出现的最后一个位置，用来当作该字母区间的右边界。
//最多划分，一旦下标i之前出现的字母，在i之后没有出现那么就需要切割出来
//存储每个字母出现的最后下标
//遍历整个字符串
//i+1 < check[s[i]-‘a’] --> 比较check[s[i+1]-‘a’] 和 check[s[i]-‘a’] 取大值
//i+1 >= check[s[i]-‘a’] 分割 更新边界 为check[s[i+1]-‘a’]

class Solution {
public:
    vector partitionLabels(string s) {
        vector check(26,-1);
        for(int i = 0;i res;
        int right = check[s[0]-'a'];
        int left = 0;
        //遍历寻找
        for(int i = 1;i right)
            {
                right = check[s[i]-'a'];
                res.push_back(i-left);
                left = i;
            }
            else
            {
                right= max(right,(check[s[i]-'a']));
            }
            if(right == s.size()-1)
            {
                res.push_back(right+1-left);
                break;
            }
        }
        return res;
    }
};

使用了两个临时变量来存储边界，以作为最后的结果计算。这道题的方法和下面那道题一样的。

56.合并区间

文档讲解：代码随想录
视频讲解： 贪心算法，合并区间有细节！LeetCode：56.合并区间
状态

使用两个临时变量来存储边界，左边界只有在下一个区间的左值大于此时的右边界时才更新，而右边界是需要不断去更新判断的。

//记录left 和 right 
//right 不断更新最大值
//当下一个区间的左值大于right时，更新left为当前左值，right 为当前区间右值
class Solution {
public:
    static bool cmp(vector& a,vector& b)
    {
        return a[0]> 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 right)
            {
                vector temp{left,right};
                left = intervals[i][0];
                right = intervals[i][1];
                res.push_back(temp);
            }
            else
            {
                right = max(right,intervals[i][1]);
            }
        }
        //处理最后一个数组的情况
        res.push_back(vector {left,right});
        return res;
    }
};