leetcode 第 36 场双周赛

最新推荐文章于 2024-07-13 22:20:33 发布

jhaos

最新推荐文章于 2024-07-13 22:20:33 发布

阅读量160

点赞数

分类专栏： leetcode 文章标签：算法 python leetcode 数据结构

本文链接：https://blog.csdn.net/jhaos/article/details/108915114

版权

leetcode 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

本文介绍了如何设计一个停车场系统，包括初始化车位数量和车辆停放功能。系统根据车辆类型分配合适的车位，并能处理满员情况。此外，文章还讨论了三个不同的信息技术应用场景：监控频繁使用员工卡的员工、恢复特定行和列和和的矩阵以及确定最繁忙的服务器。通过这些案例，展示了如何利用数据结构和算法解决实际问题。

摘要由CSDN通过智能技术生成

设计停车系统

请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位：大，中和小，每种尺寸分别有固定数目的车位。

请你实现 ParkingSystem 类：

ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 类，三个参数分别对应每种停车位的数目。
bool addCar(int carType) 检车是否有 carType 对应的停车位。 carType 有三种类型：大，中，小，分别用数字 1， 2 和 3 表示。一辆车只能停在  carType 对应尺寸的停车位中。如果没有空车位，请返回 false ，否则将该车停入车位并返回 true 。

示例 1：

输入：
[“ParkingSystem”, “addCar”, “addCar”, “addCar”, “addCar”]
[[1, 1, 0], [1], [2], [3], [1]]
输出：
[null, true, true, false, false]

解释：
ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);
parkingSystem.addCar(1); // 返回 true ，因为有 1 个空的大车位
parkingSystem.addCar(2); // 返回 true ，因为有 1 个空的中车位
parkingSystem.addCar(3); // 返回 false ，因为没有空的小车位
parkingSystem.addCar(1); // 返回 false ，因为没有空的大车位，唯一一个大车位已经被占据了

提示：

0 <= big, medium, small <= 1000
carType 取值为 1， 2 或 3
最多会调用 addCar 函数 1000 次

代码实现

class ParkingSystem:

    def __init__(self, big: int, medium: int, small: int):
        self.big = big
        self.medium=medium
        self.small = small


    def addCar(self, carType: int) -> bool:
        if carType==3:
            self.small -=1
            if self.small<0:
                self.small=0
                return False
            else:
                return True
        if carType==2:
            self.medium-=1
            if self.medium<0:
                self.medium=0
                return False
            else:
                return True
        if carType==1:
            self.big-=1
            if self.big<0:
                self.big=0
                return False
            else:
                return True



# Your ParkingSystem object will be instantiated and called as such:
# obj = ParkingSystem(big, medium, small)
# param_1 = obj.addCar(carType)

警告一小时内使用相同员工卡大于等于三次的人

力扣公司的员工都使用员工卡来开办公室的门。每当一个员工使用一次他的员工卡，安保系统会记录下员工的名字和使用时间。如果一个员工在一小时时间内使用员工卡的次数大于等于三次，这个系统会自动发布一个警告。

给你字符串数组 keyName 和 keyTime ，期中 [keyName[i], keyTime[i]] 对应一个人的名字和他在某一天内使用员工卡的时间。

使用时间的格式是 24小时制，形如 “HH:MM” ，比方说 “23:51” 和 “09:49” 。

请你返回去重后的收到系统警告的员工名字，将它们按字典序升序排序后返回。

请注意 “10:00” - “11:00” 视为一个小时时间范围内，而 “23:51” - “00:10” 不被视为一小时内，因为系统记录的是某一天内的使用情况。

示例 1：

输入：keyName = [“daniel”,“daniel”,“daniel”,“luis”,“luis”,“luis”,“luis”], keyTime = [“10:00”,“10:40”,“11:00”,“09:00”,“11:00”,“13:00”,“15:00”]
输出：[“daniel”]
解释：“daniel” 在一小时内使用了 3 次员工卡（“10:00”，“10:40”，“11:00”）。

示例 2：

输入：keyName = [“alice”,“alice”,“alice”,“bob”,“bob”,“bob”,“bob”], keyTime = [“12:01”,“12:00”,“18:00”,“21:00”,“21:20”,“21:30”,“23:00”]
输出：[“bob”]
解释：“bob” 在一小时内使用了 3 次员工卡（“21:00”，“21:20”，“21:30”）。

示例 3：

输入：keyName = [“john”,“john”,“john”], keyTime = [“23:58”,“23:59”,“00:01”]
输出：[]

示例 4：

输入：keyName = [“leslie”,“leslie”,“leslie”,“clare”,“clare”,“clare”,“clare”], keyTime = [“13:00”,“13:20”,“14:00”,“18:00”,“18:51”,“19:30”,“19:49”]
输出：[“clare”,“leslie”]

提示：

1 <= keyName.length, keyTime.length <= 105
keyName.length == keyTime.length
keyTime 格式为 "HH:MM" 。
保证 [keyName[i], keyTime[i]] 形成的二元对 互不相同 。
1 <= keyName[i].length <= 10
keyName[i] 只包含小写英文字母。

代码实现

class Solution:
    def alertNames(self, keyName: List[str], keyTime: List[str]) -> List[str]:
        from collections import defaultdict
        c = defaultdict(list)
        for i in range(len(keyName)):
            c[keyName[i]].append(list(map(int,keyTime[i].split(':'))))
        se = sorted(set(keyName))
        re = []
        for t in se:
            temp = c[t]
            if len(temp)<3:
                continue
            temp.sort(key=lambda x:(x[0],x[1]))
            for i in range(len(temp)-2):
                j = i+1
                x,y = temp[i]
                count=1
                while j<len(temp):
                    a,b = temp[j]
                    if a-x<=1:
                        su=(a-x)*60+b-y
                        if su<=60:
                            count+=1
                        else:
                            break
                    else:
                        break
                    j+=1
                if count>=3:
                    re.append(t)
                    break
        return re

给定行和列的和求可行矩阵

给你两个非负整数数组 rowSum 和 colSum ，其中 rowSum[i] 是二维矩阵中第 i 行元素的和， colSum[j] 是第 j 列元素的和。换言之你不知道矩阵里的每个元素，但是你知道每一行和每一列的和。

请找到大小为 rowSum.length x colSum.length 的任意非负整数矩阵，且该矩阵满足 rowSum 和 colSum 的要求。

请你返回任意一个满足题目要求的二维矩阵，题目保证存在至少一个可行矩阵。

示例 1：

输入：rowSum = [3,8], colSum = [4,7]
输出：[[3,0],
[1,7]]
解释：
第 0 行：3 + 0 = 0 == rowSum[0]
第 1 行：1 + 7 = 8 == rowSum[1]
第 0 列：3 + 1 = 4 == colSum[0]
第 1 列：0 + 7 = 7 == colSum[1]
行和列的和都满足题目要求，且所有矩阵元素都是非负的。
另一个可行的矩阵为：[[1,2],
[3,5]]

示例 2：

输入：rowSum = [5,7,10], colSum = [8,6,8]
输出：[[0,5,0],
[6,1,0],
[2,0,8]]

示例 3：

输入：rowSum = [14,9], colSum = [6,9,8]
输出：[[0,9,5],
[6,0,3]]

示例 4：

输入：rowSum = [1,0], colSum = [1]
输出：[[1],
[0]]

示例 5：

输入：rowSum = [0], colSum = [0]
输出：[[0]]

提示：

1 <= rowSum.length, colSum.length <= 500
0 <= rowSum[i], colSum[i] <= 108
sum(rows) == sum(columns)

代码实现

class Solution:
    def restoreMatrix(self, rowSum: List[int], colSum: List[int]) -> List[List[int]]:
        m,n = len(rowSum),len(colSum)
        re = [[0]*n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                re[i][j] = min(rowSum[i],colSum[j])
        for i in range(m):
            t = [(re[i][j],j) for j in range(n)]
            t.sort()
            s1 = rowSum[i]
            sx = [0]*n
            while s1>0:
                cur,idx = t.pop()
                if s1-cur>0 and colSum[idx]-cur>0:
                    sx[idx]=cur
                else:
                    sx[idx]=min(s1, colSum[idx])
                colSum[idx]-=sx[idx]
                s1-=sx[idx]
            re[i] = sx
        return re

找到处理最多请求的服务器

你有 k 个服务器，编号为 0 到 k-1 ，它们可以同时处理多个请求组。每个服务器有无穷的计算能力但是不能同时处理超过一个请求。请求分配到服务器的规则如下：

第 i （序号从 0 开始）个请求到达。
如果所有服务器都已被占据，那么该请求被舍弃（完全不处理）。
如果第 (i % k) 个服务器空闲，那么对应服务器会处理该请求。
否则，将请求安排给下一个空闲的服务器（服务器构成一个环，必要的话可能从第 0 个服务器开始继续找下一个空闲的服务器）。比方说，如果第 i 个服务器在忙，那么会查看第 (i+1) 个服务器，第 (i+2) 个服务器等等。

给你一个严格递增的正整数数组 arrival ，表示第 i 个任务的到达时间，和另一个数组 load ，其中 load[i] 表示第 i 个请求的工作量（也就是服务器完成它所需要的时间）。你的任务是找到最繁忙的服务器。最繁忙定义为一个服务器处理的请求数是所有服务器里最多的。

请你返回包含所有最繁忙服务器序号的列表，你可以以任意顺序返回这个列表。

示例 1：

输入：k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3]
输出：[1]
解释：
所有服务器一开始都是空闲的。
前 3 个请求分别由前 3 台服务器依次处理。
请求 3 进来的时候，服务器 0 被占据，所以它呗安排到下一台空闲的服务器，也就是服务器 1 。
请求 4 进来的时候，由于所有服务器都被占据，该请求被舍弃。
服务器 0 和 2 分别都处理了一个请求，服务器 1 处理了两个请求。所以服务器 1 是最忙的服务器。

示例 2：

输入：k = 3, arrival = [1,2,3,4], load = [1,2,1,2]
输出：[0]
解释：
前 3 个请求分别被前 3 个服务器处理。
请求 3 进来，由于服务器 0 空闲，它被服务器 0 处理。
服务器 0 处理了两个请求，服务器 1 和 2 分别处理了一个请求。所以服务器 0 是最忙的服务器。

示例 3：

输入：k = 3, arrival = [1,2,3], load = [10,12,11]
输出：[0,1,2]
解释：每个服务器分别处理了一个请求，所以它们都是最忙的服务器。

示例 4：

输入：k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]
输出：[1]

示例 5：

输入：k = 1, arrival = [1], load = [1]
输出：[0]

提示：

1 <= k <= 105
1 <= arrival.length, load.length <= 105
arrival.length == load.length
1 <= arrival[i], load[i] <= 109
arrival 保证 严格递增 。

代码实现

class Solution:
    '''
    @author: @richenyunqi from leetcode
    '''
    def busiestServers(self, ks: int, a: List[int], d: List[int]) -> List[int]:
        from sortedcontainers import SortedList
        ans=[0]*ks
        pq=[]
        fu=SortedList(range(ks))
        v=0
        for i,j in zip(a,d):
            heappush(pq,[i,1,i+j,v])
            v+=1
        # print(pq,fu)
        while pq:
            i,k,j,num=heappop(pq)
            if k==1 and fu:
                v=fu.bisect_left(num%ks)
                if v==len(fu):
                    v=0
                v=fu[v]
                fu.remove(v)
                ans[v]+=1
                heappush(pq,[j,0,v,num])
            elif k==0:
                fu.add(j)
            # print(pq,fu)
        # print(ans)
        t=max(ans)
        return [i for i in range(ks) if ans[i]==t]

jhaos

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
leetcode 第 36 场双周赛

设计停车系统请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位：大，中和小，每种尺寸分别有固定数目的车位。请你实现 ParkingSystem 类：ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 类，三个参数分别对应每种停车位的数目。bool addCar(int carType) 检车是否有 carType 对应的停车位。 carType 有三种类型：大，中，小，分别用数字 1， 2 和 3 表示。一.
复制链接

扫一扫