LeetCode 每日一题 2021/5/31-2021/6/6

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

---

5/31 342. Power of Four 4的幂

条件：
1.不能为负数
2.二进制只能出现1个1
3.1需要在二进制的奇数位 1 100 10000 看出规律 包含偶数个0

def isPowerOfFour(n):
    """
    :type n: int
    :rtype: bool
    """
    if n <0 :
        return False
    if n&(n-1)>0:
        return False
    s = bin(n)[2:]
    return  s.count('0')%2==0

---

6/1 1744. Can You Eat Your Favorite Candy on Your Favorite Day? 你能在你最喜欢的那天吃到你最喜欢的糖果吗？

summap 记录前i类的糖果总数 每次算sum会超时
第day天从0天开始 最少吃low=day+1 最多吃high=(day+1)*cap
前tp类糖果总数total=summap[tp]

def canEat(candiesCount, queries):
    """
    :type candiesCount: List[int]
    :type queries: List[List[int]]
    :rtype: List[bool]
    """
    summap = {}
    pre=0
    for i in range(len(candiesCount)):
        pre +=candiesCount[i]
        summap[i]=pre
    def find(tp,day,cap):
        if candiesCount[tp]==0:
            return False
        total = summap[tp]
        low = day+1
        high = (day+1)*cap
        if low<=total and high>total-candiesCount[tp]:
            return True
        return False
    ret =[]
    for t,d,c in queries:
        ret.append(find(t,d,c))
    return ret

---

6/2 523. Continuous Subarray Sum 连续的子数组和

寻找连续子数组
mem[a]=[i] 可以记录[0:i]的和与k的余数a sum[0:i]%k=a
只要找到两个x,y的余数相同[0:x]=a [0:y]=a 说明[x+1:y]=0这个子序列的和是k的倍数
判断x+1!=y 不能是连续两个位置
mem[0]=-1 设置满足sum[0:i]%k=0的情况

def checkSubarraySum(nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: bool
    """
    mem={}
    pre = 0
    mem[0] = [-1]
    for i in range(len(nums)):
        num = nums[i]
        pre = (pre+num)%k
        if pre in mem:
            l = mem[pre]
            for loc in l:
                if loc<i-1:
                    return True
            l.append(i)
            mem[pre] = l
        else:
            mem[pre]=[i]
    return False

---

6/3 525. Contiguous Array 连续数组

思路与上一题大致相同
记录出现1的次数结果 出现一次+1 出现一次0记录为-1
一次遍历记录每个位置前1出现次数的情况 mem[i]=x 记录次数i第一次出现的位置
如果位置y的结果也为i 说明(x,y]内0,1次数出现相同

def findMaxLength(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    mem={}
    mem[0]=-1
    pre = 0
    ans = 0
    for loc in range(len(nums)):
        num = nums[loc]
        if num==1:
            pre+=1
        else:
            pre-=1
        if pre in mem:
            ans = max(ans,loc-mem[pre])
        else:
            mem[pre]=loc
    return ans

---

6/4 160. Intersection of Two Linked Lists 相交链表

双指针 pA pB
某一个到结尾后 指到另一个链表头开始
如果相交 那么两个指针会在第二轮在相交点相遇

def getIntersectionNode(headA, headB):
    """
    :type head1, head1: ListNode
    :rtype: ListNode
    """
    pA=headA
    pB=headB
    while pA!=pB:
        pA=headB if not pA else pA.next
        pB=headA if not pB else pB.next
    return pA

---

6/5 203. Remove Linked List Elements 移除链表元素

记录前一个节点pre
找到符合要求的节点node 将pre与node连接
退出循环后 pre.next = node 放置末尾节点被跳过但ret没有指向nil

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def removeElements(head, val):
    """
    :type head: ListNode
    :type val: int
    :rtype: ListNode
    """
    ret = ListNode()
    node = head
    ret.next = node
    pre = ret
    while node:
        if node.val==val:
            node = node.next
            continue
        pre.next = node
        pre = node
        node = node.next
    pre.next = node
    return ret.next

---

6/6 474. Ones and Zeroes 一和零

1.dp
dp[i][j][k] 在前i个字符串内 有j个0 k个1 情况下最大结果
满足条件时 dp[i][j][k] =max(dp[i-1][j][k],dp[i-1][j-zero][k-one]+1)
2. 超时
c0 c1分别记录每个值包换的0,1数量
对位置Loc的值 选或者不选
选需要满足 m>=c0[loc] 并且 n>=c1[loc]

def findMaxForm(strs, m, n):
    """
    :type strs: List[str]
    :type m: int
    :type n: int
    :rtype: int
    """
    l = len(strs)
    dp = [[[0]*(n+1) for _ in range(m+1) ]for _ in range(l+1)]
    for i in range(l):
        s = strs[i]
        zero = s.count('0')
        one = len(s)-zero
        for j in range(m+1):
            for k in range(n+1):
                dp[i+1][j][k] = dp[i][j][k]
                if j>=zero and k>=one:
                    dp[i+1][j][k] = max(dp[i+1][j][k],dp[i][j-zero][k-one]+1)
                    
    return dp[l][m][n]

def findMaxForm2(strs, m, n):
    """
    :type strs: List[str]
    :type m: int
    :type n: int
    :rtype: int
    """
    l = len(strs)
    c0 = [0]*l
    c1 = [0]*l
    for i in range(l):
        s = strs[i]
        c0[i] = s.count('0')
        c1[i] = len(s)-c0[i]
        
    def find(loc,m,n):
        if loc==l:
            return 0
        if m>=c0[loc] and n>=c1[loc]:
            ret = max(find(loc+1,m,n),find(loc+1,m-c0[loc],n-c1[loc])+1)
            return ret
        else:
            ret =  find(loc+1,m,n)
            return ret
    return find(0,m,n)
        

---