LeetCode 每日一题 2025/5/19-2025/5/25

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

---

5/19 3024. 三角形类型

三条边从小到大排序 判断

def triangleType(nums):
    """
    :type nums: List[int]
    :rtype: str
    """
    nums.sort()
    if nums[0]+nums[1]<=nums[2]:
        return "none"
    if nums[0]==nums[2]:
        return "equilateral"
    elif nums[1]==nums[0] or nums[1]==nums[2]:
        return "isosceles"
    else:
        return "scalene"
    

---

5/20 3355. 零数组变换 I

将所有queries中的数都+1得到cur nums所有数不大于cur既满足
change[i]记录从左到右的cur在此处的变动

def isZeroArray(nums, queries):
    """
    :type nums: List[int]
    :type queries: List[List[int]]
    :rtype: bool
    """
    change={}
    for v in queries:
        l,r=v[0],v[1]
        change[l]=change.get(l,0)+1
        change[r+1]=change.get(r+1,0)-1
    cur=0
    for i in range(len(nums)):
        if i in change:
            cur+=change[i]
        if cur<nums[i]:
            return False
    return True

---

5/21 3356. 零数组变换 II

依次进行操作
并从左往右判断nums当前位置是否可以归零
如果可以 则继续在nums往右
如果不可以 则需要继续操作queries往右

def minZeroArray(nums, queries):
    """
    :type nums: List[int]
    :type queries: List[List[int]]
    :rtype: int
    """
    n=len(nums)
    change={}
    k=0
    cur=0
    for i in range(n):
        num=nums[i]
        cur += change.get(i,0)
        while k<len(queries) and cur<num:
            l,r,v=queries[k]
            change[l]=change.get(l,0)+v
            change[r+1]=change.get(r+1,0)-v
            if l<=i<=r:
                cur+=v
            k+=1
        if cur<num:
            return -1
    return k

---

5/22 3362. 零数组变换 III

从左往右考虑nums 将queries根据起始点排序
对于nums[i] 优先选取nums[i]在query中并且右端点更靠后的
用最大堆存放待选query

def maxRemoval(nums, queries):
    """
    :type nums: List[int]
    :type queries: List[List[int]]
    :rtype: int
    """
    import heapq
    queries.sort(key=lambda x:x[0])
    h=[]
    change={}
    j=0
    cur=0
    for i,num in enumerate(nums):
        cur+=change.get(i,0)
        while j<len(queries) and queries[j][0]==i:
            heapq.heappush(h, -queries[j][1])
            j+=1
        while cur<num and h and -h[0]>=i:
            cur+=1
            v=-heapq.heappop(h)+1
            change[v] = change.get(v,0)-1
        if cur<num:
            return -1
    return len(h)

---

5/23 3068. 最大节点价值之和

根据异或的性质 如果异或偶数次则值不变
对于树上的任意两个节点 将联通他们的边都进行一次操作
那么除了开始和结束的点 中间节点都被异或两次 值不变
所以可以异或任意两个点的值
将所有点操作后增加的值从大到小排序
每次选择最大的两个值 如果大于零则可以操作

def maximumValueSum(nums, k, edges):
    """
    :type nums: List[int]
    :type k: int
    :type edges: List[List[int]]
    :rtype: int
    """
    ans=sum(nums)
    diff = [(x^k)-x for x in nums]
    diff.sort(reverse=True)
    i=0
    while i<len(nums)-1 and diff[i]+diff[i+1]>0:
        ans += diff[i]+diff[i+1]
        i+=2
    return ans
            

---

5/24 2942. 查找包含给定字符的单词

依次判断

def findWordsContaining(words, x):
    """
    :type words: List[str]
    :type x: str
    :rtype: List[int]
    """
    ans=[]
    for i,w in enumerate(words):
        if x in w:
            ans.append(i)
    return ans

---

5/25 2131. 连接两字母单词得到的最长回文串

统计单词出现次数
如果反转后一致则判断是否是奇数个 奇数个可以由中心单词

def longestPalindrome(words):
    """
    :type words: List[str]
    :rtype: int
    """
    from collections import Counter 
    fre=Counter(words)
    mid=0
    ans=0
    for w,cnt in fre.items():
        rev = w[1]+w[0]
        if w==rev:
            if cnt%2==1:
                mid=1
            ans+=2*(cnt//2*2)
        elif w>rev:
            ans+=4*min(fre[w],fre[rev])
    return ans+2 if mid else ans
            

---