LeetCode 每日一题 2021/12/20-2021/12/26

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

• • • 12/20 475. 供暖器
    • 12/21 1154. 一年中的第几天
    • 12/22 686. 重复叠加字符串匹配
    • 12/23 1044. 最长重复子串
    • 12/24 1705. 吃苹果的最大数目
    • 12/25 1609. 奇偶树
    • 12/26 1078. Bigram 分词

将房屋 供暖器从小到大排序
对于每个房屋 找到其距离左右的两个供暖器 其中最短的距离为需要距离
双指针l,r 代表左右供暖器
找到heaters[r]位置大于当前房屋的位置
为了使得r必然存在 在heater末尾加入无穷远的一个取暖器

def findRadius(houses, heaters):
    """
    :type houses: List[int]
    :type heaters: List[int]
    :rtype: int
    """
    heaters.sort()
    houses.sort()
    print(houses)
    print(heaters)
    heaters.append(float('inf'))
    ans = 0
    l,r = 0,1
    for h in houses:
        while heaters[r] 
 
12/21 1154. 一年中的第几天 
 
 
分别获取年月日 判断是否是润年
 将月份之前的天数累加 再加上当前月份天数
 
 
def dayOfYear(date):
    """
    :type date: str
    :rtype: int
    """
    monthday = [31,28,31,30,31,30,31,31,30,31,30]
    l = date.split("-")
    year = int(l[0])
    if year%4==0 and (year%100!=0 or year==2000):
            monthday[1]=29
    ans =0
    month = int(l[1])
    if month>1:
        ans += sum(monthday[:month-1])
    day = int(l[2])
    ans +=day
    return ans
 
 
12/22 686. 重复叠加字符串匹配 
 
 
1.判断b中是否有a不存在的字符 如果有则一定不能
 将n个a拼成长度大于nb的字符串
 从头开始比较是否存在和b一样的子字符串
 2.对于a,b 做少需要 [b/a]上取整个a 最多需要[b/a]上取整+1个a
 判断新字符串内是否存在b
 
 
def repeatedStringMatch1(a, b):
    """
    :type a: str
    :type b: str
    :rtype: int
    """
    m={}
    for c in a:
        m[c]=1
    for c in b:
        if c not in c:
            return -1
    na,nb = len(a),len(b)
    n = nb//na+2
    
    newa = "".join([a]*n)
    for i in range(len(newa)-nb+1):
        if newa[i:i+nb]==b:
            left = (nb-(na-i))
            n = left//na+1
            if left%na>0:
                n+=1
            return n
    return -1

def repeatedStringMatch(a, b):
    """
    :type a: str
    :type b: str
    :rtype: int
    """
    na,nb = len(a),len(b)
    n = (nb+na-1)//na
    newa = a*n
    if newa.find(b)!=-1:
        return n
    newa = a*(n+1)
    if newa.find(b)!=-1:
        return n+1
    return -1
 
 
12/23 1044. 最长重复子串 
 
 
暴力搜索 记录最长答案
将字符串哈希
 如果哈希值相同则两个字符串相同
 Rabin-Karp算法计算哈希值
 一个底数容易哈希冲突 使用两个大大减小冲突可能
 对于子字符串长度进行二分
 
 
def longestDupSubstring1(s):
    """
    :type s: str
    :rtype: str
    """
    n = len(s)
    ans = ""
    for i in range(n):
        if i+len(ans)>=n:
            break
        while s[i:i+len(ans)+1] in s[i+1:]:
            ans = s[i:i+len(ans)+1]
    return ans

def longestDupSubstring(s):
    """
    :type s: str
    :rtype: str
    """
    prime1 = 31
    prime2 = 97
    MOD = 10**9+7
    n = len(s)
    arr = [ord(x)-ord('a') for x in s]
    def check(length):
        h1,h2 = 0,0
        for i in range(length):
            h1 = (h1*prime1+arr[i])%MOD
            h2 = (h2*prime2+arr[i])%MOD
        p1 = pow(prime1,length)%MOD
        p2 = pow(prime2,length)%MOD
        mem = set()
        mem.add((h1,h2))
        for left in range(1,n-length+1):
            h1 = (h1*prime1-arr[left-1]*p1+arr[left+length-1])%MOD
            h2 = (h2*prime2-arr[left-1]*p2+arr[left+length-1])%MOD
            if (h1,h2) in mem:
                return s[left:left+length]
            mem.add((h1,h2))
        return ""
    l,r = 0,n-1
    ans = ""
    while l<=r:
        mid = l+(r-l+1)//2
        cur = check(mid)
        if cur!="":
            ans = cur
            l = mid +1
        else:
            r = mid -1
    return ans
 
 
12/24 1705. 吃苹果的最大数目 
 
 
最小堆l 存储(腐坏日期，苹果数量)
 遍历每一天的苹果
 先将已经坏了的苹果扔掉
 如果当天有苹果 将(腐坏日期，苹果数量)存入堆中
 选择腐坏日期最接近的优先拿出来吃一个
 更新堆
 遍历完生长苹果的日期后 同样将剩余的依次取出
 
 
def eatenApples(apples, days):
    """
    :type apples: List[int]
    :type days: List[int]
    :rtype: int
    """
    import heapq
    l = []
    ans = 0
    heapq.heapify(l)
    for i,apple in enumerate(apples):
        while l and l[0][0]<=i:
            heapq.heappop(l)
        if apple:
            heapq.heappush(l,[i+days[i],apple])
        if l:
            l[0][1]-=1
            if l[0][1]==0:
                heapq.heappop(l)
            ans+=1
    day = len(apples)
    while l:
        while l and l[0][0]<=day:
            heapq.heappop(l)
        if len(l)==0:
            break
        d,n = heapq.heappop(l)
        num = min(d-day,n)
        ans +=num
        day +=num
    return ans
 
 
12/25 1609. 奇偶树 
 
 
BFS 广搜
 level记录当前层数
 每个数v需要满足与level的奇偶性不同
 prev记录当前位置前一个数大小 来判断当前层是否递增递减
 
 
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def isEvenOddTree(root):
    """
    :type root: TreeNode
    :rtype: bool
    """
    level = 0
    l = [root]
    while l:
        tmp = []
        prev = 0
        for i,node in enumerate(l):
            v = node.val
            if level%2+v%2!=1:
                return False
            if i>0:
                if level%2==0:
                    if v<=prev:
                        return False
                else:
                    if v>=prev:
                        return False
            prev = v
            if node.left:
                tmp.append(node.left)
            if node.right:
                tmp.append(node.right)
        level+=1
        l = tmp[:]
    return True
 
 
12/26 1078. Bigram 分词 
 
 
记录当前单词之前第一个单词 第二个单词的状态 a,b
 如果第二单词状态为True 则加入当前单词
 如果第一单词状态为True 判断当前单词是否与第二单词相同
 判断当前单词与第一单词是否相同 修改第一单词状态
 
 
def findOcurrences(text, first, second):
    """
    :type text: str
    :type first: str
    :type second: str
    :rtype: List[str]
    """
    a,b = False,False
    l = text.split(" ")
    ans = []
    for word in l:
        if b:
            b = False
            ans.append(word)
        if a and word==second:
            b = True
        if word == first:
            a = True
        else:
            a = False
    return ans