LeetCode 每日一题 2024/5/6-2024/5/12

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

---

5/6 741. 摘樱桃

从起点到终点 再返回起点
可以看做两个人同时从起点到终点走两条路所能拿到的樱桃总和
假设两人同时走了k步 那么坐标为(x1,k-x1) (x2,k-x2)
设dp[k][x1][x2]表示两人从此时到终点能够摘到的樱桃之和最大值
倒序去除掉k 并假设x1<=x2

def cherryPickup(grid):
    """
    :type grid: List[List[int]]
    :rtype: int
    """
    n = len(grid)
    dp = [[float('-inf')]*n for _ in range(n)]
    dp[0][0] = grid[0][0]
    for k in range(1,2*n-1):
        for x1 in range(min(k,n-1),max(k-n,-1),-1):
            for x2 in range(min(k,n-1),x1-1,-1):
                y1,y2=k-x1,k-x2
                if grid[x1][y1]==-1 or grid[x2][y2]==-1:
                    dp[x1][x2] = float('-inf')
                    continue
                v = dp[x1][x2]
                if x1>0:
                    v = max(v,dp[x1-1][x2])
                if x2>0:
                    v = max(v,dp[x1][x2-1])
                if x1>0 and x2>0:
                    v = max(v,dp[x1-1][x2-1])
                v += grid[x1][y1]
                if x1!=x2:
                    v += grid[x2][y2]
                dp[x1][x2] = v
    return max(dp[-1][-1],0)

---

5/7 1463. 摘樱桃 II

矩阵m*n
机器人每走一步必定下一行
所以两机器人每一步之后都在同一行
dp[k][y1][y2]表示在k行两个机器人分别在位置(k,y1) (k,y2)情况下能够得到的最大值
k=0为第一行 y1=0 y2=n-1
遍历每一行k=1~m-1
当前行增加grid[k][y1]+grid[k][y2]
如果在同一个位置y1=y2那么只加一次
y可以由上一行y-1,y,y+1三个位置走过来
考虑各个位置最大值dp[k][y1][y2]
最后找到dp[m-1][y1][y2]的最大值即可

def cherryPickup(grid):
    """
    :type grid: List[List[int]]
    :rtype: int
    """
    m,n=len(grid),len(grid[0])
    dp = [[[float("-inf")]*n for _ in range(n)] for _ in range(m)]
    dp[0][0][n-1]=grid[0][0]+grid[0][n-1]
    for k in range(1,m):
        for y1 in range(n):
            for y2 in range(y1,n):
                v = grid[k][y1]
                if y1!=y2:
                    v += grid[k][y2]
                pre = dp[k-1][y1][y2]
                if y1>0:
                    pre = max(pre,dp[k-1][y1-1][y2])
                    if y2>0:
                        pre = max(pre,dp[k-1][y1-1][y2-1])
                    if y2<n-1:
                        pre = max(pre,dp[k-1][y1-1][y2+1])
                if y1<n-1:
                    pre = max(pre,dp[k-1][y1+1][y2])
                    if y2>0:
                        pre = max(pre,dp[k-1][y1+1][y2-1])
                    if y2<n-1:
                        pre = max(pre,dp[k-1][y1+1][y2+1])
                if y2>0:
                    pre = max(pre,dp[k-1][y1][y2-1])
                if y2<n-1:
                    pre = max(pre,dp[k-1][y1][y2+1])
                dp[k][y1][y2] = pre+v
    ans = 0
    for i in range(n):
        ans = max(ans,max(dp[m-1][i]))
    return ans

---

5/8 2079. 给植物浇水

依次给植物浇水 如果水不够了当前位置为x
说明在x-1位置就需要重新灌水
2*x步重新灌水并回到x-1位置
一共n个植物每次一步需要n步

def wateringPlants(plants, capacity):
    """
    :type plants: List[int]
    :type capacity: int
    :rtype: int
    """
    n=len(plants)
    cur = capacity
    ans = n
    for i in range(n):
        print(i,cur)
        if plants[i]<=cur:
            cur -= plants[i]
        else:
            cur = capacity-plants[i]
            ans +=2*i
    return ans

---

5/9 2105. 给植物浇水 II

模拟两人浇水 一个从左 一个从右
直到两人相遇

def minimumRefill(plants, capacityA, capacityB):
    """
    :type plants: List[int]
    :type capacityA: int
    :type capacityB: int
    :rtype: int
    """
    n = len(plants)
    l,r = 0,n-1
    a,b = capacityA,capacityB
    ans = 0
    while l<=r:
        if l==r:
            if a>=b:
                if a<plants[l]:
                    ans+=1
            else:
                if b<plants[l]:
                    ans+=1
            break
        if a>=plants[l]:
            a-=plants[l]
        else:
            ans +=1
            a = capacityA-plants[l]
        if b>=plants[r]:
            b-=plants[r]
        else:
            ans+=1
            b = capacityB-plants[r]
        l+=1
        r-=1
    return ans

---

5/10 2960. 统计已测试设备

模拟 ans为测试次数

def countTestedDevices(batteryPercentages):
    """
    :type batteryPercentages: List[int]
    :rtype: int
    """
    ans=0
    for v in batteryPercentages:
        if v>ans:
            ans+=1
    return ans

---

5/11 2391. 收集垃圾的最少总时间

因为垃圾车只能有一辆可以工作
可以看做三种垃圾依次处理
cur记录三辆车当前位置

def garbageCollection(garbage, travel):
    """
    :type garbage: List[str]
    :type travel: List[int]
    :rtype: int
    """
    ans = 0
    cur={"G":0,"P":0,"M":0}
    for i,g in enumerate(garbage):
        for v in g:
            while cur[v]<i:
                ans += travel[cur[v]]
                cur[v]+=1
            ans+=1
    return ans

---

5/12 1553. 吃掉 N 个橘子的最少天数

三种情况 记忆化搜索

def minDays(n):
    """
    :type n: int
    :rtype: int
    """
    mem={}
    mem[0]=0
    mem[1]=1
    def func(num):
        if num in mem:
            return mem[num]
        v = min(func(num//2)+num%2,func(num//3)+num%3)+1
        mem[num]=v
        return v
    return func(n)

---