55.跳跃游戏

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n = nums.size();

        int maxJump{}; // 记录最大跳跃的距离
        for(int i{};i<n;++i){
            maxJump = max(i+nums[i],maxJump); // 当前能跳跃的最大距离

            if(maxJump >= n-1) return true;// 最大距离能到到达终点，满足条件
            if(maxJump < i+1) return false;// 最大距离无法到达下一点，不符合条件
        }

        return false;
    }
};

45.跳跃游戏II

class Solution {
public:
    int jump(vector<int>& nums) {
        int n = nums.size();
        int maxJumps{};  // 最大的跳跃位置
        int lastJumps{}; // 每一次最大跳跃后的位置
        int result{};
        for(int i{};i<n;++i){
            if(lastJumps >= n-1){
                return result;
            }
            
            maxJumps = max(maxJumps,i + nums[i]); // 记录最大的跳跃位置
            if(lastJumps == i){ // 当贪心到每一次最大跳跃后的位置时，进行再次更新
                result++;
                lastJumps = maxJumps;
            }
        }

        return result;
    }
};

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

class Solution {
public:
    int findMinArrowShots(vector<vector<int>>& points) {
    	// 根据起始x值进行排序
        sort(points.begin(),points.end(),[](auto&&a,auto&&b){
            return a[0] <= b[0];
        });

        int result{1}; // points 不为空至少需要一支箭
        for(int i = 1;i<points.size();++i){
        	// 气球i和气球i-1挨着，更新重叠气球最小右边界
            if(points[i][0] >= points[i-1][0] && points[i][0] <= points[i-1][1]){
                points[i][1] = min(points[i-1][1],points[i][1]);
                continue;
            }
            // 当遇到不重叠的气球了，弓箭数+1
            result++;
        }
        return result;
    }
};

435.无重叠区间

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
    	// 按照右边界进行排序
        sort(intervals.begin(),intervals.end(),[](auto&& a,auto&& b){
            return a[1] < b[1];
        });

        int edge = intervals[0][1];
        int result{1}; // 记录非交叉的区间
        for(int i{};i<intervals.size();++i){
            if(edge <= intervals[i][0]){ // 如果上一次记录的区间右边界小于等于当前的左边界，说明是出现了非交叉的区间
                edge = intervals[i][1];
                result++;
            }
        }
		// 最后用区间总数减去非交叉区间的个数就是需要移除的区间个数
        return intervals.size()-result;
    }
};

763.划分字母区间

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[27]{}; // i为字符，hash[i]为字符出现的最后位置
        for(int i{};i<s.size();++i){ // 统计每一个字符最后出现的位置
            hash[s[i] - 'a'] = i;
        }

        vector<int> result;
        int left{};
        int right{};
        for(int i{};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;
    }
};

56.合并区间

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
    	// 按照左边界排序
        sort(intervals.begin(),intervals.end(),[](auto&&a,auto&&b){
            return a[0] < b[0];
        });

        vector<vector<int>> result;

        bool flag{false}; // 标记最后一个区间有没有合并
        for(int i = 1;i<intervals.size();++i){
           int start = intervals[i-1][0];
           int end = intervals[i-1][1];
           // 合并取最大的右边界
           while(i < intervals.size() && intervals[i][0] <= end){
               end = max(end,intervals[i][1]);
               if(i == intervals.size() -1) flag = true;
               i++;
           }   
           result.push_back({start,end}); 
        }

        if(flag == false){
            result.push_back(intervals.back());
        }

        return result;
    }
};