LeetCode 第 274 场周赛总结

5967. 检查是否所有 A 都在 B 之前

这是我写的：执行用时: 40 ms，内存消耗: 15 MB

class Solution:
    def checkString(self, s: str) -> bool:
        index = 0
        for i in range(index, len(s)):
            if s[i] == 'a':
                index += 1
            else:
                break
        if 'a' in s[index:]:
            return False
        return True

另一种极简做法：执行用时: 24 ms，内存消耗: 15.1 MB

class Solution:
    def checkString(self, s: str) -> bool:
        return not 'ba' in s

5968. 银行中的激光束数量

这是我写的：执行用时: 216 ms，内存消耗: 16.5 MB

class Solution:
    def numberOfBeams(self, bank: List[str]) -> int:
        res = 0
        pre = -1
        prenum = 0
        m, n = len(bank), len(bank[0])
        for i in range(m):
            tmp = 0
            for j in range(n):
                if bank[i][j] == '1':
                    tmp += 1  
            if tmp == 0:
                continue
            else:            
                if pre != -1:
                    res += (tmp * prenum)
                prenum = tmp
                pre = i
        if pre == -1:
            return 0
        return res

5969. 摧毁小行星

我写的：执行用时: 140 ms，内存消耗: 24.4 MB
直接贪心即可

class Solution:
    def asteroidsDestroyed(self, mass: int, asteroids: List[int]) -> bool:
        asteroids.sort()
        for num in asteroids:
            if num <= mass:
                mass += num
            else:
                return False
        return True 

5970. 参加会议的最多员工数

大佬写的：执行用时: 564 ms，内存消耗: 54.9 MB

class Solution:
    def maximumInvitations(self, favorite: List[int]) -> int:
        
        ## =========================================
        ## 1. 拓扑排序，分离出环
        ## =========================================

        # 建图
        reversed_graph = collections.defaultdict(list)  # 方向反转的图【求解 N 叉树的最大深度】
        indeg = collections.defaultdict(int)            # 节点入度 indegree
        for u, v in enumerate(favorite):
            reversed_graph[v].append(u)
            indeg[v] += 1
        
        # 拓扑排序【得到有向环中的全部节点】
        n = len(favorite)
        deque = collections.deque([u for u in range(n) if indeg[u]==0])
        while deque:
            u = deque.popleft()
            v = favorite[u]     # 节点 u 喜欢的员工 v：u -> v
            indeg[v] -= 1
            if indeg[v] == 0:   # 入度为 0 的节点入队列
                deque.append(v)
        
       
        ## =========================================
        ## 2. 环的大小【强连通片的大小】
        ## =========================================

        # 环的长度
        def bfs1(root: int) -> int:
            depth = 0
            deque = collections.deque([root])
            while deque:
                u = deque.popleft()
                if u in visited:    # 找到了环，返回其长度
                    return depth
                visited.add(u)
                deque.append(favorite[u])
                depth += 1
        
        nodes_in_circle = [u for u in range(n) if indeg[u]>0]   # 有向环中的全部节点
        visited = set()     # 防止重复访问
        records = []        # 记录二元环
        max_circle_len = 0
        
        for u in nodes_in_circle:
            if u in visited:    # 每个节点至多存在于一个环中，若已经访问过则无需再次访问
                continue
            circle_len = bfs1(u)
            max_circle_len = max(max_circle_len, circle_len)    # 环的最大长度
            if circle_len==2:                       # 记录二元环
                records.append((u, favorite[u]))    # 若 (u, v) 组成二元环，将其记录

        if len(records) == 0:   # 不存在二元环，则直接返回最大环的长度；否则需计算二元环的情况
            return max_circle_len
        
        
        ## =========================================
        ## 3. 二元环及其粉丝链的总长度
        ## =========================================
        
        # 二元环左右粉丝链条的最大长度【类似于 N 叉树的最大深度】
        def bfs2(root: int) -> int:
            depth = 0
            deque = collections.deque([root])
            while deque:
                depth += 1
                for _ in range(len(deque)):
                    u = deque.popleft()
                    for v in reversed_graph[u]:
                        deque.append(v)
            return depth


        total_path_len = 0      # 二元环及其粉丝链（指向根节点）的总长度
        while records:
            u, v = records.pop()
            # 将二元环(u, v)断开，并分别计算以 u 和 v 为根节点的 N 叉树的最大深度【可参加 N 叉树的最大深度】
            reversed_graph[u] = [i for i in reversed_graph[u] if i!=v]      # 断开二元环
            reversed_graph[v] = [i for i in reversed_graph[v] if i!=u]
            left = bfs2(u)      # 以 u 为根节点的树的深度
            right = bfs2(v)     # 以 v 为根节点的树的深度
            total_path_len += left+right    # 累加所有的二元环情况
        

        ans = max(max_circle_len, total_path_len)   # 返回二元环和非二元环情况下求得的最大值
        return ans