LeetCode笔记：Weekly Contest 264

• LeetCode笔记：Weekly Contest 264
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

1. 题目一

给出题目一的试题链接如下：

• 2047. Number of Valid Words in a Sentence

1. 解题思路

这一题和惯例一样，只需要严格按照题目意思进行条件判断就可以了，不过我这边实现的方式多少有点复杂，应该还有后续的优化空间，不过这个就留给读者自行考虑了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countValidWords(self, sentence: str) -> int:
        tokens = sentence.strip().split()
        
        def is_valid(token):
            if any(digit in token for digit in "0123456789"):
                return False
            if token[-1] in "!.,":
                token = token[:-1]
            if any(punc in token for punc in "!.,"):
                return False
            if len(token.split("-")) > 2:
                return False
            if len(token.split("-")) == 2 and any(len(sub) == 0 for sub in token.split("-")):
                return False
            return True
        
        return len([w for w in tokens if is_valid(w)])

提交代码评测得到：耗时60ms，占用内存14.3MB。

2. 题目二

给出题目二的试题链接如下：

• 2048. Next Greater Numerically Balanced Number

1. 解题思路

这一题由于位数有限，因此可以使用的元素个数事实上也是有限的，因此，我们可以直接暴力地给出所有可能的数据，然后进行遍历即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def nextBeautifulNumber(self, n: int) -> int:
        
        def create_beautiful_nums(s):
            res = {int("".join(x)) for x in permutations(s)}
            return list(res)
        
        bnums = []
        for s in ["1", "22", "122", "333", "1333", "4444", "14444", "22333", "55555", "122333", "155555", "224444", "666666", "1224444"]:
            bnums +=  create_beautiful_nums(s)
        
        for x in sorted(bnums):
            if x > n:
                return x

提交代码评测得到：耗时352ms，占用内存14.2MB。

3. 题目三

给出题目三的试题链接如下：

• 2049. Count Nodes With the Highest Score

1. 解题思路

这一题事实上也还好，如果删除任何一个点的情况，其结果就是会将原树分为三个部分，分别是该节点的左右子树对应的子树以及剩余的所有节点，其对应的节点数就是其左右子树包含的节点个数，以及总结点数减去该节点包含的所有节点的个数。

因此，我们只需要记录下每一个节点的子节点以及其子树节点的个数即可，而后者可以通过一个拓扑图直接进行实现。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countHighestScoreNodes(self, parents: List[int]) -> int:
        n = len(parents)
        cnt = defaultdict(int)
        children = defaultdict(list)
        
        for i, p in enumerate(parents):
            if p == -1:
                continue
            cnt[p] += 1
            children[p].append(i)
            
        subs = [0 for _ in range(n)]
        s = [u for u in range(n) if cnt[u] == 0]
        while s:
            u = s.pop(0)
            subs[u] = 1
            for v in children[u]:
                subs[u] += subs[v]
            p = parents[u]
            cnt[p] -= 1
            if cnt[p] == 0:
                s.append(p)
        
        def cal_score(u):
            k = 1
            res = 1
            for v in children[u]:
                res *= subs[v]
                k += subs[v]
            res = res * (n-k) if k != n else res
            return res
        
        scores = [cal_score(u) for u in range(n)]
        max_score = max(scores)
        return len([u for u in range(n) if scores[u] == max_score])

提交代码评测得到：耗时3107ms，占用内存54.9MB。

4. 题目四

给出题目四的试题链接如下：

• 2050. Parallel Courses III

1. 解题思路

这一题的考察点同样是一个拓扑图的实现，相对而言感觉还比前面那一题更简单一些，这里就不多做展开了。

2. 代码实现

给出python代码实线如下：

class Solution:
    def minimumTime(self, n: int, relations: List[List[int]], time: List[int]) -> int:
        precourse = defaultdict(list)
        postcourse = defaultdict(list)
        cnt = defaultdict(int)
        
        for pre, post in relations:
            cnt[post] += 1
            precourse[post].append(pre)
            postcourse[pre].append(post)
            
        s = [u for u in range(1, n+1) if cnt[u] == 0]
        tot = [0 for _ in range(n+1)]
        while s != []:
            u = s.pop(0)
            tot[u] += time[u-1]
            before = 0
            for v in precourse[u]:
                before = max(before, tot[v])
            tot[u] += before
            for v in postcourse[u]:
                cnt[v] -= 1
                if cnt[v] == 0:
                    s.append(v)
        return max(tot)

提交代码评测得到：耗时1921ms，占用内存50.5MB。