代码随想录算法训练营第37天 | 738.单调递增的数字，968.监控二叉树

Leetcode - 738：单调递增的数字

题目：

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

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

示例 1:

输入: n = 10
输出: 9

示例 2:

输入: n = 1234
输出: 1234

示例 3:

输入: n = 33

笔记：

这道题我的第一感觉是要将每个数位上的数字放荡一个char的数组里，从最大数位上的数字往后遍历，如果一旦后面的数字小于了前一位的数字，就将后面的数字变为最大值9，然后前一位数字-1.

但这里当我们按照从前向后的顺序进行遍历的时候我们会发现一个问题，就是当前一位数字减一的时候可能又小于了前前一位数字这样就又要特殊处理前一位数字和前前一位数字相等的情况。所以我们改变遍历顺序，从最小数位开始向前遍历，一旦前一位数字大于本位数字，那么本位数字就置为9，前一位数字-1，接着向前递归遍历。

但是自己做了一遍发现好像从前和从后遍历都一样，都会存在while的情况：

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        int index = 0;
        int x = n;
        int count = 0;
        while(x > 0){
            x /= 10;
            count++;
        }
        vector<int> nstr(count, 0);
        while(n > 0){
            nstr[index] = n % 10;
            n /= 10;
            index++;
        }
        for(int i = 1; i < nstr.size(); i++){
            if(nstr[i] > nstr[i - 1]){
                int index2 = i;
                while(index2 >= 1 && nstr[index2] > nstr[index2 - 1]){
                    nstr[index2 - 1] = 9;
                    index2--;
                }
                nstr[i]--;
            }
        }
        int res = 0;
        reverse(nstr.begin(), nstr.end());
        for(int i = 0; i < nstr.size(); i++){
            res = 10 * res + nstr[i];
        }
        return res;
    }
};

看完题解发现还是自己理解错了，从后向前找的目的是为了找到第一个不合法的位置，从该位置往后的数字一律置为9，而该位数字--。而上面我自己的写法是有点像暴力了。

这里我有一点不对的是：在我们找到flag后我有加了一个while循环去处理flag之前的区间内是否因更改后出现不合法的情况，对于这种情况我们可以这么处理来省去这个while循环，就是找到flag之后，将flag之前的元素全部置为9，因为当我们吧flag位置的元素置为9之后，flag之前的元素也就是从flag位到最低数位的数字都必须要>=9，所以我们直接讲这些元素全部置为9即可。

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        int count = 0;
        int x = n;
        while(x > 0){
            x /= 10;
            count++;
        }
        vector<int> nstr(count, 0);
        int index = 0;
        while(n > 0){
            nstr[index] = n % 10;
            n /= 10;
            index++;
        }
        int flag;
        for(int i = 1; i < count; i++){
            if(nstr[i] > nstr[i - 1]){
                flag = i;
                nstr[flag]--;
            }
        }
        for(int i = 0; i < flag; i++){
            nstr[i] = 9;
        }
        reverse(nstr.begin(), nstr.end());
        int res = 0;
        for(int i = 0; i < count; i++){
            res = 10 * res + nstr[i];
        }
        return res;
    }
};

Leetcode - 968:监控二叉树

题目：

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

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

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

示例 1：

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。

示例 2：

输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。

笔记：

对每个节点进行状态赋值：0：未覆盖，1：装摄像头， 2：已覆盖

首先我们需要明确这棵二叉树的遍历顺序：必须是左右根的后序遍历，有左右子节点才可以判断当前节点是否装摄像头。然后我们开始对各个节点进行赋值并记录摄像头的数量，首先，叶子结点不可以放摄像机因为必然会造成浪费（没有子节点），所以我们就要对子节点的孩子节点：空节点进行赋值为2（已覆盖的状态），将所有叶子结点赋值为0（未覆盖的状态）：

if(left == 2 && right == 2)    return 0;

  接着我们向上走，当左右孩子只要出现一个孩子未被监控我们就要安装摄像头：

if(left == 0 || right == 0)    return 1;

我们接着继续走，当孩子节点安装摄像头时，那么它的父节点就已经被监控了，所以父节点为已覆盖的状态：

if(left == 1 || right == 1)    return 2;

还有一种特殊的情况就是两个孩子节点都是以覆盖的状态时，这不单单是描述叶子结点，还有一种可能是两个已覆盖状态孩子节点的父节点是根节点的时候，因为我们增加摄像机的操作仅仅是在左右孩子中出现未覆盖的情况下我们才加装摄像头，所以我们需要判断一下根节点是不是左右孩子都是已覆盖的状态，如果是就需要在加装一个摄像头。

/**
 * 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 res = 0;
    int trave(TreeNode* cur){
        if(cur == NULL) return 2;
        int left = trave(cur -> left);
        int right = trave(cur -> right);
        if(left == 2 && right == 2) return 0;
        if(left == 0 || right == 0){
            res++;
            return 1;
        }
        if(left == 1 || right == 1){
            return 2;
        }
        return -1;
    }
    int minCameraCover(TreeNode* root) {
        if(trave(root) == 0){
            res++;
        }
        return res;
    }
};