LeetCode第 26 场双周赛

5396. 连续字符

题目难度Easy
给你一个字符串 s ，字符串的「能量」定义为：只包含一种字符的最长非空子字符串的长度。

请你返回字符串的能量。

示例 1：

输入：s = “leetcode”
输出：2
解释：子字符串 “ee” 长度为 2 ，只包含字符 ‘e’ 。
示例 2：

输入：s = “abbcccddddeeeeedcba”
输出：5
解释：子字符串 “eeeee” 长度为 5 ，只包含字符 ‘e’ 。
示例 3：

输入：s = “triplepillooooow”
输出：5
示例 4：

输入：s = “hooraaaaaaaaaaay”
输出：11
示例 5：

输入：s = “tourist”
输出：1

提示：

1 <= s.length <= 500
s 只包含小写英文字母。

思路

注意连续最长子串出现在最后的情形

代码

class Solution {
    public int maxPower(String s) {
        int energy = 0, ans = 0;
        char pre = 0;
        for (char ch: s.toCharArray()) {
            if (ch == pre) {
                ++energy;
            } else {
                pre = ch;
                ans = Math.max(ans, energy);
                energy = 1;
            }
        }
        ans = Math.max(ans, energy);
        return ans;
    }
}

5397. 最简分数

题目难度Medium
给你一个整数 n ，请你返回所有 0 到 1 之间（不包括 0 和 1）满足分母小于等于 n 的 最简 分数 。分数可以以 任意 顺序返回。

示例 1：

输入：n = 2
输出：[“1/2”]
解释：“1/2” 是唯一一个分母小于等于 2 的最简分数。
示例 2：

输入：n = 3
输出：[“1/2”,“1/3”,“2/3”]
示例 3：

输入：n = 4
输出：[“1/2”,“1/3”,“1/4”,“2/3”,“3/4”]
解释：“2/4” 不是最简分数，因为它可以化简为 “1/2” 。
示例 4：

输入：n = 1
输出：[]

提示：

1 <= n <= 100

思路

递归 & 最大公约数计算

代码

class Solution {
    private int gcd(int a, int b) {
        int tmp = 0;
        while (a % b != 0) {
            tmp = a;
            a = b;
            b = tmp % b;
        }
        return b;
    }
    
    public List<String> simplifiedFractions(int n) {
        List<String> ans = new ArrayList<>();
        if (n == 1) {
            return ans;
        }
        ans = simplifiedFractions(n - 1);
        for (int i=1; i<=n; ++i) {
            if (gcd(n, i) == 1) {
                ans.add(new String(i + "/" + n));
            }
        }
        return ans;
    }
}

5398. 统计二叉树中好节点的数目

题目难度Medium
给你一棵根为 root 的二叉树，请你返回二叉树中好节点的数目。

「好节点」X 定义为：从根到该节点 X 所经过的节点中，没有任何节点的值大于 X 的值。

示例 1：

输入：root = [3,1,4,3,null,1,5]
输出：4
解释：图中蓝色节点为好节点。
根节点 (3) 永远是个好节点。
节点 4 -> (3,4) 是路径中的最大值。
节点 5 -> (3,4,5) 是路径中的最大值。
节点 3 -> (3,1,3) 是路径中的最大值。
示例 2：

输入：root = [3,3,null,4,2]
输出：3
解释：节点 2 -> (3, 3, 2) 不是好节点，因为 “3” 比它大。
示例 3：

输入：root = [1]
输出：1
解释：根节点是好节点。

提示：

二叉树中节点数目范围是 [1, 10^5] 。
每个节点权值的范围是 [-10^4, 10^4] 。

思路

递归

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    private int numGood = 0;
    
    private void dfs(TreeNode root, int preMax) {
        if (root == null) {
            return;
        }
        if (root.val >= preMax) {
            ++numGood;
            preMax = Math.max(preMax, root.val);
        }
        dfs(root.left, preMax);
        dfs(root.right, preMax);
    }
    
    public int goodNodes(TreeNode root) {
        this.numGood = 0;
        dfs(root, Integer.MIN_VALUE);
        return this.numGood;
    }
}

5399. 数位成本和为目标值的最大数字

题目难度Hard
给你一个整数数组 cost 和一个整数 target 。请你返回满足如下规则可以得到的 最大 整数：

给当前结果添加一个数位（i + 1）的成本为 cost[i] （cost 数组下标从 0 开始）。
总成本必须恰好等于 target 。
添加的数位中没有数字 0 。
由于答案可能会很大，请你以字符串形式返回。

如果按照上述要求无法得到任何整数，请你返回 “0” 。

示例 1：

输入：cost = [4,3,2,5,6,7,2,5,5], target = 9
输出：“7772”
解释：添加数位 ‘7’ 的成本为 2 ，添加数位 ‘2’ 的成本为 3 。所以 “7772” 的代价为 23+ 31 = 9 。 “997” 也是满足要求的数字，但 “7772” 是较大的数字。
数字 成本
1 -> 4
2 -> 3
3 -> 2
4 -> 5
5 -> 6
6 -> 7
7 -> 2
8 -> 5
9 -> 5
示例 2：

输入：cost = [7,6,5,5,5,6,8,7,8], target = 12
输出：“85”
解释：添加数位 ‘8’ 的成本是 7 ，添加数位 ‘5’ 的成本是 5 。“85” 的成本为 7 + 5 = 12 。
示例 3：

输入：cost = [2,4,6,2,4,6,4,4,4], target = 5
输出：“0”
解释：总成本是 target 的条件下，无法生成任何整数。
示例 4：

输入：cost = [6,10,15,40,40,40,40,40,40], target = 47
输出：“32211”

提示：

cost.length == 9
1 <= cost[i] <= 5000
1 <= target <= 5000

思路

动态规划

代码

class Solution {
    private int digitCompare(String a, String b) {
        int la = a.length(), lb = b.length(), i = 0;
        if (la > lb) {
            return 1;
        } else if (la < lb) {
            return -1;
        }
        for (i=0; i<la; ++i) {
            if (a.charAt(i) > b.charAt(i)) {
                return 1;
            } else if (a.charAt(i) < b.charAt(i)) {
                return -1;
            }
        }
        return 0;
    }
    
    public String largestNumber(int[] cost, int target) {
        HashMap<Integer, Integer> costMap = new HashMap<>();
        String[] dp = new String[target+1];
        int i = 0, j = 0;
        for (i=0; i<9; ++i) {
            costMap.put(cost[i], i+1);
        }
        String tmp = "";
        dp[0] = "";
        for (i=1; i<=target; ++i) {
            dp[i] = "";
            for (j=0; j<i; ++j) {
                if (j != 0 && dp[j].equals("")) {
                    continue;
                }
                if (costMap.containsKey(i-j)) {
                    tmp = String.valueOf(costMap.get(i-j)) + dp[j];
                    if (digitCompare(tmp, dp[i]) > 0) {
                        dp[i] = tmp;
                    }
                }
            }
            // System.out.println(i + " " + dp[i]);
        }
        if (dp[target].equals("")) {
            dp[target] = "0";
        }
        return dp[target];
    }
}