LeetCode 每日一题 2025/6/16-2025/6/22

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

---

目录

• • • [6/16 2016. 增量元素之间的最大差值](#6/16 2016. 增量元素之间的最大差值)
    • [6/17 3405. 统计恰好有 K 个相等相邻元素的数组数目](#6/17 3405. 统计恰好有 K 个相等相邻元素的数组数目)
    • [6/18 2966. 划分数组并满足最大差限制](#6/18 2966. 划分数组并满足最大差限制)
    • [6/19 2294. 划分数组使最大差为 K](#6/19 2294. 划分数组使最大差为 K)
    • [6/20 3443. K 次修改后的最大曼哈顿距离](#6/20 3443. K 次修改后的最大曼哈顿距离)
    • [6/21 3085. 成为 K 特殊字符串需要删除的最少字符数](#6/21 3085. 成为 K 特殊字符串需要删除的最少字符数)
    • [6/22 2138. 将字符串拆分为若干长度为 k 的组](#6/22 2138. 将字符串拆分为若干长度为 k 的组)

6/16 2016. 增量元素之间的最大差值

为了使差值最大 尽量使得numsi小

从左到右 使用minv 记录当前位置之前的最小值

def maximumDifference(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    ans = -1
    minv = nums[0]
    for j in range(1,len(nums)):
        if nums[j]>minv:
            ans=max(ans,nums[j]-minv)
        minv=min(minv,nums[j])
    return ans

---

6/17 3405. 统计恰好有 K 个相等相邻元素的数组数目

k对相邻元素相同 n-1-k对相邻元素不同

不同的可以看作分割线 得到n-k段子数组

C(n-1,k)m(m-1)^(n-k-1)

def countGoodArrays(n, m, k):
    """
    :type n: int
    :type m: int
    :type k: int
    :rtype: int
    """
    MOD=10**9+7
    MX=10**5
    f=[0]*MX
    invf=[0]*MX
    
    f[0]=1
    for i in range(1,MX):
        f[i]=f[i-1]*i%MOD
    invf[MX-1]=pow(f[-1], -1,MOD)
    for i in range(MX-1,0,-1):
        invf[i-1]=invf[i]*i%MOD
    def comb(n,m):
        return f[n]*invf[m]*invf[n-m]%MOD
    return comb(n-1,k)*m*pow(m-1, n-1-k,MOD)%MOD
    

---

6/18 2966. 划分数组并满足最大差限制

排序后 依次分组必定是差值最小的

def divideArray(nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: List[List[int]]
    """
    nums.sort()
    ans = []
    for i in range(0,len(nums),3):
        if nums[i+2]-nums[i]>k:
            return []
        ans.append(nums[i:i+3])
    return ans

---

6/19 2294. 划分数组使最大差为 K

从小到大排列 尽可能排进同一个序列

def partitionArray(nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: int
    """
    nums.sort()
    ans=1
    cur=nums[0]
    for num in nums[1:]:
        if cur+k<num:
            cur=num
            ans+=1
    return ans

---

6/20 3443. K 次修改后的最大曼哈顿距离

东西、南北互不影响

对于一串方向 修改其中较少的方向 可以使距离更远

def maxDistance(s, k):
    """
    :type s: str
    :type k: int
    :rtype: int
    """
    NS,EW=0,0
    ans=0
    for i in range(len(s)):
        if s[i]=='N':
            NS+=1
        elif s[i]=='S':
            NS-=1
        elif s[i]=='E':
            EW+=1
        elif s[i]=='W':
            EW-=1
        ans = max(ans,min(abs(NS)+abs(EW)+2*k,i+1))
    return ans

---

6/21 3085. 成为 K 特殊字符串需要删除的最少字符数

一共26个字母 枚举每个字母成为最少字符的情况

def minimumDeletions(word, k):
    """
    :type word: str
    :type k: int
    :rtype: int
    """
    from collections import defaultdict
    cnt=defaultdict(int)
    for w in word:
        cnt[w]+=1
    ans = len(word)
    for c in cnt.values():
        d = 0
        for w in cnt.values():
            if c>w:
                d+=w
            elif w>c+k:
                d+=w-c-k
        ans=min(ans,d)
    return ans

---

6/22 2138. 将字符串拆分为若干长度为 k 的组

依次取k个生成放入ans 最后如果不足k 则补充fill

def divideString(s, k, fill):
    """
    :type s: str
    :type k: int
    :type fill: str
    :rtype: List[str]
    """
    n=len(s)
    ans=[]
    for i in range(0,n,k):
        if i+k<=n:
            ans.append(s[i:i+k])
        else:
            ans.append(s[i:]+fill*(k-n%k))
    return ans

---