day37｜● 738.单调递增的数字 ● 968.监控二叉树

738.单调递增的数字

第一次做只想着把从不递增部分开始变9，忽视了相等的情况。
错误case：668841
这个就是因为有相等的，一旦没有搞清flag位置，就会导致不递增。

这里是把flag放在不递增时的那位的前一位，如果前面还有相等的会导致减一之后递减所以要继续前移flag。
这就是while循环的意义，找到属于flag的位置再开始改变char

class Solution {
    public int monotoneIncreasingDigits(int n) {
        char[] chars = String.valueOf(n).toCharArray();
        int flag = chars.length;
        for (int i = 1; i < chars.length; i ++) {
            if (chars[i] < chars[i-1]) {
                flag = i-1;
                while (i >= 2 && chars[i-1] == chars[i-2]) {
                    i--;
                    flag--;
                }
                break;
            }
        }
        if (flag == chars.length) return n;
        for (int i = chars.length-1; i >= 0; i--) {
            if (flag != i) {
                chars[i] = '9';
            } else if (flag == i) {
                chars[i] -= 1;
                break; // break也要记住，要不然会把前面的也改了
            }
        }
        return Integer.valueOf(String.valueOf(chars));
    }
}

方法二：简洁版
这个就是从后向前遍历，但是保证了可以一直检测有没有递减，也就满足了情况332 -> 329 -> 299

class Solution {
    public int monotoneIncreasingDigits(int n) {
        String s = String.valueOf(n);
        char[] chars = s.toCharArray();
        int flag = chars.length;
        for (int i = chars.length - 1; i > 0; i--) {
            if (chars[i-1] > chars[i]) { // 发现递减
                chars[i-1]--; // 前一个--
                flag = i; // 更新违规的index
            }
        }
        for (int i = flag; i < s.length(); i++) {
            chars[i] = '9';
        }
        return Integer.parseInt(String.valueOf(chars));
    }
}

968.监控二叉树

不算难，后序遍历，一层层向上。

局部最优：让叶子节点的父节点安摄像头，所用摄像头最少。隔两个节点放一个摄像头
整体最优：全部摄像头数量所用最少！

class Solution {
    int count = 0;
    public int minCameraCover(TreeNode root) {
        int rootVal = traversal(root);
        if (rootVal == 0) {
            count++;
        }
        return count;
    }

    private int traversal(TreeNode node) {
        // 无覆盖0 有覆盖1 有摄像头2
        if (node == null) return 1;
        int left = traversal(node.left);
        int right = traversal(node.right);
        if (left == 0 || right == 0) { 
            count++;
            return 2;
        }
        if (left == 1 && right == 1) return 0;
        if (left == 2 || right == 2) return 1;
        return 0;
    }
}

原有注释解析版

class Solution {
    int result = 0;
    public int minCameraCover(TreeNode root) {
        if (traversal(root) == 0) { // 4.遍历完后，根节点没有被覆盖，按装摄像头
            result ++;
        }
        return result;
    }
    private int traversal(TreeNode node) {
        // 无覆盖0 有摄像头1 有覆盖2
        if (node == null) {
            return 2;
        }
        int left = traversal(node.left); //左
        int right = traversal(node.right); // 右
        if (left == 2 && right == 2) { //中 //1.左右有覆盖，返回无覆盖等待父节点装摄像头
            return 0;
        }
        if (left == 0 || right == 0) { // 2.左右至少一个无覆盖，装摄像头
            result++;
            return 1;
        }
        if (left == 1 || right == 1) { // 3.左右至少一个有摄像头，不用安装
            return 2;
        }
        return -1;
    }
}