代码随想录算法训练营第31 天 |LeetCode56. 合并区间 LeetCode 738.单调递增的数 LeetCode968.监控二叉树字

最新推荐文章于 2024-11-14 19:06:32 发布

HIT最菜电控

最新推荐文章于 2024-11-14 19:06:32 发布

阅读量1k

点赞数 24

分类专栏：代码随想录算法训练营文章标签：算法 leetcode 数据结构 c++ 贪心算法二叉树

本文链接：https://blog.csdn.net/2301_79647020/article/details/140865917

版权

代码随想录算法训练营专栏收录该内容

46 篇文章 0 订阅

订阅专栏

代码随想录算法训练营

Day31 代码随想录算法训练营第31 天 |LeetCode56. 合并区间 LeetCode 738.单调递增的数字 LeetCode968.监控二叉树

前言

一、LeetCode56. 合并区间

1.题目链接

LeetCode56. 合并区间

2.思路1

（1）按起点排序
（2）遍历每个区间
1）如果和前一个重叠，那么更新右端（取最大）
2）如果和前一个不重叠：将前一个区间（l到前一个右端）放入答案
（3）最后将最后一个区间放入

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) {
        if (intervals.size() == 1)
            return intervals;
        vector<vector<int>> ans;
        sort(intervals.begin(), intervals.end(), cmp);

        int l = intervals[0][0];
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals[i][0] <= intervals[i - 1][1]) {
                intervals[i][1] = max(intervals[i - 1][1], intervals[i][1]);

            } else {
                vector<int> path;
                path.push_back(l);
                path.push_back(intervals[i - 1][1]);
                ans.push_back(path);
                l = intervals[i][0];
            }
            if (i == intervals.size() - 1) {
                vector<int> path;
                path.push_back(l);
                path.push_back(intervals[i][1]);
                ans.push_back(path);
            }
        }
        return ans;
    }
};

3、同思路优化：不用path暂存区间

遇到不与前面重叠的区间，直接放入结果；
遇到和前面重叠的区间，修改最后一个区间的右端

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

二、LeetCode 738.单调递增的数字

1.题目链接

LeetCode 738.单调递增的数字

2.思路

（1）如何存放n的每一位：用字符串
n的位要从左向右放，但是一般的获取整数各位的方法是从右向左获取的
（2）贪心思路
1）如果左<右：顺序正常
2）如果左>右：左边需要－1，左边-1以后要让右边尽可能大—也就是右边全变成9
（3）遍历顺序：从右向左
1）如果从左向右
遇到s[i - 1] > s[i]的情况，让s[i - 1]减一，但此时如果s[i - 1]减一了，可能又小于s[i - 2]
以332为例，会变成329，前两位还是不满足
2）所以从右向左

3.题解

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

四、LeetCode 968.监控二叉树

1.题目链接

LeetCode 968.监控二叉树

2.思路

（1）贪心思路：
1）两种浪费：
① 根节点放摄像头会浪费：本来摄像头可以覆盖除了自己以外的3个点，现在只有子节点被覆盖
② 叶节点放摄像头浪费，本来摄像头可以覆盖除了自己以外的3个点，现在只有父节点被覆盖
2）叶节点会浪费两个覆盖点，头结点浪费一个，并且叶节点很可能比头结点多
所以我们给所有叶节点的父节点放摄像头，再往上面推导
（2）遍历顺序：后序遍历（自下而上）
（3）返回类型为什么是int
返回0代表节点没有被覆盖
返回1代表节点被覆盖
返回2代表节点放摄像头
（4）三种情况
1）左右节点都被覆盖：当前节点一定没有被覆盖，返回0
2）左子节点和右子节点中的一个没被覆盖：当前节点需要安装摄像头，计数+1，返回2
3）左子节点和右子节点中的一个有摄像头：当前节点被覆盖，返回1
（5）额外检验头结点，如果头结点没被覆盖，则在头结点加摄像头

3.题解

class Solution {
public:
    int count = 0;
    int trace(TreeNode* node) {
        // 0--无覆盖 1---有覆盖  2---有摄像头
        if (node == NULL)
            return 1;
        int l = trace(node->left);
        int r = trace(node->right);
        if (l == 1 && r == 1)
            return 0;
        if (l == 0 || r == 0) {
            count++;
            return 2;
        }
        if (l == 2 || r == 2)
            return 1;
        return -1;
    }
    int minCameraCover(TreeNode* root) {

        int a=trace(root);
        if(a==0)count++;
        return count;
    }
};