LeetCode 每日一题 2025/4/7-2025/4/13

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

---

4/7 416. 分割等和子集

和是奇数则不可能
dp[x]判断和为x是否取的到

def canPartition(nums):
    """
    :type nums: List[int]
    :rtype: bool
    """
    x=sum(nums)
    if x%2:
        return False
    x//=2
    dp=[False]*(x+1)
    dp[0]=True
    n=len(nums)
    for i in range(n):
        for j in range(x,-1,-1):
            if j-nums[i]>=0:
                dp[j]=dp[j] or dp[j-nums[i]]
    return dp[x]

---

4/8 3396. 使数组元素互不相同所需的最少操作次数

从后往前找到第一次出现相同元素的位置

def minimumOperations(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    n=len(nums)
    s=set()
    loc=n-1
    while loc>=0:
        if nums[loc] in s:
            break
        s.add(nums[loc])
        loc-=1
    return 0 if loc==-1 else loc//3+1

---

4/9 3375. 使数组的值全部为 K 的最少操作次数

如果k大于nums中的最小值 则不可能
只要计算nums中不同数值个数就可以

def minOperations(nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: int
    """
    if min(nums)<k:
        return -1
    s = set(nums)
    ans = len(s)
    if k in s:
        ans-=1
    return ans
    

---

4/10 2999. 统计强大整数的数目

递归
dfs(i,limitl,limith) 表示第i位及之后位置能够组成满足条件的数字数量
limitl,limith分别表示当前位是否受到start,finish的约束
不受约束则可以填入[0,limit]

def numberOfPowerfulInt(start, finish, limit, s):
    """
    :type start: int
    :type finish: int
    :type limit: int
    :type s: str
    :rtype: int
    """
    l,h=str(start),str(finish)
    n=len(h)
    l=l.zfill(n)
    prelen=n-len(s)
    
    mem={}
    def dfs(i,limitl,limith):
        if (i,limitl,limith) in mem:
            return mem[(i,limitl,limith)]
        if i==n:
            return 1
        lo=int(l[i]) if limitl else 0
        hi=int(h[i]) if limith else 9
        ans = 0
        if i<prelen:
            for d in range(lo,min(hi,limit)+1):
                ans += dfs(i+1,limitl and d==lo,limith and d==hi)
        else:
            x=int(s[i-prelen])
            if lo<=x<=min(hi,limit):
                ans=dfs(i+1,limitl and x==lo,limith and x==hi)
        mem[(i,limitl,limith)]=ans
        return ans
    return dfs(0,True,True)

---

4/11 2843. 统计对称整数的数目

考虑两位数 11的倍数
四位数 前两位和等于后两位和

def countSymmetricIntegers(low, high):
    """
    :type low: int
    :type high: int
    :rtype: int
    """
    ans=0
    for i in range(low,high+1):
        if i<100 and i%11==0:
            ans+=1
        if 1000<i<10000:
            if i//1000+i%1000//100==i%100//10+i%10:
                ans+=1
    return ans
        

---

4/12 3272. 统计好整数的数目

列举所有K回文数 对每个数计算排列组合

def countGoodIntegers(n, k):
    """
    :type n: int
    :type k: int
    :rtype: int
    """
    nums=set()
    base=10**((n-1)//2)
    sk=n&1
    for i in range(base,base*10):
        s=str(i)
        s+=s[::-1][sk:]
        num=int(s)
        if num%k==0:
            nums.add(''.join(sorted(s)))
    def fac(num):
        n=1
        for i in range(1,num+1):
            n*=i
        return n
    f=[fac(i) for i in range(n+1)]
    ans=0
    for s in nums:
        cnt=[0]*10
        for c in s:
            cnt[int(c)]+=1
        t = (n-cnt[0])*f[n-1]
        for x in cnt:
            t//=f[x]
        ans+=t
    return ans

---

4/13 1922. 统计好数字的数目

偶数位置有0,2,4,6,8 五种
奇数位置有2,3,5,7 四种

def countGoodNumbers(n):
    """
    :type n: int
    :rtype: int
    """
    MOD=10**9+7
    def func(x,y):
        ans,mul=1,x
        while y>0:
            if y%2==1:
                ans= ans*mul%MOD
            mul = (mul**2)%MOD
            y=y//2
        return ans
    return func(5,(n+1)//2)*func(4,n//2)%MOD

---