LeetCode Weekly Contest 172

5315. 6 和 9 组成的最大数字

给你一个仅由数字 6 和 9 组成的正整数 num。

你最多只能翻转一位数字，将 6 变成 9，或者把 9 变成 6 。

请返回你可以得到的最大数字。

示例 1：

输入：num = 9669
输出：9969
解释：
改变第一位数字可以得到 6669 。
改变第二位数字可以得到 9969 。
改变第三位数字可以得到 9699 。
改变第四位数字可以得到 9666 。
其中最大的数字是 9969 。
示例 2：

输入：num = 9996
输出：9999
解释：将最后一位从 6 变到 9，其结果 9999 是最大的数。
示例 3：

输入：num = 9999
输出：9999
解释：无需改变就已经是最大的数字了。

代码

class Solution {
    public int maximum69Number (int num) {
        String snum = String.valueOf(num);
        int slen = snum.length(), i = 0;
        for (i=0; i <slen; ++i) {
            if (snum.charAt(i) == '6') {
                return Integer.parseInt(snum.substring(0, i) + '9' + snum.substring(i+1));
            }
        }
        return num;
    }
};

5316. 竖直打印单词

给你一个字符串 s。请你按照单词在 s 中的出现顺序将它们全部竖直返回。
单词应该以字符串列表的形式返回，必要时用空格补位，但输出尾部的空格需要删除（不允许尾随空格）。
每个单词只能放在一列上，每一列中也只能有一个单词。

示例 1：

输入：s = “HOW ARE YOU”
输出：[“HAY”,“ORO”,“WEU”]
解释：每个单词都应该竖直打印。
“HAY”
“ORO”
“WEU”
示例 2：

输入：s = “TO BE OR NOT TO BE”
输出：[“TBONTB”,“OEROOE”," T"]
解释：题目允许使用空格补位，但不允许输出末尾出现空格。
“TBONTB”
“OEROOE”
" T"
示例 3：

输入：s = “CONTEST IS COMING”
输出：[“CIC”,“OSO”,“N M”,“T I”,“E N”,“S G”,“T”]

提示：

1 <= s.length <= 200
s 仅含大写英文字母。
题目数据保证两个单词之间只有一个空格。

代码

class Solution {
    public List<String> printVertically(String s) {
        s = s.trim();
        ArrayList<String> ans = new ArrayList<>();
        String[] words = s.split(" ");
        int n = words.length, i = 0, lmax = 0, j = 0;
        for (String word: words) {
            lmax = Math.max(lmax, word.length());
        }
        char[] chs = new char[n];
        for (j=0; j<lmax; ++j) {
            Arrays.fill(chs, '0');
            for (i=0; i<n; ++i) {
                if (j < words[i].length()) {
                    chs[i] = words[i].charAt(j);
                } else {
                    chs[i] = ' ';
                }
            }
            String tmp = new String(chs);
            tmp = 'a' + tmp;
            tmp = tmp.trim();
            tmp = tmp.substring(1);
            ans.add(tmp);
        }
        return ans;
    }
}

5317. 删除给定值的叶子节点

给你一棵以 root 为根的二叉树和一个整数 target ，请你删除所有值为 target 的 叶子节点 。

注意，一旦删除值为 target 的叶子节点，它的父节点就可能变成叶子节点；如果新叶子节点的值恰好也是 target ，那么这个节点也应该被删除。

也就是说，你需要重复此过程直到不能继续删除。

示例 1：

输入：root = [1,2,3,2,null,2,4], target = 2
输出：[1,null,3,null,4]
解释：
上面左边的图中，绿色节点为叶子节点，且它们的值与 target 相同（同为 2 ），它们会被删除，得到中间的图。
有一个新的节点变成了叶子节点且它的值与 target 相同，所以将再次进行删除，从而得到最右边的图。
示例 2：

输入：root = [1,3,3,3,2], target = 3
输出：[1,3,null,null,2]
示例 3：

输入：root = [1,2,null,2,null,2], target = 2
输出：[1]
解释：每一步都删除一个绿色的叶子节点（值为 2）。
示例 4：

输入：root = [1,1,1], target = 1
输出：[]
示例 5：

输入：root = [1,2,3], target = 1
输出：[1,2,3]

提示：

1 <= target <= 1000
每一棵树最多有 3000 个节点。
每一个节点值的范围是 [1, 1000] 。

思路

递归。先处理左右子树，返回左右子树根节点，根据更新的左右子节点判断当前根节点是否需要删除。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode removeLeafNodes(TreeNode root, int target) {
        if (root == null) {
            return null;
        }
        root.left = removeLeafNodes(root.left, target);
        root.right = removeLeafNodes(root.right, target);
        if (root.left == null && root.right == null) {
            return root.val == target? null: root;
        }
        return root;
    }
}

5318. 灌溉花园的最少水龙头数目 显示英文描述

在 x 轴上有一个一维的花园。花园长度为 n，从点 0 开始，到点 n 结束。

花园里总共有 n + 1 个水龙头，分别位于 [0, 1, …, n] 。

给你一个整数 n 和一个长度为 n + 1 的整数数组 ranges ，其中 ranges[i] （下标从 0 开始）表示：如果打开点 i 处的水龙头，可以灌溉的区域为 [i - ranges[i], i + ranges[i]] 。

请你返回可以灌溉整个花园的 最少水龙头数目 。如果花园始终存在无法灌溉到的地方，请你返回 -1 。

示例 1：

输入：n = 5, ranges = [3,4,1,1,0,0]
输出：1
解释：
点 0 处的水龙头可以灌溉区间 [-3,3]
点 1 处的水龙头可以灌溉区间 [-3,5]
点 2 处的水龙头可以灌溉区间 [1,3]
点 3 处的水龙头可以灌溉区间 [2,4]
点 4 处的水龙头可以灌溉区间 [4,4]
点 5 处的水龙头可以灌溉区间 [5,5]
只需要打开点 1 处的水龙头即可灌溉整个花园 [0,5] 。
示例 2：

输入：n = 3, ranges = [0,0,0,0]
输出：-1
解释：即使打开所有水龙头，你也无法灌溉整个花园。
示例 3：

输入：n = 7, ranges = [1,2,1,0,2,1,0,1]
输出：3
示例 4：

输入：n = 8, ranges = [4,0,0,0,0,0,0,0,4]
输出：2
示例 5：

输入：n = 8, ranges = [4,0,0,0,4,0,0,0,4]
输出：1

提示：

1 <= n <= 10^4
ranges.length == n + 1
0 <= ranges[i] <= 100

思路

区间覆盖问题。将线段按照左端点从小到大排序，维护两个变量curLen和curIdx，分别表示当前所选区间集合最右端覆盖的位置和当前所选的线段的Id. 每次从curIdx开始，在有序的线段数组中二分查找最后一个左端点位于curLen左侧的线段tmpIdx，在(curIdx, tmpIdx]区间中寻找右端点最右的线段的Id作为新的curIdx, 该线段的右端点位置作为新的curLen. 如此循环直到区间完全覆盖，记录所用的线段个数返回。
注意rightmostNoLargerThan的二分查找的写法，主要关注while循环条件l <= r和返回值return r.

代码

class Solution {
    private class Line implements Comparable<Line> {
        public int left, right;
        
        public Line(int left, int right) {
            this.left = left;
            this.right = right;
        }
        
        @Override
        public int compareTo(Line other) {
            return left - other.left;
        }
    }
    
    private int rightmostNoLargerThan(Line[] lines, int beginIdx, int bound) {
        int n = lines.length, l = Math.max(beginIdx, 0), r = n-1, m = 0;
        while (l <= r) {
            m = (l + r) / 2;
            if (lines[m].left <= bound) {
                l = m + 1;
            } else {
                r = m - 1;
            }
        }
        return r;
    }
    
    public int minTaps(int n, int[] ranges) {
        Line[] lines = new Line[n+1];
        int i = 0;
        for (i=0; i<=n; ++i) {
            lines[i] = new Line(i - ranges[i], i + ranges[i]);
        }
        Arrays.sort(lines);
        int curLen = 0, curIdx = -1, cnt = 0, preLen = 0;
        while (curLen < n) {
            int tmpIdx = rightmostNoLargerThan(lines, curIdx, curLen);
            preLen = curLen;
            for (i=curIdx + 1; i<=tmpIdx; ++i) {
                if (lines[i].right > curLen) {
                    curLen = lines[i].right;
                    curIdx = tmpIdx;
                }
            }
            if (preLen == curLen) {
                return -1;
            }
            ++cnt;
        }
        return cnt;
    }
}