[代码随想录]贪心算法

贪心算法

455. 分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int sum = 0;
        for(int i = 0,j = 0;i < g.size() && j < s.size();j++){
            if(s[j] >= g[i]){
                sum++,i++;
            }
        }
        return sum;
    }
};

367. 有效的完全平方数

给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。

不能使用任何内置的库函数，如 sqrt 。

class Solution {
public:
    bool isPerfectSquare(int num) {
        int left = 0,right = num;
        while(left <= right){
            long long mid = (left + right) / 2;
            if(mid * mid == num){
                return true;
            }else if(mid * mid > num){
                right = mid -1;
            }else{
                left = mid +1;
            }
        }
        return false;
    }
};

53. 最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

1

class Solution {
public:
    int max(int one,int two){
        if(one > two){
            return one;
        }
        else{
            return two;
        }
    }
    int maxSubArray(vector<int>& nums) {
        bool flag = 0;//首先把前面负数排除，其次中间如果累加变成负数也是flag=0
        int sum = nums[0] ,max = sum;
        for(int i = 1;i < nums.size();i++){
            if(sum <= 0 && flag == 0 && nums[i] <= 0){
                sum = this->max(nums[i],sum);
                continue;
            }
            flag = 1;
            if(sum <= 0)sum = 0;
            sum += nums[i];
            max = this->max(sum,max);
            if(sum <= 0){
                flag = 0;
            }
        }
        max = this->max(max,sum);
        return max;
    }
};

2

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int>dp(nums.size() + 1,0);
        int mymax = INT_MIN;
        for(int i = 0;i < nums.size();i++){
            dp[i + 1] = max(nums[i] + dp[i],nums[i]);
            mymax = max(mymax,dp[i + 1]);
        }
        return mymax;
    }
};

55. 跳跃游戏

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

class Solution {
public:
//直接i+num值
    bool canJump(vector<int>& nums) {
        if(find(nums.begin(),nums.end(),0) == nums.end())return true;
        if(nums.size() <= 1)return true;
        int k = 0;
        for(int i = 0;i < nums.size();i++){
            if(i > k)return false;
            k = max(k,i + nums[i]);
        }
        return true;
    }
};

45. 跳跃游戏 II

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

• 0 <= j <= nums[i]
• i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

class Solution {
public:
    int jump(vector<int>& nums) {
        int sum = 0;
        if(nums.size() == 1)return sum;
        int k = 0;
        int right = nums.size() - 1;
        for(int i = 0;i < right;i++){
            k = max(k,i + nums[i]);
            if(k >= right){
                sum++;
                right = i;
                i = -1;
                k = 0;
            }
        }
        return sum;
    }
};

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

给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：

• 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。

重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

以这种方式修改数组后，返回数组 可能的最大和 。

class Solution {
public:
    int sum(vector<int>&nums){
        int sum = 0;
        for(int i = 0;i < nums.size();i++){
            sum += nums[i];
        }
        return sum;
    }
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end());
        if(nums[0] >= 0){
            nums[0] *= pow(-1,k);
            return sum(nums);
        }
        int i = 0;
        for(;i < k && nums[i] < 0 && i < nums.size();i++){
            nums[i] *= (-1);
        }
        if(k - i > 0){
            sort(nums.begin(),nums.end());
            nums[0] *= pow(-1,k - i);
        }
        return sum(nums);
    }
};

134. 加油站

在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。

class Solution {
public:
//暴力算法太慢，经常时间超出
    int sum(vector<int>&num){
        int sum = 0;
        for(int i = 0;i < num.size();i++){
            sum += num[i];
        }
        return sum;
    }
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        vector<int>cha(0,gas.size());
        if(gas.size() == 1 && gas[0] - cost[0] >= 0)return 0;
        for(int i = 0;i < gas.size();i++){
            cha.push_back(gas[i] - cost[i]) ;
        }
        int sums = sum(cha);
        int sum = 0;
        int start = 0;
        if(sums < 0)return -1;
        else {
            for(int i = 0;i < cha.size();i++){
                sum += cha[i];
                if(sum < 0){
                    start = i + 1;
                    sum = 0;
                }
            }
            return start;
        }
        return -1;
    }
};

135. 分发糖果

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

• 每个孩子至少分配到 1 个糖果。
• 相邻两个孩子评分更高的孩子会获得更多的糖果。

请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int>num(ratings.size(),1);//每个人糖果数量
        for(int i = 1;i < ratings.size();i++){
            if(ratings[i] > ratings[i - 1]){
                num[i] = num[i - 1] + 1;
            }
        }
        for(int i = ratings.size() - 2;i >= 0;i--){
            if(ratings[i] > ratings[i + 1] && num[i] < (num[i + 1] + 1)){
                num[i] = num[i + 1] + 1;
            }
        }
        int sum = 0;
        for(int i = 0;i < ratings.size();i++){
            sum += num[i];
        }
        return sum;
    }
};

860.柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int num5 = 0;//5元数量
        int num10 = 0;//10元
        for(int i = 0;i < bills.size();i++){
            if(bills[i] == 5){
                num5++;
            }
           else if(bills[i] == 10){
               if(num5 > 0){
                   num5--;
                   num10++;
               }
               else{
                   return false;
               }
           }
           else{
               if(num5 > 0 && num10 > 0){
                   num10--;
                   num5--;
                   continue;
               }
               else if(num5 >= 3){
                   num5 = num5 - 3;
               }
               else{
                   return false;
               }
           }
        }
        return true;
    }
};

*406. 根据身高重建队列

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

class Solution {
public:
    //从高到低先排序，后面来插队**
    //通过链表更快
    static bool my_cmp(vector<int>v1,vector<int>v2){
        if(v1[0] == v2[0])return v1[1] < v2[1];
        return v1[0] > v2[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        vector<vector<int>>queue;
        sort(people.begin(),people.end(),this->my_cmp);
        if(people.size() == 1)return people;
        for(int i = 0;i < people.size();i++){
            queue.insert(queue.begin() + people[i][1],people[i]);//太巧妙l
        }
        return queue;
    }
};

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

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

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

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

1

class Solution {
private:
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    }
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if (points.size() == 0) return 0;
        sort(points.begin(), points.end(), cmp);

        int result = 1; // points 不为空至少需要一支箭
        for (int i = 1; i < points.size(); i++) {
            if (points[i][0] > points[i - 1][1]) {  // 气球i和气球i-1不挨着，注意这里不是>=
                result++; // 需要一支箭
            }
            else {  // 气球i和气球i-1挨着
                points[i][1] = min(points[i - 1][1], points[i][1]); // 更新重叠气球最小右边界
            }
        }
        return result;
    }
};

2

class Solution {
public:
    static bool cmp(vector<int>&v1,vector<int>&v2){
        if(v1[0] == v2[0])return v1[1] < v2[1];
        return v1[0] < v2[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        sort(points.begin(),points.end(),cmp);
        int start = points[0][0];
        int end = points[0][1];
        int sum = 1;
        for(int i = 1;i < points.size();i++){
            start = points[i][0];
            if(points[i][0] <= end){
                
                end = min(end,points[i][1]);
                continue;
            }
            end = points[i][1];
            sum++;
        }
        return sum;
    }
};

435. 无重叠区间

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

class Solution {
public:
    static bool cmp(vector<int>&v1,vector<int>&v2){
        if(v1[0] == v2[0])return v1[1] < v2[1];
        return v1[0] < v2[0];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size() == 1)return 0;
        sort(intervals.begin(),intervals.end(),cmp);
        int sum = 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]);
                sum++;
            }           
        }
        return sum;
    }
};

763.划分字母区间

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

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

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

class Solution {
public:
    vector<int> partitionLabels(string s) {
        vector<int>v;
        int sum = 1;
        int start = 0;
        for(int i = 0;i < s.size();i++){//也可以跟代码随想录一样自己造一个最后出现位置
            if(sum == 1 && s.find_last_of(s[i]) < i + 1){
                v.push_back(1);
                start = i + 1;
            }
            else if(sum == 1 && s.find_last_of(s[i]) >= i + 1){
                sum += s.find_last_of(s[i]);
            }
            else if(sum != 1 && s.find_last_of(s[i]) >= sum && i < sum - 1){
                sum += (s.find_last_of(s[i]) - sum + 1);
            }
            else if(i == sum - 1){
                int val = sum - start;
                v.push_back(val);
                sum = 1;
                start = i + 1;
            }
        }
        return v;
    }
};

56. 合并区间

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

class Solution {
public:
    static bool cmp(vector<int>&v1,vector<int>&v2){
        if(v1[0] == v2[0])return v1[1] < v2[1];
        return v1[0] < v2[0];
    }
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> merge;
        vector<int>v = {-1,-1};
        if(intervals.size() == 1)return intervals;
        sort(intervals.begin(),intervals.end(),cmp);
        v[0] = intervals[0][0];
        for(int i = 1;i < intervals.size();i++){
            if(intervals[i][0] > intervals[i - 1][1]){
                v[1] = intervals[i - 1][1];
                merge.push_back(v);
                 v[0] = intervals[i][0];
            }
            else intervals[i][1] = max(intervals[i - 1][1],intervals[i][1]);
        }
        v[1] = intervals[intervals.size() - 1][1];
        merge.push_back(v);
        return merge;
    }
};

738.单调递增的数字

当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。

给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        if(n < 20 && n != 10)return n;
        if(n == 10)return 9;
        vector<int>v;
        while(n){
            v.push_back(n % 10);
            n /= 10;
        }
        int j = -1;
        for(int i = 0;i < v.size() - 1;i++){
            if(v[i] < v[i + 1]){
               j = i;
               v[i + 1]--;
            }
        }
        int sum = 0;
        for(int i = 0;i < v.size();i++){
            if(i <= j){
                sum += 9 * pow(10,i);
            }
            else sum += v[i] * pow(10,i);
        }
        return sum;
    }
};

*968. 监控二叉树

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    // 0：什么都没有
    // 1：被覆盖
    // 2：有摄像头

    //看代码随想录的
public:
    int travel(TreeNode* root,int &sum){
        if(root == nullptr)return 1;
        int left = travel(root->left,sum);
        int right = travel(root->right,sum);

        if(left == 1 && right == 1){
            return 0;
        }
        
        if(left == 0 || right == 0){
            sum++;
            return 2;
        }

        if(left == 2 || right == 2){
            return 1;
        }
        return 0;
    }

    int minCameraCover(TreeNode* root) {
        int sum = 0;
        if(travel(root,sum) == 0){
            sum++;
        }
        return sum;
    }
};