LeetCode 每日一题 2021/11/1-2021/11/7

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

---

11/1 575. 分糖果

哈希表存储不同种类
最多能有n/2种

def distributeCandies(candyType):
    """
    :type candyType: List[int]
    :rtype: int
    """
    m = {}
    for candy in candyType:
        m[candy]=1
    return min(len(m),len(candyType)//2)
    

---

11/2 237. 删除链表中的节点

节点不是末尾节点 后一个点必定有值
将当前点数值变为后节点数值 删除后面节点

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
def deleteNode(node):
    """
    :type node: ListNode
    :rtype: void Do not return anything, modify node in-place instead.
    """
    node.val = node.next.val
    node.next = node.next.next
    return

---

11/3 407. 接雨水 II

1.BFS
边界最大水深即为边界平台高度，加入队列
出队一个平台i，更新邻接点j水面深度，如果更新成功则将邻接点入队
更新规则：limit=max(heightMap[j],h[i]),h[j] > limit => h[j]=limit
统计最终平台水面高度-平台高度之和
2.最小堆
mem记录该位置是否已经在堆中
最外面一圈 无法积累雨水 将其位置、高度放入堆中
从堆中选出最矮的位置 更新其四周位置 如果某个位置比当前要矮 说明可以积攒雨水到当前高度 保存雨水高度
将四周位置放入堆中
因为每次都是从最矮的地方考虑 所以不存在雨水会流出变矮

def trapRainWater1(heightMap):
    """
    :type heightMap: List[List[int]]
    :rtype: int
    """
    n = len(heightMap)
    if n <=2 :
        return 0
    m = len(heightMap[0])

    fullMap = [[float('inf')] * m for _ in range(n)]
    deallist = []
    for i in range(n):
        for j in range(m):
            if i in (0, n - 1) or j in (0, m - 1):
                fullMap[i][j] = heightMap[i][j]
                deallist.append((i, j))
    while deallist:
        i, j= deallist.pop(0)
        for dx, dy in zip((1, 0, -1, 0), (0, 1, 0, -1)):
            nx, ny = i + dx, j + dy
            if nx <= 0 or nx >= n - 1 or ny <= 0 or ny >= m - 1: continue
            limit = max(fullMap[i][j], heightMap[nx][ny])
            if fullMap[nx][ny] > limit:
                fullMap[nx][ny] = limit
                deallist.append((nx, ny))
    return sum(fullMap[i][j] - heightMap[i][j] for i in range(n) for j in range(m))

def trapRainWater(heightMap):
    """
    :type heightMap: List[List[int]]
    :rtype: int
    """
    n = len(heightMap)
    if n <=2 :
        return 0
    m = len(heightMap[0])
    mem = [[False]*m for _ in range(n)]
    q = []
    res = 0
    import heapq
    for i in range(n):
        for j in range(m):
            if i in (0, n - 1) or j in (0, m - 1):
                heapq.heappush(q,(heightMap[i][j],i,j))
                mem[i][j]=True
    while q:
        h,i,j = heapq.heappop(q)
        for dx, dy in zip((1, 0, -1, 0), (0, 1, 0, -1)):
            x,y = i+dx,j+dy
            if 0<=x<n and 0<=y<m and not mem[x][y]:
                mem[x][y] = True
                if h>heightMap[x][y]:
                    res += h-heightMap[x][y]
                heapq.heappush(q,(max(h,heightMap[x][y]),x,y))
    return res
    

---

11/4 367. 有效的完全平方数

二分查找

def isPerfectSquare(num):
    """
    :type num: int
    :rtype: bool
    """
    if num==1:
        return True
    l,r = 1,min(num,2**16)
    while l<=r:
        mid = l+(r-l)//2
        now = mid*mid
        if now==num:
            return True
        elif now<num:
            l = mid+1
        else:
            r = mid-1
    return False
    

---

11/5 1218. 最长定差子序列

从头遍历
m[v] 用来记录以v结尾能够得到的最大结果
如果有相同的v v1=v2 在右边的v2得到结果必定大于等于v1

def longestSubsequence(arr, difference):
    """
    :type arr: List[int]
    :type difference: int
    :rtype: int
    """
    from collections import defaultdict
    m = defaultdict(int)
    ans = 0
    for v in arr:
        m[v] = m[v-difference]+1  
        ans = max(ans,m[v])
    return ans
    

---

11/6 268. 丢失的数字

最简单 先求理论所有数总和再减去现有值
位运算 所有的数如果两两相异或可以抵消 所以把所有的数和现有list做异或 最后剩下的就是缺少的

def missingNumber(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    ans=0
    for i in range(len(nums)):
        ans = ans^(i+1)^nums[i]
    return(ans)
    

---

11/7 598. 范围求和 II

nowm,nown代表最大整数右下角的点
每次操作更新nowm,nown最小值

def maxCount(m, n, ops):
    """
    :type m: int
    :type n: int
    :type ops: List[List[int]]
    :rtype: int
    """
    nowm,nown = m,n
    for i,j in ops:
        nowm = min(nowm,i)
        nown = min(nown,j)
    return nowm*nown
    
    

---