贪心算法（二）-优快云博客

本文链接：https://blog.youkuaiyun.com/jmqxnxg/article/details/129660240

文章介绍了如何使用贪心策略解决LeetCode上的非重叠区间问题，提供了两种不同的解题思路。第一种思路是删除可能与未处理区间重合的区间，按左坐标排序并优先保留右坐标小的。第二种思路则是保留不与其他区间重叠且右坐标小的区间。此外，还提供了一道练习题——种花问题，展示了贪心策略的应用，并对比了两种不同的实现方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

3.区间问题

力扣https://leetcode.cn/problems/non-overlapping-intervals/解题思路一：

最直观的想法就是删除重叠的区间，且该区间是更有可能与未处理的区间重合的。

先根据区间左坐标排序，发现重叠的区间后，根据右左标大小删除右左标大的区间。

这里的贪心策略体现在处理每一对重叠区间时，只考虑当下哪个区间更有可能和未处理的区间重合。

代码：

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        int n = intervals.size();
        if(n<2) return 0;
        sort(intervals.begin(), intervals.end(),
        [&](vector<int>& a, vector<int>& b){
            if(a[0]==b[0]) return a[1]<b[1];
            return a[0]<b[0];
        }
        );

        int res = 0;
        vector<int> pre = intervals[0];
        for(int i=1;i<n;i++){
            if(intervals[i][0]>=pre[1]){
                pre = intervals[i];
            }else{
                res++;
                if(intervals[i][1]<pre[1]){
                    pre = intervals[i];
                }
            }
        }
        return res;


    }
};

解题思路二：

另一个思路就是从反面思考，不考虑如何删除区间，而是考虑如何保留尽可能多的区间。

原则是区间右坐标越小，与未处理的区间重叠可能性越低。

贪心策略为保留右左标小且不与其他区间重叠的区间。

注意这里的sort是需要根据右左标大小来排序，与前一个方法的sort不同。

代码：

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        int n = intervals.size();
        if(n<2) return 0;
        sort(intervals.begin(), intervals.end(),
        [&](vector<int>& a, vector<int>& b){
            return a[1]<b[1];
           
        }
        );

        int res = 1;
        vector<int> pre = intervals[0];
        for(int i=1;i<n;i++){
            if(intervals[i][0]>=pre[1]){
                pre = intervals[i];
                res++;
            }
        }
        return n-res;


    }
};

这道题是很明显的贪心策略，只考虑局部（左边和右边是否种花），只要符合条件，就种花。

就是边界条件有点多，写到一半我就意识到了应该在vector前后各加一个哨兵的。

两种写法都放上来了。

解法一：各种加边界条件判断，直至通过所有case。

class Solution {
public:
    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
        if(flowerbed.size()==0) return n==0;
        if(flowerbed.size()==1) return n==0 || (n==1&&flowerbed[0]==0);
        if(flowerbed.size()>=2 && flowerbed[0]==0&&flowerbed[1]==0){
            n--;
            flowerbed[0] = 1;
        }


        for(int i=1;i<flowerbed.size()-1;i++){
            if(flowerbed[i]==0 && flowerbed[i-1]==0&&flowerbed[i+1]==0){
                n--;
                flowerbed[i]=1;
                i++;

            }
        }

        if(flowerbed.size()>2 && flowerbed[flowerbed.size()-1]==0&&flowerbed[flowerbed.size()-2]==0){
            n--;
        }
       
        return n<=0;
    }
};

解法二：vector前后各加一个哨兵，省略掉边界条件判断。缺点是用时比上一个解法长。

class Solution {
public:
    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
       
        flowerbed.insert(flowerbed.begin(),0);
        flowerbed.insert(flowerbed.end(),0);
        for(int i=1;i<flowerbed.size()-1;i++){
            if(flowerbed[i]==0 && flowerbed[i-1]==0&&flowerbed[i+1]==0){
                n--;
                i++;

            }
        }
        return n<=0;
    }
};