LeetCode笔记：Weekly Contest 308

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

• 比赛链接：https://leetcode.com/contest/weekly-contest-308/

0. 小结

这次的比赛倒是挺顺利的，大概前后也就花了不到一小时时间吧，不过考虑到第一名的大佬只用了6分钟，emmm……

继续加油吧……

1. 题目一

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

• 2389. Longest Subsequence With Limited Sum

1. 解题思路

这一题题目表面上说是顺序相关的，但是由于是求和，所以事实上和顺序无关，因此，我们只需要对其进行排序之后计算一下累积数组，然后对每一个query找到不大于这个数的最长位置即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def answerQueries(self, nums: List[int], queries: List[int]) -> List[int]:
        nums = sorted(nums)
        s = list(accumulate(nums))
        return [bisect.bisect_right(s, q) for q in queries]

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

2. 题目二

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

• 2390. Removing Stars From a String

1. 解题思路

这一题就是一个栈，对于不是*的元素进行一个入栈操作，对于*元素则进行一次出栈操作。

最后得到的序列就是我们所需要的结果。

2. 代码实现

给出python代码实现如下：

class Solution:
    def removeStars(self, s: str) -> str:
        q = []
        for ch in s:
            if ch == "*":
                q.pop()
            else:
                q.append(ch)
        return "".join(q)

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

3. 题目三

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

• 2391. Minimum Amount of Time to Collect Garbage

1. 解题思路

由于车子之间相互之间不能有交叠，因此这一题的答案就是车子行驶的总路程加上收集垃圾所需要的总时间。

而对于每一个车子需要行驶的总路程，就是这辆车子收集的垃圾最后一个出现的位置。

另一方面，收集垃圾所需要的时间恰好就是这类垃圾的总数目。

综上，我们很快就能得到我们的答案了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def garbageCollection(self, garbage: List[str], travel: List[int]) -> int:
        travel = [0] + list(accumulate(travel))
        last = defaultdict(int)
        cnt = defaultdict(int)
        for i, g in enumerate(garbage):
            for k, v in Counter(g).items():
                cnt[k] += v
                last[k] = i
        t = sum(travel[idx] for idx in last.values())
        s = sum(cnt.values())
        return s + t

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

4. 题目四

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

• 2392. Build a Matrix With Conditions

1. 解题思路

这一题典型的就是拓扑序列的问题。

显然，行和列之间的位置关系是相互独立的，因此，事实上我们就是要分别在行和列上构造两个1-k的序列，使得其满足给出的顺序关系即可。

因此，这个问题就可以化简成为简单地拓扑序列排序的问题进行实现了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def buildMatrix(self, k: int, rowConditions: List[List[int]], colConditions: List[List[int]]) -> List[List[int]]:
        def get_order(seq):
            pre = defaultdict(int)
            post = defaultdict(list)
            for u, v in seq:
                pre[v] += 1
                post[u].append(v)
                
            res = [-1 for _ in range(k)]
            
            idx = 0
            s = [i for i in range(1, k+1) if i not in pre]
            while s != []:
                u = s.pop(0)
                res[u-1] = idx
                idx += 1
                for v in post[u]:
                    pre[v] -= 1
                    if pre[v] == 0:
                        s.append(v)
                        
            for i in range(k):
                if res[i] == -1:
                    res[i] = idx
                    idx += 1
            return res if all(v == 0 for v in pre.values()) else []
        
        rows = get_order(rowConditions)
        cols = get_order(colConditions)
        if rows == [] or cols == []:
            return []
        res = [[0 for _ in range(k)] for _ in range(k)]
        for i, (x, y) in enumerate(zip(rows, cols)):
            res[x][y] = i+1
        return res

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