LeetCode 每日一题 2023/5/1-2023/5/7

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

---

5/1 1376. 通知所有员工所需的时间

m[x]存储x的直属下属
t[x]记录消息到达x需要的时间
广搜

def numOfMinutes(n, headID, manager, informTime):
    """
    type n: int
    type headID: int
    type manager: List[int]
    type informTime: List[int]
    :rtype: int
    """
    from collections import defaultdict
    m=defaultdict(list)
    t={}
    t[headID] = 0
    for i,v in enumerate(manager):
        m[v].append(i)
        
    l = [headID]
    ans = 0
    while l:
        tmp=[]
        for x in l:
            for nxt in m[x]:
                t[nxt] = t[x]+informTime[x]
                ans = max(ans,t[nxt])
                tmp.append(nxt)
        l=tmp
    return ans

---

5/2 970. 强整数

列出x^i y^j<=bound的所有数
两两相加遍历

def powerfulIntegers(x, y, bound):
    """
    :type x: int
    :type y: int
    :type bound: int
    :rtype: List[int]
    """
    lx,ly = [],[]
    cur = 1
    while cur<=bound:
        lx.append(cur)
        cur*=x
        if x==1:
            break
    cur = 1
    while cur<=bound:
        ly.append(cur)
        cur*=y
        if y==1:
            break
    s = set()
    for vx in lx:
        for vy in ly:
            if vx+vy<=bound:
                s.add(vx+vy)
            else:
                break
    return sorted(list(s))

---

5/3 1003. 检查替换后的词是否有效

遍历去除每个单词后的情况

def isValid(s):
    """
    :type s: str
    :rtype: bool
    """
    if len(s)%3>0:
        return False
    st = []
    for c in s:
        st.append(c)
        if len(st)>=3 and ''.join(st[-3:])=="abc":
            st = st[:-3]
    return len(st)==0

---

5/4 2106. 摘水果

假设摘果子区间是[l,r]
如果start<=l 则走过的路最少为r-start
如果start>=r 走过的路最少是start-l
如果l<start<r 走过的路r-l+min(r-start,start-l)
综合三种情况 可以总结为 r-l+min(|r-start|,|start-l|)
固定r 移动左端点l
如果start<=l 随着l增大 步数不会变化
如果start>l 随着l增大 步数减小
只考虑有水果的点 i,j为左右水果的点
往右移动j 计算当前最小步数 如果大于k 则将i也往右移动

def maxTotalFruits(fruits, startPos, k):
    """
    :type fruits: List[List[int]]
    :type startPos: int
    :type k: int
    :rtype: int
    """
    ans = 0
    cur = 0
    i = 0
    for j,(r,f) in enumerate(fruits):
        cur+=f
        while i<=j and r-fruits[i][0]+min(abs(startPos-r),abs(startPos-fruits[i][0]))>k:
            cur-=fruits[i][1]
            i+=1
        ans = max(ans,cur)
    return ans

---

5/5 2432. 处理用时最长的那个任务的员工

按时间从大到小排序 按序号从小到大排序

def hardestWorker(n, logs):
    """
    :type n: int
    :type logs: List[List[int]]
    :rtype: int
    """
    l = []
    pre = 0
    for ind,t in logs:
        l.append([ind,t-pre])
        pre = t
    l.sort(key=lambda x:(-x[1],x[0]))
    return l[0][0]

---

5/6 1419. 数青蛙

记录当前没有叫完的青蛙 和各个叫声当前青蛙数
如果是c说明新加入一只青蛙 cur+1
如果是k说明有一只青蛙叫完了 cur-1
如果叫声前一个叫声青蛙为0 说明异常

def minNumberOfFrogs(croakOfFrogs):
    """
    :type croakOfFrogs: str
    :rtype: int
    """
    if len(croakOfFrogs)%5>0:
        return -1
    m = {"c":0,"r":1,"o":2,"a":3,"k":4}
    l = [0]*5
    cur = 0
    ans = 0
    for v in croakOfFrogs:
        ind = m[v]
        if ind>0:
            if l[ind-1]==0:
                return -1
            l[ind-1]-=1
            l[ind]+=1
        if v=="c":
            l[0]+=1
            cur+=1
            ans = max(ans,cur)
        elif v=="k":
            cur-=1
    if sum(l[:-1])>0:
        return -1
    return ans

---

5/7 1010. 总持续时间可被 60 整除的歌曲

计算每首歌时间除以60的余数
除了0和30 需要自身相同余数的时间组合
其余x的需要同60-x的匹配 将两种情况的个数相乘即可
只需考虑[0~30]

def numPairsDivisibleBy60(time):
    """
    :type time: List[int]
    :rtype: int
    """
    from collections import defaultdict
    m = defaultdict(int)
    for t in time:
        m[t%60]+=1
    ans = 0
    for t,v in m.items():
        if t>30:
            continue
        if t==0 or t==30:
            ans += v*(v-1)//2
        else:
            ans += v*m[60-t]
    return ans

---