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

菜鸟的Zoom之旅

已于 2023-06-15 22:09:43 修改

阅读量89

点赞数

分类专栏：代码随想录刷题训练营文章标签：算法数据结构

于 2023-06-14 22:32:19 首次发布

本文链接：https://blog.csdn.net/weixin_42809675/article/details/131216890

版权

代码随想录刷题训练营专栏收录该内容

51 篇文章 0 订阅

订阅专栏

文章讲述了在力扣平台上的几个编程问题，包括无重叠区间、划分字母区间和合并区间。通过比较和优化算法，如调整射箭问题的判断条件，使用排序和特殊条件判断来减少区间数量，以及利用哈希表记录字符最远位置，解决了区间重叠和字母分组的问题。同时也提出了一个简单的合并区间方法。

摘要由CSDN通过智能技术生成

无重叠区间

题目链接：力扣

本题其实和“用最少数量的箭引爆气球”非常像，弓箭的数量就相当于是非交叉区间的数量，只要把弓箭那道题目代码里射爆气球的判断条件加个等号（认为[0，1][1，2]不是相邻区间），然后用总区间数减去弓箭数量就是要移除的区间数量了。

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {

        if(!intervals.size())
        return 0;

        sort(intervals.begin(),intervals.end(),compare);
        int count = 1;
        
        for(int i=1; i<intervals.size();i++)
        {
            if(intervals[i-1][1] > intervals[i][0])
            {
                intervals[i][1] = min(intervals[i][1], intervals[i-1][1]);
            }
            else if(intervals[i-1][1] <= intervals[i][0])
            {
                count++;
            }
        }
        return intervals.size()-count;

    }


    static bool compare(vector<int>&a, vector<int>&b)
    {
        if(a[0] == b[0])  return a[1]<b[1];
        return a[0] < b[0];
    }
};

划分字母区间

题目链接：力扣

该题与跳跃游戏有点类似。

其中s.rfind() 用于从后向前记录想要查找字母的位置。


    vector<int> partitionLabels(string s) {

        int cur = 0;
        int next = 0;        
        vector<int> Res;

        for(int i=0; i<=s.size(); i++)
        {
            next = max(next, int(s.rfind(s[i])));
            cout<< i << " "<< next << endl;
            
            if(i == next)
            {
                Res.push_back(next-cur+1);
                cur = i+1;
                next = s.rfind(s[i+1]);
            }

        }
        return Res;
    }

卡哥的代码巧妙利用了hash表来记录某一字母最远端的位置

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 left = 0;
        int right = 0;
        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 = i + 1;
            }
        }
        return result;
    }
};

合并区间

题目链接：力扣

这题感觉比较简单，可以模拟出来。

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {    //超时

        if(intervals.size()==1)
        return intervals;

        sort(intervals.begin(),intervals.end(),cmp);
        vector<vector<int>> Res;

        for(int i=1;i<intervals.size();i++)
        {
            if(intervals[i][0] <= intervals[i-1][1])   //说明有重叠
            {
                intervals[i][0] = intervals[i-1][0];
                intervals[i][1] = max(intervals[i][1],intervals[i-1][1]);
            }
            else
                Res.push_back(intervals[i-1]);

            if(i == intervals.size()-1)
                Res.push_back(intervals[i]);                         
        }
        return Res;
    }

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