LeetCode笔记：Weekly Contest 284

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

1. 题目一

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

• 2200. Find All K-Distant Indices in an Array

1. 解题思路

这一题我的思路很暴力，直接暴力检索一下，找到所有的目标位置，然后加入其对应范围内的所有index即可。

2. 代码实现

class Solution:
    def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
        n = len(nums)
        res = set()
        for i, x in enumerate(nums):
            if x == key:
                for j in range(max(0, i-k), min(i+k+1, n)):
                    res.add(j)
        return sorted(list(res))

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

2. 题目二

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

• 2201. Count Artifacts That Can Be Extracted

1. 解题思路

这一题我的思路同样异常暴力，用一个set记录下所有的dig的位置，然后对每一个artifact检查是否有被完整的挖出来……

2. 代码实现

给出python代码实现如下：

class Solution:
    def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
        dig = set([tuple(x) for x in dig])
        res = 0
        for a, b, c, d in artifacts:
            if all((i, j) in dig for i in range(a, c+1) for j in range(b, d+1)):
                res += 1
        return res

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

3. 题目三

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

• 2202. Maximize the Topmost Element After K Moves

1. 解题思路

这一题只需要进行一下分类讨论就行了：

1. 如果n等于1，那么当且仅当k为偶数时top元素为第一个元素，否则操作之后数组为空，返回为-1；
2. 如果n长度不少于k，那么返回的元素将会是前k-1个元素于第k+1个元素之中的最大值；
3. 如果n小于k，那么任何的元素都可以被渠道，因此我们只要返回所有元素当中的最大值就行了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maximumTop(self, nums: List[int], k: int) -> int:
        n = len(nums)
        if n == 1:
            return nums[0] if k % 2 == 0 else -1
        if k == 0:
            return nums[0]
        elif k < n:
            return max(nums[:k-1] + [nums[k]])
        elif k == n:
            return max(nums[:k-1])
        else:
            return max(nums)

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

4. 题目四

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

• 2203. Minimum Weighted Subgraph With the Required Paths

1. 解题思路

这一题搞是搞出来了，不过方法极其的不优雅。

我的核心思路是说找到所有能够通向dest节点的对应节点到dest的最短距离，然后遍历这些节点，然后分别加上src1于src2到这些节点的最短距离，就是构成的子图所需的最小的距离。

不过直接提交出现了超时，因此我加了一点补丁，即首先先对所有的边进行了一下去重，只保留了两个节点之间的最短边，这样可以减少一些计算量。

修改后的代码可以通过测试样例，不过感觉还是很不优雅……

2. 代码实现

给出python代码实现如下：

class Solution:
    def minimumWeight(self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int) -> int:
        edges = sorted(edges, key=lambda x: x[2])
        
        out_graph = defaultdict(list)
        in_graph = defaultdict(list)
        seen = set()
        for u, v, w in edges:
            if (u, v) in seen:
                continue
            seen.add((u,v))
            out_graph[u].append((v, w))
            in_graph[v].append((u, w))
        
        def get_downsteam_distance(src):
            q = [(0, src)]
            distances = {}
            while q:
                dis, u = heapq.heappop(q)
                if u not in distances:
                    distances[u] = dis
                for v, w in out_graph[u]:
                    if v not in distances:
                        heapq.heappush(q, (dis+w, v))
            return distances
        
        def get_upstream_distance(dest):
            q = [(0, dest)]
            distances = {}
            while q:
                dis, u = heapq.heappop(q)
                if u not in distances:
                    distances[u] = dis
                for v, w in in_graph[u]:
                    if v not in distances:
                        heapq.heappush(q, (dis+w, v))
            return distances
        
        src1_to_nodes = get_downsteam_distance(src1)
        src2_to_nodes = get_downsteam_distance(src2)
        nodes_to_dest = get_upstream_distance(dest)
        res = min(nodes_to_dest[v] + src1_to_nodes.get(v, math.inf) + src2_to_nodes.get(v, math.inf) for v in nodes_to_dest)
        return res if res != math.inf else -1

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