代码随想录 第八章 贪心算法 part05 56. 合并区间 738.单调递增的数字 968.监控二叉树

56. 合并区间

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

这题与之前的射气球等类似，对左边界进行排序后对是否重叠进行判断，对重叠的元素进行合并即可。

738.单调递增的数字

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        string s=to_string(n);
        if(s.size()>1){
            for(int i=s.size()-1;i>0;i--){
                if(s[i]<s[i-1]){
                    for(int j=i;j<s.size();j++){
                        if(s[j]!='9') s[j]='9';
                        else break;
                    }
                    s[i-1]-=1;
                }
            }
        }
        return stoi(s);
    }
};

对这题稍加观察就会发现，如果所给的数字不满足单调递增，则答案的数字尾必然是一串9，因为一串9是最大的，所以对数字从后往前判断是否满足单调递增，不满足的地方将前一位-1，保证后面全为9时也小于原数字，即可得到答案。

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 {
public:
    int result=0;
    int minCameraCover(TreeNode* root) {
        rd(root);
        if(root->val==0){
            root->val=2;
            result++;
        }
        return result;
    }
    void rd(TreeNode* root){
        if(root==NULL) return;
        rd(root->left);
        rd(root->right);
        if(root->left==NULL&&root->right==NULL) return;
        if(root->left!=NULL){
            if(root->left->val==0){
                root->val=2;
                root->left->val=1;
                result++;
                return;
            } 
            if(root->left->val==2){
                root->val=1;
            }
        }
        if(root->right!=NULL){
            if(root->right->val==0){
                root->val=2;
                root->right->val=1;
                result++;
                return;
            } 
            if(root->right->val==2){
                root->val=1;
            }
        }

    }
};

这题随想录给的思路是使用3个数字标记节点的三种状态，采用后序遍历，先从叶子节点开始判断是否加监控，只需要理清一个节点在子节点具有什么状态时需要加监控即可。

代码随想录 第八章 贪心算法 part05