LeetCode 每日一题 2023/2/20-2023/2/26

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

---

2/20 2347. 最好的扑克手牌

分别判断每一种情况
将数组去重 根据个数来判断

def bestHand(ranks, suits):
    """
    :type ranks: List[int]
    :type suits: List[str]
    :rtype: str
    """
    if len(set(suits))==1:
        return "Flush"
    m = {}
    for r in ranks:
        m[r] = m.get(r,0)+1
    if len(m)==5:
        return "High Card"
    ans = "Pair"
    for v in m.values():
        if v>=3:
            ans = "Three of a Kind"
    return ans

---

2/21 1326. 灌溉花园的最少水龙头数目

记录每个点能够到达的左右边缘
记录每个点能够到达的最远右端right[i]
last记录当前能够到达的最远右端
pre记录已选择的某区域边缘
如果当前i=last说明 下一步无法覆盖了
如果i=pre 说明之前选的区域用完 需要下一个区域ans+1

def minTaps(n, ranges):
    """
    :type n: int
    :type ranges: List[int]
    :rtype: int
    """
    right = list(range(n+1))
    for i,r in enumerate(ranges):
        l,r = max(0,i-r),min(n,i+r)
        right[l] = max(right[l],r)
    
    last,ans,pre =0,0,0
    for i in range(n):
        last = max(last,right[i])
        if i==last:
            return -1
        if i==pre:
            pre = last
            ans +=1
    return ans

---

2/22 1140. 石子游戏 II

s[i]记录后缀和sum(piles[i:])
如果i+2*m>n 可以把后面的都拿了
遍历所有可能的x 找到后一个步最少的可能性 得到此时最大值
mem记忆(i,m)的结果

def stoneGameII(piles):
    """
    :type piles: List[int]
    :rtype: int
    """
    s = piles[:]
    n = len(piles)
    for i  in range(n-2,-1,-1):
        s[i]+=s[i+1]
    mem = {}
    def dfs(i,m):
        if (i,m) in mem:
            return mem[(i,m)]
        if i+2*m>=n:
            mem[(i,m)] = s[i]
            return s[i]
        ans = s[i]-min(dfs(i+x,max(m,x)) for x in range(1,m*2+1))
        mem[(i,m)] = ans
        return ans
    return dfs(0,1)

---

2/23 1238. 循环码排列

格雷码生成 相邻二进制只有一位不同

def circularPermutation(n, start):
    """
    :type n: int
    :type start: int
    :rtype: List[int]
    """
    ans = [0]*(1<<n)
    for i in range(1<<n):
        ans[i] = (i>>1)^i^start
    return ans

---

2/24 2357. 使数组中所有元素都等于零

统计nums中不同的非零数个数即可

def minimumOperations(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    s = set(nums)
    ans = len(s)
    if 0 in s:
        ans -=1
    return ans

---

2/25 1247. 交换字符使得字符串相同

从头遍历s1,s2 跳过字符相同的
字符不同有两种情况s1[i]=x s2[i]=y 或者s1[i]=y s2[i]=x
第一种xy 第二种yx
可以通过一次交换 减少2个xy或者yx
s1:xx xy
s2:yy xy
可以通过两次交换 减少一个xy和yx
s1:xy xx xy
s2:yx yy xy
尽量多的使用第一种

def minimumSwap(s1, s2):
    """
    :type s1: str
    :type s2: str
    :rtype: int
    """
    xy,yx=0,0
    for a,b in zip(s1,s2):
        if a=='x' and b=='y':
            xy +=1
        if a=='y' and b=='x':
            yx +=1
    if (xy+yx)%2:
        return -1
    return xy//2+yx//2+xy%2+yx%2

---

2/26 1255. 得分最高的单词集合

统计每个字母出现次数
对于每个单词有选或者不选 两种状态
回溯

def maxScoreWords(words, letters, score):
    """
    :type words: List[str]
    :type letters: List[str]
    :type score: List[int]
    :rtype: int
    """
    from collections import Counter
    m = Counter(letters)
    s = {}
    for i in range(26):
        s[chr(ord('a')+i)] = score[i]
    global ans 
    ans = 0
    def dfs(i,v):
        if i<0:
            global ans
            ans = max(ans,v)
            return 
        dfs(i-1,v)
        
        for loc,c in enumerate(words[i]):
            if m[c]==0:
                for cc in words[i][:loc]:
                    m[cc]+=1
                return 
            m[c]-=1
            v += s[c]
        dfs(i-1,v)
        for c in words[i]:
            m[c] +=1
    dfs(len(words)-1,0)
    return ans

---