leetcode第155场周赛总结

leetcode第155场周赛总结

第一题:5197. 最小绝对差

给你个整数数组 arr,其中每个元素都 不相同。
请你找到所有具有最小绝对差的元素对,并且按升序的顺序返回。

示例1:

输入:arr = [4,2,1,3]
输出:[[1,2],[2,3],[3,4]]

示例2:

输入:arr = [1,3,6,10,15]
输出:[[1,3]]

示例3:

输入:arr = [3,8,-10,23,19,-4,-14,27]
输出:[[-14,-10],[19,23],[23,27]]

提示:

2 <= arr.length <= 10^5
-10^6 <= arr[i] <= 10^6

分析:
因为要求按升序的顺序返回答案,所以可先对原数组进行排序,接着先遍历一遍找出最小绝对差是多少,然后再遍历一遍把所有等于最小绝对差的元素对添加进答案中。由于我们是在排完序的基础上做的,所以遍历时只需考虑相邻元素对即可,若不相邻的两元素对,其绝对差必不为最小。
代码如下:

class Solution:
    def minimumAbsDifference(self, arr: List[int]) -> List[List[int]]:
        arr.sort()
        ans = []
        mins = float('inf')
        for i in range(len(arr)-1):
            mins = min(mins, arr[i+1] - arr[i])
        for i in range(len(arr)-1):
            if arr[i+1] - arr[i] == mins:
                ans.append([arr[i], arr[i+1]])
        return ans
第二题:5198. 丑数 III

请你帮忙设计一个程序,用来找出第 n 个丑数。
丑数是可以被 a 或 b 或 c 整除的 正整数。

示例1:

输入:n = 3, a = 2, b = 3, c = 5
输出:4
解释:丑数序列为 2, 3, 4, 5, 6, 8, 9, 10… 其中第 3 个是 4。

示例2:

输入:n = 4, a = 2, b = 3, c = 4
输出:6
解释:丑数序列为 2, 3, 4, 6, 8, 9, 12… 其中第 4 个是 6。

示例3:

输入:n = 5, a = 2, b = 11, c = 13
输出:10
解释:丑数序列为 2, 4, 6, 8, 10, 11, 12, 13… 其中第 5 个是 10。

示例4:

输入:n = 1000000000, a = 2, b = 217983653, c = 336916467
输出:1999999984

提示:

1 <= n, a, b, c <= 10^9
1 <= a * b * c <= 10^18
本题结果在 [1, 2 * 10^9] 的范围内

分析:
看提示中n的范围是1~10^9,所以n的取值可以很大,用O(n)复杂度也未必能满足时间复杂度的要求,事实上我试了一下,确实不行,超时了。所以看样子是要用O(logn)的时间复杂度才行,这就让我想到了二分法了。事实上,给定一个数我们是可以计算它是第几个丑数的,只需计算这个数能整除多少个a,b,c,并且根据容斥原理减去重复计算的和加上未计算的即可。具体分析可参考这位大神博主:具体分析
所以我们可以用二分法在可取值的范围内搜索这个数。
代码如下:

class Solution:
    def nthUglyNumber(self, n: int, a: int, b: int, c: int) -> int:
        l, r = 1, 2*10**9
        x, y, z = a * b // math.gcd(a, b), b * c // math.gcd(b, c), a * c // math.gcd(a, c)
        w = x * y // math.gcd(x, y)
        ans = 0
        while l <= r:
            mid = (l + r) // 2
            cnt = mid // a + mid // b + mid // c - mid // x - mid // y - mid // z + mid // w
            if cnt >= n:
                r = mid - 1
                if cnt == n:
                    ans = mid
            else:
                l = mid + 1
        return ans
第三题:5199. 交换字符串中的元素

给你一个字符串 s,以及该字符串中的一些「索引对」数组 pairs,其中 pairs[i] = [a, b] 表示字符串中的两个索引(编号从 0 开始)。
你可以 任意多次交换 在 pairs 中任意一对索引处的字符。
返回在经过若干次交换后,s 可以变成的按字典序最小的字符串。

示例1:

输入:s = “dcab”, pairs = [[0,3],[1,2]]
输出:“bacd”
解释:
交换 s[0] 和 s[3], s = “bcad”
交换 s[1] 和 s[2], s = “bacd”

示例2:

输入:s = “dcab”, pairs = [[0,3],[1,2],[0,2]]
输出:“abcd”
解释:
交换 s[0] 和 s[3], s = “bcad”
交换 s[0] 和 s[2], s = “acbd”
交换 s[1] 和 s[2], s = “abcd”

示例3:

输入:s = “cba”, pairs = [[0,1],[1,2]]
输出:“abc”
解释:
交换 s[0] 和 s[1], s = “bca”
交换 s[1] 和 s[2], s = “bac”
交换 s[0] 和 s[1], s = “abc”

提示:

1 <= s.length <= 10^5
0 <= pairs.length <= 10^5
0 <= pairs[i][0], pairs[i][1] < s.length
s 中只含有小写英文字母

分析:
并查集的题,主要还是要分析好题意啊,这个太重要了!参考:大神解析
代码如下:

import numpy as np
class Solution:
    def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
        def find(a):
            if a == pre[a]:
                return a
            f = find(pre[a])
            pre[a] = f
            return f
        def union(a, b):
            a = find(a)
            b = find(b)
            pre[a] = b
        
        n = len(s)
        pre = [i for i in range(n)]
        for a, b in pairs:
            union(a, b)
        for i in range(n):
            find(i)
        unique_pre = list(set(pre))
        pre_str = {x:'' for x in unique_pre}
        for i in range(n):
            pre_str[pre[i]] += s[i]
        for x in unique_pre:
            pre_str[x] = sorted(pre_str[x])
        pre_cnt = {x:0 for x in unique_pre}
        ans = ''
        for i in range(n):
            c = pre[i]
            ans += pre_str[c][pre_cnt[c]]
            pre_cnt[c] += 1
        return ans
第四题:5200. 项目管理

公司共有 n 个项目和 m 个小组,每个项目要不没有归属,要不就由其中的一个小组负责。
我们用 group[i] 代表第 i 个项目所属的小组,如果这个项目目前无人接手,那么 group[i] 就等于 -1。(项目和小组都是从零开始编号的)
请你帮忙按要求安排这些项目的进度,并返回排序后的项目列表:

  1. 同一小组的项目,排序后在列表中彼此相邻。
  2. 项目之间存在一定的依赖关系,我们用一个列表 beforeItems 来表示,其中beforeItems[i] 表示在进行第 i 个项目前(位于第 i 个项目左侧)应该完成的所有项目。

结果要求:
如果存在多个解决方案,只需要返回其中任意一个即可。
如果没有合适的解决方案,就请返回一个 空列表。

示例1:
leetcode第155场周赛总结_第1张图片

输入:n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3,6],[],[],[]]
输出:[6,3,4,1,5,2,0,7]

示例2:

输入:n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3],[],[4],[]]
输出:[]
解释:与示例 1 大致相同,但是在排序后的列表中,4 必须放在 6 的前面。

提示:

1 <= m <= n <= 3*10^4
group.length == beforeItems.length == n
-1 <= group[i] <= m-1
0 <= beforeItems[i].length <= n-1
0 <= beforeItems[i][j] <= n-1
i != beforeItems[i][j]

分析:
这是一道拓扑排序的问题,但是稍微复杂了一点,因为得分为组内和组间来分别进行拓扑排序。
代码如下:

import queue
import numpy as np
class Solution:
    def sortItems(self, n: int, m: int, group: List[int], beforeItems: List[List[int]]) -> List[int]:
        # 组内拓扑排序
        def get_group_ans(points, edges):
            # 组内建图
            graph = {point:[] for point in points}
            degree = {point:0 for point in points}
            for x, y in edges:
                graph[y].append(x)
                degree[x] += 1
            q = queue.Queue()
            for point in points:
                if degree[point] == 0:
                    q.put(point)
            res = []
            while not q.empty():
                x = q.get()
                res.append(x)
                for y in graph[x]:
                    degree[y] -= 1
                    if degree[y] == 0:
                        q.put(y)
            if len(res) != len(points):
                return None
            return res
        
        
        # 组级别建图
        for i in range(n):
            if group[i] == -1:
                group[i] = m
                m += 1
        group_ids = [i for i in range(m)]
        graph = {group_id:[] for group_id in group_ids}
        degree = {group_id:0 for group_id in group_ids}
        group_points = {group_id:[] for group_id in group_ids}
        group_inner_edges = {group_id:[] for group_id in group_ids}
        for i in range(n):
            groupa = group[i]
            group_points[groupa].append(i)
            for j in beforeItems[i]:
                groupb = group[j]
                if groupa == groupb:
                    group_inner_edges[groupa].append([i, j])
                    continue
                graph[groupb].append(groupa)
                degree[groupa] += 1
        # 组级别拓扑排序
        q = queue.Queue()
        for group_id in group_ids:
            if degree[group_id] == 0:
                q.put(group_id)
        group_res = []
        while not q.empty():
            x = q.get()
            group_res.append(x)
            for y in graph[x]:
                degree[y] -= 1
                if degree[y] == 0:
                    q.put(y)
        if len(group_res) != len(group_ids):
            return []
        ans = []
        for group_id in group_res:
            temp = get_group_ans(group_points[group_id], group_inner_edges[group_id])
            if temp is None:
                return []
            ans += temp
        return ans

你可能感兴趣的:(leetcode第155场周赛总结)