LeetCode笔记：Biweekly Contest 102

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

• 比赛链接：https://leetcode.com/contest/biweekly-contest-102

1. 题目一

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

• 2639. Find the Width of Columns of a Grid

1. 解题思路

这一题没啥难度，就是翻译一下题目，在每一列中找到所有元素的最大长度然后返回即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def findColumnWidth(self, grid: List[List[int]]) -> List[int]:
        n, m = len(grid), len(grid[0])
        res = [max(len(str(grid[i][j])) for i in range(n)) for j in range(m)]
        return res

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

2. 题目二

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

• 2640. Find the Score of All Prefixes of an Array

1. 解题思路

这一题同样也只要按照题意翻译一下即可。先构造出conversion数组，然后求一下累积数组即可。

2. 代码实现

class Solution:
    def findPrefixScore(self, nums: List[int]) -> List[int]:
        conversion = deepcopy(nums)
        _max = 0
        for i, x in enumerate(nums):
            _max = max(_max, x)
            conversion[i] += _max
        return list(accumulate(conversion))

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

3. 题目三

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

• 2641. Cousins in Binary Tree II

1. 解题思路

这一题暂时没想到什么特别巧妙的思路，因此我就是拆了两步，首先通过一次遍历获取每一层的元素和以及每一个节点的两个子节点元素的和。

然后第二次遍历我们就可以更新每一个元素的值为其所在层的元素之和减去其父元素的两个子节点的原值之和了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def replaceValueInTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        s = defaultdict(int)
        nodes = defaultdict(int)
        
        def dfs(root, depth):
            nonlocal nodes, s
            if root is None:
                return 0
            s[depth] += root.val
            lval = dfs(root.left, depth+1)
            rval = dfs(root.right, depth+1)
            nodes[root] = lval + rval
            return root.val
        
        dfs(root, 0)
        
        def rep(root, depth, parent):
            if root is None:
                return
            if parent is None:
                root.val = 0
            else:
                root.val = s[depth] - nodes[parent]
            rep(root.left, depth+1, root)
            rep(root.right, depth+1, root)
            return
        
        rep(root, 0, None)
        return root

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

4. 题目四

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

• 2642. Design Graph With Shortest Path Calculator

1. 解题思路

这一题丢脸都大发了……

我看到这道题的第一反应就是需要维护一个巧妙的结构，然后每次query的时候可以在$O(1)$的时间复杂度内直接返回答案。

但是代价就是需要在每一次addEdge的时候维护好所有的节点之间的连接距离的最小值，结果做到是能做，但是一直超时，死活搞不定……

然后一看其他大佬们的答案，直接懵逼，因为他们的思路是反的，不维护一个复杂的结构，就是记录一下edge，然后每次query的时候用一个dfs来获取最小距离……

简直了……

2. 代码实现

给出python代码实现如下：

class Graph:

    def __init__(self, n: int, edges: List[List[int]]):
        self.graph = defaultdict(list)
        for edge in edges:
            self.addEdge(edge)

    def addEdge(self, edge: List[int]) -> None:
        u, v, w = edge
        self.graph[u].append((v, w))

    def shortestPath(self, node1: int, node2: int) -> int:
        # print(node1, node2, self.graph)
        q = [(0, node1)]
        seen = set()
        while q:
            cost, u = heapq.heappop(q)
            seen.add(u)
            if u == node2:
                return cost
            for v, w in self.graph[u]:
                if v in seen:
                    continue
                heapq.heappush(q, (cost+w, v))
        return -1

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