LeetCode 每日一题 2024/5/13-2024/5/19

alphaTao

已于 2024-05-19 09:21:56 修改

阅读量260

点赞数 6

分类专栏： Exercise 文章标签： leetcode 算法职场和发展

于 2024-05-18 18:53:03 首次发布

本文链接：https://blog.csdn.net/zkt286468541/article/details/139003067

版权

Exercise 专栏收录该内容

190 篇文章 0 订阅

订阅专栏

记录了初步解题思路以及本地实现代码；并不一定为最优也希望大家能一起探讨一起进步

5/13 994. 腐烂的橘子

BFS广搜每过一分钟可以蔓延一圈
将烂掉的已处理的标记为0 之后不再处理
fresh记录当前存在的新鲜橘子

def orangesRotting(grid):
    """
    :type grid: List[List[int]]
    :rtype: int
    """
    m,n = len(grid),len(grid[0])
    l=[]
    fresh = 0
    for i in range(m):
        for j in range(n):
            if grid[i][j]==2:
                l.append((i,j))
                grid[i][j]=0
            elif grid[i][j]==1:
                fresh+=1
    step = 0
    while l and fresh:
        tmp = []
        for x,y in l:
            for sx,sy in [(1,0),(0,1),(-1,0),(0,-1)]:
                nx,ny=x+sx,y+sy
                if 0<=nx<m and 0<=ny<n and grid[nx][ny]==1:
                    tmp.append((nx,ny))
                    grid[nx][ny]=0
                    fresh -=1
        step+=1
        l=tmp
    return step if fresh==0 else -1

5/14 2244. 完成所有任务需要的最少轮数

统计相同任务出现的次数如果只有1次则无法完成
为了轮数最少尽量完成3个相同级别的任务
如果同一级别出现次数v为3的倍数那么增加v//3轮
如果余数为1 那么需要减少一次3 增加两次2 v//3-1+2 = v//3+1
如果余数为2 那么需要增加1次2 v//3+1

def minimumRounds(tasks):
    """
    :type tasks: List[int]
    :rtype: int
    """
    m = {}
    for t in tasks:
        m[t] = m.get(t,0)+1
    ans = 0
    for v in m.values():
        if v==1:
            return -1
        if v%3==0:
            ans += v//3
        else:
            ans += v//3+1
    return ans

5/15 2589. 完成所有任务的最少时间

run[x]用来记录x时间点是否运行
将结束时间从小到大排序
判断当前任务在时间区间内是否运行结束
如果没有则尽量从后往前运行任务
因为靠后的更有可能被后续任务重叠

def findMinimumTime(tasks):
    """
    :type tasks: List[List[int]]
    :rtype: int
    """
    tasks.sort(key=lambda x:x[1])
    run = [0]*(tasks[-1][1]+1)
    for start,end,d in tasks:
        d -= sum(run[start:end+1])
        if d<=0:
            continue
        for i in range(end,start-1,-1):
            if run[i]==1:
                continue
            run[i]=1
            d-=1
            if d==0:
                break
    return sum(run)

5/16 1953. 你可以工作的最大周数

假设所有工作和为s 项目最多工作m
如果m比其他剩余工作量都多
即m>s-m+1 一个其他工作对应m中的一项工作 m中还能在工作一周剩余的就都是m工作了无法继续
2*(s-m)+1
如果m<=s-m+1 间隔安排即可完成所有工作 s

def numberOfWeeks(milestones):
    """
    :type milestones: List[int]
    :rtype: int
    """
    s=sum(milestones)
    m=max(milestones)
    return  s if m<=s-m+1 else 2*(s-m)+1

5/17 826. 安排工作以达到最大收益

将工作收益从大到小难度从小到大排列
将工人能力从高到低排列
依序判断当前工作能有多少工人处理

def maxProfitAssignment(difficulty, profit, worker):
    """
    :type difficulty: List[int]
    :type profit: List[int]
    :type worker: List[int]
    :rtype: int
    """
    n,m=len(difficulty),len(worker)
    work = [(difficulty[x],profit[x])for x in range(n)]
    work.sort(key=lambda x:(-x[1],x[0]))
    worker.sort(reverse=True)
    loc = 0
    ans = 0
    for diff,pro in work:
        if diff>worker[loc]:
            continue
        while loc<m and diff<=worker[loc]:
            ans += pro
            loc+=1
        if loc==m:
            break
    return ans

5/18 2644. 找出可整除性得分最大的整数

将divisors去重从小到大考虑

def maxDivScore(nums, divisors):
    """
    :type nums: List[int]
    :type divisors: List[int]
    :rtype: int
    """
    divisors=list(set(divisors))
    divisors.sort()
    ans = divisors[0]
    cur = 0
    for d in divisors:
        tmp = 0
        for num in nums:
            if num%d==0:
                tmp+=1
        if tmp>cur:
            ans = d
            cur = tmp
    return ans

5/19 1535. 找出数组游戏的赢家

arr中有n个数
如果赢得次数大于等于n-1次就是arr中的最大值
从头遍历数组
记录当前最大值以及途中遇到比它小的数个数
如果满足了k则返回
如果遍历完了则当前数值为最大值必定是答案

def getWinner(arr, k):
    """
    :type arr: List[int]
    :type k: int
    :rtype: int
    """
    n=len(arr)
    if k>=n-1:
        return max(arr)
    cur = arr[0]
    num = 0
    for v in arr[1:]:
        if cur>v:
            num+=1
        else:
            cur = v
            num = 1
        if num==k:
            return cur
    return cur