代码随想录算法训练营第三十六天|LeetCode435 无重叠区间、LeetCode763 划分字母区间、LeetCode56 合并区间

435.无重叠区间

思路：先按左坐标从小到大的顺序排列区间，判断当前区间与上一个区间是否重叠，如果重叠，计数++，将当前右坐标替换成，这两个区间最小的右坐标（默认删除右坐标长的那个区间，因为右坐标越大越可能对下一个区间重叠），依次判断。

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

763.划分字母区间

思路：利用hash记录字母出现的最大坐标，遍历字母，更新最大坐标end，如果循环的i==end，则将当前区间放入result，继续搜索后续区间。

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[26] = {0};
        for(int i = 0;i<s.size();i++)
        {
            hash[s[i]-'a'] = i ;
        }
        int left = 0;
        int right =0;
        vector<int> result;
        for(int i =0;i<s.size();i++)
        {
            right = max(right,hash[s[i]-'a']);
            if(i==right)
            {
                result.push_back(right-left+1);
                left = right+1;
            }
        }
        return result;

    }
};

56.合并区间

思路：对区间按左坐标从小到大排序，如果当前区间的左坐标小于等于上一个区间的右坐标，说明重叠，需要更新right，如果不重叠，把区间放入result，同时更新left，right，当遍历最后一个区间时，把区间放入result。

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

    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end(),cmp);
        int left = intervals[0][0];
        int right = intervals[0][1];
        vector<int> path;
        vector<vector<int>> result;
        if(intervals.size()==1)
        {
            return intervals;
        }
        for(int i = 1;i<intervals.size();i++)
        {
            if(intervals[i][0]<=right)
            {
                right = max(right,intervals[i][1]);
            }
            else
            {
                path.push_back(left);
                path.push_back(right);
                result.push_back(path);
                path.pop_back();
                path.pop_back();
                left = intervals[i][0];
                right = intervals[i][1];
            }
            if(i==intervals.size()-1)
            {
                path.push_back(left);
                path.push_back(right);
                result.push_back(path);
                path.pop_back();
                path.pop_back();
            }
        }
        return result;
    }
};

思路：排序区间，直接把intervals放进result，如果重叠更新result.back[1]，如果不重叠，直接把区间放入result。

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

收获：

对区间处理的问题，排序很重要，排序之后再考虑什么情况下放入result，或者更新边界。