LeetCode 每日一题 2023/5/15-2023/5/21

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

---

5/15 1072. 按列翻转得到最大值等行数

将每一行的首个元素反转为0 如果一整行的元素都相同
则说明两行可以翻转成相同状态
找到状态相同的最多行数

def maxEqualRowsAfterFlips(matrix):
    """
    :type matrix: List[List[int]]
    :rtype: int
    """
    from collections import defaultdict
    n,m=len(matrix),len(matrix[0])
    mem=defaultdict(int)
    for i in range(n):
        tag = ""
        for j in range(m):
            tag+=str((0^matrix[i][0])^matrix[i][j])
        mem[tag]+=1
    return max(mem.values())

---

5/16 1335. 工作计划的最低难度

将数组分为d段 每一段不能为空
dfs(d,ind)定义用d天完成0~ind的工作
这一天最多可以完成d-1~ind的工作
考虑各种情况 k~ind为当前工作 mx记录最大难度

def minDifficulty(jobDifficulty, d):
    """
    :type jobDifficulty: List[int]
    :type d: int
    :rtype: int
    """
    n = len(jobDifficulty)
    if d>n:
        return -1
    mem = {}
    
    def dfs(d,ind):
        if (d,ind) in mem:
            return mem[(d,ind)]
        if d==0:
            return max(jobDifficulty[:ind+1])
        ans = float("inf")
        mx = 0
        for k in range(ind,d-1,-1):
            mx = max(mx,jobDifficulty[k])
            ans = min(ans,dfs(d-1,k-1)+mx)
        mem[(d,ind)] = ans
        return ans
    return dfs(d-1,n-1)

---

5/17 2446. 判断两个事件是否存在冲突

将时间转换成分钟 比较一个end和另一个start的大小

def haveConflict(event1, event2):
    """
    :type event1: List[str]
    :type event2: List[str]
    :rtype: bool
    """
    def trans(s):
        l = s.split(":")
        return 60*int(l[0])+int(l[1])
    s1,e1 = trans(event1[0]),trans(event1[1])
    s2,e2 = trans(event2[0]),trans(event2[1])
    if e1<s2 or e2<s1:
        return False
    return True

---

5/18 1073. 负二进制数相加

当前位x=arr1[i]+arr2[i]+c
如果x=0,1 当前位为x c=0
x=2 当前位为x-2 c=-1
x=-1 当前位为1 c=1

def addNegabinary(arr1, arr2):
    """
    :type arr1: List[int]
    :type arr2: List[int]
    :rtype: List[int]
    """
    i,j=len(arr1)-1,len(arr2)-1
    ans = []
    c = 0
    
    while i>=0 or j>=0 or c:
        x = c
        if i>=0:
            x+=arr1[i]
        if j>=0:
            x+=arr2[j]
            
        if x>=2:
            ans.append(x-2)
            c = -1
        elif x>=0:
            ans.append(x)
            c = 0
        else:
            ans.append(1)
            c = 1
        i-=1
        j-=1
        
    while len(ans)>1 and ans[-1]==0:
        ans.pop()
    return ans[::-1]

---

5/19 1079. 活字印刷

统计每个字母的出现次数
回溯判断可能情况

def numTilePossibilities(tiles):
    """
    :type tiles: str
    :rtype: int
    """
    from collections import Counter
    def dfs(cnt):
        ans = 0
        for i,x in cnt.items():
            if x>0:
                ans +=1
                cnt[i]-=1
                ans += dfs(cnt)
                cnt[i]+=1
        return ans
    cnt = Counter(tiles)
    return dfs(cnt)

---

5/20 1373. 二叉搜索子树的最大键值和

深搜dfs某个节点node
返回该子树是否是二叉搜索树,子树内最大值，最小值以及所有节点和

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def maxSumBST(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    global ans
    ans = 0
    def dfs(node):
        global ans
        if node is None:
            return True,float("-inf"),float("inf"),0
        lbst,lmax,lmin,lsum = dfs(node.left)
        rbst,rmax,rmin,rsum = dfs(node.right)
        if lbst and rbst and lmax<node.val and rmin>node.val:
            s = lsum+rsum+node.val
            ans = max(ans,s)
            return True,max(rmax,node.val),min(lmin,node.val),s
        return False,0,0,0
    dfs(root)
    return ans

---

5/21 LCP 33. 蓄水

升级之后在蓄水
枚举蓄水次数k 统计每个水桶水缸在k此完成蓄水需要的升级次数

def storeWater(bucket, vat):
    """
    :type bucket: List[int]
    :type vat: List[int]
    :rtype: int
    """
    n = len(bucket)
    maxk = max(vat)
    if maxk==0:
        return 0
    ans = float("inf")
    for k in range(1,maxk+1):
        up = 0
        for i in range(n):
            up += max(0,(vat[i]+k-1)//k-bucket[i])
        ans=min(ans,up+k)
    return ans

---