Leetcode贪心算法

455. 分发饼干

小尺寸的饼干先满足小胃口的孩子。

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        if(s.size()==0){
            return 0;
        }
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());

        int ans=0;
        int j=0;
        for(int i=0;i<g.size();){
            if(j==s.size()){
                return ans;
            }
            if(s[j]>=g[i]){
                ans++;
                i++;
                j++;
            }else{
                j++;
            }
        }
        return ans;
    }
};

134. 加油站

首先，如果刚好能够绕一圈，那么对gas-cost中的元素求和后 结果刚好为0，在此前提下，只需要一次遍历就能找到正确的起点（题目说了解唯一）。

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        if (gas.size() == 0) {
            return 0;
        }
        //总油量，当前油量，起点
        int startIndex = 0;
        int current = 0;
        int total = 0;
        for (int i = 0; i < gas.size(); i++) {
            total += gas[i] - cost[i];
            current += gas[i] - cost[i];
            if (current < 0) {
                startIndex = i+1;
                current = 0;
            }
        }
        return (total >= 0) ? startIndex : -1;//等于0时刚好够一圈
    }
};

1005.K次取反后最大化的数组和

class Solution {
public:
    static bool cmp(const int& a, const int& b){
        return abs(a)>abs(b);
    }

    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end(),cmp);//绝对值从大到小
        int sum=0;
        for(int i=0;i<nums.size();i++){
            if(nums[i]<0&&k>0){//尽可能将前面（绝对值更大）的负数取反
                nums[i]=-nums[i];
                k--;
            }
            sum+=nums[i];
        }
        //k%2==0，此时有两种可能，
        //1.nums中仍有负数，但是数组和已经最大，直接返回sum；
        //2.nums所有元素大于等于0，且k>=0，同样直接返回sum。
        //k%2==1的情况，对最后一位元素处理
        if(k%2==1){
            sum-=(2*nums.back());
        }
        return sum;
    }
};

53. 最大子数组和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()==1){
            return nums[0];
        }
        vector<int > dp(nums.size(),0);//记录包含dp[i]在内的最大子数组和。
        dp[0]=nums[0];
        int maxSum=dp[0];
        for(int i=1;i<nums.size();i++){
            dp[i]=max(nums[i],dp[i-1]+nums[i]);//更新分为d[i-1]<=0和>0两种情况
            maxSum=max(maxSum, dp[i]);
        }
        return maxSum;
    }
};

136. 最长连续递增（递减）序列

子序列和子数组定义不一样，子序列不连续，但子数组必须连续，这里连续子序列可以认为是子数组。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int start=0, maxlen=1;
        int n=nums.size();
        for(int i=0;i<n;i++){
            if(i>0&&nums[i-1]>=nums[i]){//找递减序列时，改变大于等于号。
                start=i;
            }
            maxlen=max(maxlen,i-start+1);
        }
        return maxlen;
    }
};

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

class Solution {
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.empty()){
            return 0;
        }
        sort(points.begin(),points.end(),[](const vector<int>& a, vector<int>& b){
            return a[1]<b[1];//按照第二个元素（尾巴）升序排序
        });
        int arrows=1;
        int current_end=points[0][1];
        for(const auto& point:points){
            if(point[0]>current_end){//有无重叠
                arrows++;
                current_end=point[1];
            }
        }
        return arrows;
    }
};

435. 无重叠区间

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        //首尾相接不算重叠
        if(intervals.empty()){
            return 0;
        }
        sort(intervals.begin(),intervals.end(),[](const vector<int>& a, vector<int>& b){
            return a[1]<b[1];
        });
        int minNum=0;
        int current_end=intervals[0][1];
        // for(const auto& interval:intervals){
        for(int i=1;i<intervals.size();i++){    
            if(intervals[i][0]<current_end){//是否重叠
                minNum++;
            }else{
                current_end=intervals[i][1];
            }
        }
        return minNum;
    }
};

676. 盛最多水的容器

class Solution {
public:
    int maxArea(vector<int>& height) {
        if(height.size()<=1){
            return 0;
        }
        int l=0,r=height.size()-1;
        int water=0;
        while(l<r){
            int lower_height=(height[l]<=height[r])?height[l]:height[r];
            if(water<lower_height*(r-l)){
                water=lower_height*(r-l);
            }
            if(height[l]<=height[r]){
                l++;
            }else{
                r--;
            }
        }
        return water;
        // 三目运算符必须要有返回值。
    }
};