代码随想录算法训练营刷题复习6 ：贪心算法2/2

每天努力进步！

已于 2024-06-20 20:51:28 修改

阅读量415

点赞数 4

分类专栏： leetcode刷题文章标签：算法贪心算法 leetcode c++

于 2024-06-20 00:07:30 首次发布

本文链接：https://blog.csdn.net/cir_sky/article/details/139800875

版权

leetcode刷题专栏收录该内容

49 篇文章 0 订阅

订阅专栏

贪心算法

860. 柠檬水找零
406. 根据身高重建队列
452. 用最少数量的箭引爆气球
435. 无重叠区间
按照区间的左界对区间进行升序排序（如遇到相同的值，则按照第二个值小的在前）
如果当前区间的左界大于等于已处理过的区间右界（right_index变量存储这个值），则对right_index值进行更新
否则：需要移除一个区间，保留区间右界小的那个（以尽可能少的移除区间）
763. 划分字母区间
56. 合并区间
738. 单调递增的数字
968. 监控二叉树 没写出来重点复习
二叉树+贪心，主要还是分析好遍历二叉树的过程中的对节点的处理逻辑，详细过程在下面。

860. 柠檬水找零

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

    }
};

406. 根据身高重建队列

class Solution {
public:
    //按照身高排序——二维数组的排序问题
    static bool cmp(vector<int>& a,vector<int>& b) {
        if(a[0]==b[0]) return a[1]<b[1];
        return a[0]>b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(),people.end(),cmp);
        //排好序后，按照第二列的位置信息在对应位置插入
        vector<vector<int>> que;
        for(int i=0;i<people.size();i++) {
            int position = people[i][1];
            que.insert(que.begin()+position, people[i]);
        }
        return que;
    }
};

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

class Solution {
public:
//所有区间按照第一个值的大小 进行升序排序
    static bool cmp(vector<int>& a,vector<int>& b) {
        return a[0]<b[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.size()==0)
            return 0;
        sort(points.begin(),points.end(),cmp);
        int res = 1;
        for(int i=1;i<points.size();i++) {
            //如果当前区间的左界大于上一个区间的右界，说明无法合并在一起，需要重新使用一只箭
            if(points[i][0] > points[i-1][1]) {
                res++;
            }
            //否则，更新当前区间的右界（缩小范围，以两个区间的最小值右界为准，方便下一步操作）
            else {
                points[i][1] = min(points[i-1][1], points[i][1]);
            }
        }
        return res;
    }
};

435. 无重叠区间
按照区间的左界对区间进行升序排序（如遇到相同的值，则按照第二个值小的在前）
如果当前区间的左界大于等于已处理过的区间右界（right_index变量存储这个值），则对right_index值进行更新
否则：需要移除一个区间，保留区间右界小的那个（以尽可能少的移除区间）

class Solution {
public:
    static bool cmp(vector<int>& a, 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 res = 0;
        int right_index = intervals[0][1];
        for(int i=1;i<intervals.size();i++) {
            if(intervals[i][0] >= right_index) {
                right_index = intervals[i][1];
            } else {
                res++;
                right_index = min(right_index, intervals[i][1]);
                continue;
            }
        }
        return res;
    }
};

763. 划分字母区间

class Solution {
public:
    vector<int> partitionLabels(string s) {
        vector<int> hash(27);
        vector<int> res;
        for(int i=0;i<s.size();i++) {
            hash[s[i]-'a']=i;
        }
        int left = 0;
        int right = 0;
        for(int i=0;i<s.size();i++) {
            right = max(right,hash[s[i]-'a']);
            if(i==right) {
                res.push_back(right-left+1);
                left=i+1;
            }
        }
        return res;
    }
};

56. 合并区间

class Solution {
public:
    static bool cmp(vector<int>&a, 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) {
        if(intervals.size()<=1)
            return intervals;
        vector<vector<int>> res;
        sort(intervals.begin(),intervals.end(),cmp);
        res.push_back(intervals[0]);//二维数组  一次性赋值a[0] = {a[0][0],a[0][1]}
        for(int i=0;i<intervals.size();i++) {
            if(intervals[i][0] <= res.back()[1]) {
                //这里对区间右界的修改！！！！   还是没记住怎么写
                res.back()[1] = max(intervals[i][1],res.back()[1]);
            }
            else {
                res.push_back(intervals[i]);
            }
        }
        return res;
    }
};

738. 单调递增的数字

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        //①数字转字符串
        string strNum = to_string(n);
        //标记开始写9的位置下标
        int flag = strNum.size();
        //逆序处理
        for(int i=strNum.size()-1;i>0;i--) {
            //如果前一个值比当前值大的话，不满足递增，前一值--，当前值记录下来需要改为9
            if(strNum[i-1] > strNum[i]) {
                flag = i;
                strNum[i-1]--;
            }

        }
        for(int i=flag;i<strNum.size();i++) {
            strNum[i]='9';
        }
        //字符串转整型stoi
        return stoi(strNum);
    }
};

968. 监控二叉树

判断逻辑：
1.二叉树的遍历——递归后序遍历

2.叶子节点不做处理，从叶子节点的父节点处放置摄像头

3.遍历函数traversal的目的是返回节点的状态：
判断逻辑：0状态表示未做处理；1表示当前节点放摄像头；2表示当前节点在摄像头覆盖范围内
当前节点cur ，通过判断左右孩的状态来决定是否放摄像头：
左、右孩至少有一个为0——>当前放置摄像头标记为1；
左右孩都为2 ——> 当前节点标记为 0 ；
其他——>当前节点标记为2；在摄像头覆盖范围内；

4.需要额外的变量result来存储结果，在设置为1的时候result++;’
在minCameraCover函数中，调用函数返回头结点的状态，需多加一步判断是否对头结点放置摄像头。

/**
 * 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 {
private:
    int result;
    int traversal(TreeNode* cur) {
//0表示未作处理；1表示当前节点为摄像头； 2表示当前节点在摄像头覆盖范围
        
        //从叶子节点开始处理，摄像头不能放在叶子节点层，放在叶子结点的父节点才能最有效利用

        //如果当前节点为空，标记为2
        if(cur==NULL) {
            return 2;
        }
        //递归处理左右节点
        int left = traversal(cur->left);
        int right = traversal(cur->right);

        //这里可以看作，若左右都为2 即左右都为空，当前节点标记为0
        if(left==2 && right==2) {
            return 0;
        }
        //若左右孩子节点都是0，说明找到孩子节点的父节点，标记为一个摄像头，并返回1
        if(left==0 || right==0) {
            result++;
            return 1;
        }
        if(left==1 || right==1){
            return 2;
        }
        return -1;
    }
public:
    int minCameraCover(TreeNode* root) {
        result=0;
        //判断头结点的状态
        if(traversal(root)==0)
            result++;
        return result;
    }
};