[Leetcode Weekly Contest]264

链接：LeetCode

[Leetcode]2047. 句子中的有效单词数

句子仅由小写字母（'a' 到 'z'）、数字（'0' 到 '9'）、连字符（'-'）、标点符号（'!'、'.' 和 ','）以及空格（' '）组成。每个句子可以根据空格分解成 一个或者多个 token ，这些 token 之间由一个或者多个空格 ' ' 分隔。

如果一个 token 同时满足下述条件，则认为这个 token 是一个有效单词：

仅由小写字母、连字符和/或标点（不含数字）。
至多一个 连字符 '-' 。如果存在，连字符两侧应当都存在小写字母（"a-b" 是一个有效单词，但 "-ab" 和 "ab-" 不是有效单词）。
至多一个 标点符号。如果存在，标点符号应当位于 token 的 末尾 。
这里给出几个有效单词的例子："a-b."、"afad"、"ba-c"、"a!" 和 "!" 。

给你一个字符串 sentence ，请你找出并返回 sentence 中 有效单词的数目 。

遍历即可。

class Solution {
    public int countValidWords(String sentence) {
        String[] words = sentence.split(" ");
        int res = 0;
        for(String word : words) {
            if(isValid(word)) {
                res+=1;
            }
        }
        return res;
    }

    public boolean isValid(String word) {
        if(word.isBlank()) return false;
        int dash = -1, n = word.length();
        for(int idx=0; idx<n; idx++) {
            var ch = word.charAt(idx);
            if (ch == '-') {
                if(dash != -1) return false;
                else dash = idx;
            }
            else if(ch == '!' || ch == '.' || ch == ',') {
                if(idx != n-1) return false;
            }
            else if(Character.isDigit(ch)) return false;
        }
        if(dash!=-1 && (dash==0 || dash==n-1||!Character.isLowerCase(word.charAt(dash-1))||!Character.isLowerCase(word.charAt(dash+1)))) return false;
        return true;
    }
}

[Leetcode]2048. 下一个更大的数值平衡数

如果整数 x 满足：对于每个数位 d ，这个数位 恰好 在 x 中出现 d 次。那么整数 x 就是一个 数值平衡数 。

给你一个整数 n ，请你返回 严格大于 n 的 最小数值平衡数 。

暴力即可。

class Solution {
    public int nextBeautifulNumber(int n) {
        while(true) {
            n++;
            if(isBeautifulNumber(n)) {
                return n;
            }
        }
    }

    public boolean isBeautifulNumber(int n) {
        String strN = String.valueOf(n);
        HashMap<Character,Integer> count = new HashMap<>();
        for(var ch:strN.toCharArray()) {
            count.put(ch,count.getOrDefault(ch,0)+1);
        }
        for(var pair:count.entrySet()) {
            // int key = (int)(pair.getKey()) - (int)('0');
            int key = Integer.parseInt(String.valueOf(pair.getKey()));
            if(key != pair.getValue()) return false;
        }
        return true;
    }
}

[Leetcode]2049. 统计最高分的节点数目

给你一棵根节点为 0 的 二叉树 ，它总共有 n 个节点，节点编号为 0 到 n - 1 。同时给你一个下标从 0 开始的整数数组 parents 表示这棵树，其中 parents[i] 是节点 i 的父节点。由于节点 0 是根，所以 parents[0] == -1 。

一个子树的 大小 为这个子树内节点的数目。每个节点都有一个与之关联的 分数 。求出某个节点分数的方法是，将这个节点和与它相连的边全部 删除 ，剩余部分是若干个 非空 子树，这个节点的 分数 为所有这些子树 大小的乘积 。

请你返回有 最高得分 节点的 数目 。

1.使用Map存储当前节点，以及它的子节点。
2.利用DFS查询并存储当前节点下的节点个数。
3.遍历计算各个节点删除后的得分情况(0号节点没有父节点)。

class Solution {
    public int countHighestScoreNodes(int[] parents) {
        Map<Integer, List<Integer>> map = new HashMap();
        int[] count = new int[parents.length];
        for(int i = 1; i < parents.length; i++){
            List<Integer> list = new ArrayList(map.getOrDefault( parents[i], new ArrayList()));
            list.add(i);
            map.put(parents[i], list);
        }
        DFS(0, map, count);
        long scoreMax = Integer.MIN_VALUE;
        int nodes = 0;
        for(int i = 0; i < parents.length; i++){
            long score = 1;
            if(parents[i] == -1){
                List<Integer> list = new ArrayList( map.getOrDefault( i, new ArrayList() ) );
                for(int num : list)
                    score *= count[num];
            }else{
                score = count[0] - count[i];
                List<Integer> list = new ArrayList( map.getOrDefault( i, new ArrayList() ) );
                for(int num : list)
                    score *= count[num];
            }
            if(scoreMax < score){
                scoreMax = score;
                nodes = 1;
            }else if(score == scoreMax) ++nodes;
        }
        return nodes;
    }

    public void DFS(int index,  Map<Integer, List<Integer>> map, int[] count){
        List<Integer> list = new ArrayList( map.getOrDefault( index, new ArrayList() ) );
        if(list.size() == 0){
            count[index] = 1;
            return;
        }
        for(int num : list){
            DFS(num, map, count);
            count[index] += count[num];
        }
        ++count[index];
    }
}

[Leetcode]2050. 并行课程 III

给你一个整数 n ，表示有 n 节课，课程编号从 1 到 n 。同时给你一个二维整数数组 relations ，其中 relations[j] = [prevCoursej, nextCoursej] ，表示课程 prevCoursej 必须在课程 nextCoursej 之前 完成（先修课的关系）。同时给你一个下标从 0 开始的整数数组 time ，其中 time[i] 表示完成第 (i+1) 门课程需要花费的 月份 数。

请你根据以下规则算出完成所有课程所需要的 最少 月份数：

如果一门课的所有先修课都已经完成，你可以在 任意 时间开始这门课程。
你可以 同时 上 任意门课程 。
请你返回完成所有课程所需要的 最少 月份数。

注意：测试数据保证一定可以完成所有课程（也就是先修课的关系构成一个有向无环图）。

这是一道非常经典的拓扑排序的应用题目， 我们可以在拓扑排序的过程中，维护一个 dp[i] 数组来表示当前到达节点 i 的最长时间即可。另外，我们也可用DFS的方法来做，维护一个最长时间即可。

class Solution {
public int minimumTime(int n, int[][] relations, int[] time) {
        int[] inDegree = new int[n];
        List<Integer>[] graph = new List[n];
        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
        }
        for (int[] edge : relations) {
            int u = edge[0] - 1;
            int v = edge[1] - 1;
            graph[u].add(v);
            inDegree[v]++;
        }

        int[] dist = new int[n];
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (inDegree[i] == 0) {
                queue.add(i);
                dist[i] = time[i];
            }
        }
        while (!queue.isEmpty()) {
            int index = queue.poll();
            for (int next : graph[index]) {
                dist[next] = Math.max(dist[next], dist[index] + time[next]);
                if (--inDegree[next] == 0) {
                    queue.add(next);
                }
            }
        }
        return Arrays.stream(dist).max().getAsInt();
    }
}

Leetcode