代码随想录32 贪心算法 leetcode452.用最少数量的箭引爆气球-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_74096700/article/details/145399834

leetcode452.用最少数量的箭引爆气球

leetcode452.用最少数量的箭引爆气球

有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend，且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量 没有限制 。弓箭一旦被射出之后，可以无限地前进。

给你一个数组 points ，返回引爆所有气球所必须射出的最小弓箭数 。

注意点：

在于如果当前气球的起始点大于上一个箭覆盖的结束位置，则需要一支新的箭。但是上一个箭的结束位置是取最小的覆盖位置！

class Solution {
public:
    static bool cmp(const vector<int>& a, const vector<int>& b) {
    if (a[0] == b[0]) {
        return a[1] < b[1];  // 如果第一个元素相同，按第二个元素升序排序
    }
    return a[0] < b[0];  // 否则按第一个元素升序排序
}
    
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.size()==0) return 0;
        sort(points.begin(),points.end(),cmp);  
        int count=1;
        for(int i=1;i<points.size();i++){
            if(points[i][0]<=points[i-1][1]){
                points[i][1]=min(points[i][1],points[i-1][1]);
            }
            else{
                count++;
            }
        }
        return count;
    }

};

下面那道题和这个很相似

leetcode435.无重叠区间

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

注意只在一点上接触的区间是 不重叠的。例如 [1, 2] 和 [2, 3] 是不重叠的。

示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

class Solution {
public:
 static bool cmp(const vector<int>& a, const vector<int>& b) {
    if (a[0] == b[0]) {
        return a[1] < b[1];  // 如果第一个元素相同，按第二个元素升序排序
    }
    return a[0] < b[0];  // 否则按第一个元素升序排序
}

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

leetcode763.划分字母区间

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：

输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。

思路:

1. 问题转换

每个字母在字符串中的出现可以看作一个区间：

每个字母的区间是它的首次出现位置和最后出现位置之间。

2. 贪心策略

用贪心的思想解决这个区间划分问题：

我们从左到右遍历字符串，动态维护一个当前的区间。
每次遇到一个字母时，更新当前区间的结束位置 end，使其包含当前字母的最后出现位置。
如果当前索引 i 恰好等于 end，说明当前区间结束，可以划分出一个片段。

class Solution {
public:
    vector<int> partitionLabels(string s) {
        // 1. 记录每个字母的最后出现位置
        unordered_map<char, int> lastIndex;
        for (int i = 0; i < s.size(); i++) {
            lastIndex[s[i]] = i;  // 更新字母的最后出现位置
        }

        // 2. 遍历字符串，划分片段
        vector<int> result;
        int start = 0, end = 0;  // 当前片段的起始和结束位置
        for (int i = 0; i < s.size(); i++) {
            end = max(end, lastIndex[s[i]]);  // 更新当前片段的结束位置
            if (i == end) {  // 当前片段完成
                result.push_back(end - start + 1);  // 记录片段长度
                start = i + 1;  // 更新下一片段的起始位置
            }
        }

        return result;  // 返回所有片段的长度
    }
};

56.合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

思路：

这个思路和无重叠区间那道题很像，我是根据那个改的

class Solution {
public:
  static bool cmp(const vector<int>& a, const 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) {
        vector<vector<int>> result;
        if (intervals.empty()) return result; // 空区间处理

        sort(intervals.begin(), intervals.end(), cmp); // 按照结束位置排序
        
        // 初始化第一个区间
        result.push_back(intervals[0]);

        for (int i = 1; i < intervals.size(); i++) {
            // 如果当前区间与上一个区间有重叠，合并
            if (result.back()[1] >= intervals[i][0]){
                // 更新合并后的区间的结束位置
                result.back()[1] = max(result.back()[1], intervals[i][1]);
            } else {
                // 没有重叠，添加新区间
                result.push_back(intervals[i]);
            }
        }

        return result;
    }
};