算法练习day32

一、单调递增的数字

找到非单调递增的位置，把该位置减1，然后把后序的位置都改为9

/**
 * @param {number} n
 * @return {number}
 */
var monotoneIncreasingDigits = function(n) {
    let arr = String(n).split('')
    let result
    let flag = null
    for(let i = arr.length - 1; i >= 1; i--) {
        if(arr[i-1] > arr[i]) {
            flag = i
            arr[i-1]--
        }
    }
    if(flag) {
        for(let i = flag; i < arr.length; i++) {
            arr[i] = 9
        }
    }
    result = arr.join('')
    return result
};

二、监控二叉树

局部最优：让叶子节点的父节点安装摄像头，摄像头最少，全局最优

思路：从叶子节点往上遍历，后序遍历，左右中

定义三种状态， 0，无覆盖，1，有摄像头，2，有覆盖，空节点默认为有覆盖，这样不影响叶子节点

四类情况：

1. 左节点和右节点都有覆盖，返回无覆盖
2. 左节点和右节点至少有一个无覆盖，返回摄像头
3. 左节点和右节点至少一个有摄像头，返回有覆盖
4. 根节点为无覆盖时，结果加1

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var minCameraCover = function(root) {
    // 0, 无覆盖，1，有摄像头，2，有覆盖
    let result = 0
    function dfs(root) {
        if(!root) {
            return 2
        }
        let left = dfs(root.left)
        let right = dfs(root.right)
        if(left === 2 && right === 2) {
            return 0
        }
        if(left === 0 || right === 0) {
            result++
            return 1
        }
        if(left === 1 || right === 1) {
            return 2
        }
    }
    if(dfs(root) === 0) {
        result++
    }
    return result
};