LeetCode 每日一题 2023/1/30-2023/2/5

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

---

1/30 1669. 合并两个链表

遍历list1 找到a前的start 找到b后的end
将start指向list2开头 将list2结尾指向end

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def mergeInBetween(list1, a, b, list2):
    """
    :type list1: ListNode
    :type a: int
    :type b: int
    :type list2: ListNode
    :rtype: ListNode
    """
    ans = ListNode()
    ans.next = list1
    pre = ans
    end = None
    num = 0
    while list1:
        if num==a:
            pre.next = list2
        if num==b:
            end = list1.next
            break
        num+=1
        pre,list1 = list1,list1.next
    while list2.next:
        list2 = list2.next
    list2.next = end
    return ans.next

---

1/31 2319. 判断矩阵是否是一个 X 矩阵

矩阵n*n
遍历每一个位置(i,j)
对角线满足 i==j 或者i+j=n-1

def checkXMatrix(grid):
    """
    :type grid: List[List[int]]
    :rtype: bool
    """
    n = len(grid)
    for i in range(n):
        for j in range(n):
            if i==j or i+j==n-1:
                if grid[i][j]==0:
                    return False
            elif grid[i][j]>0:
                return False
    return True

---

2/1 2325. 解密消息

map存储对应关系

def decodeMessage(key, message):
    """
    :type key: str
    :type message: str
    :rtype: str
    """
    cur = 0
    m = {}
    for c in key:
        if c!=" " and c not in m:
            m[c] = chr(ord('a')+cur)
            cur+=1
    ans = [" "]*len(message)
    for i,c in enumerate(message):
        if c!=" ":
            ans[i] = m[c]
    return "".join(ans)

---

2/2 1129. 颜色交替的最短路径

m[i]记录x能够到达的节点(j,0)红边 (j,1)蓝边
从0点开始BFS

def shortestAlternatingPaths(n, redEdges, blueEdges):
    """
    :type n: int
    :type redEdges: List[List[int]]
    :type blueEdges: List[List[int]]
    :rtype: List[int]
    """
    from collections import defaultdict
    m = defaultdict(list)
    for i,j in redEdges:
        m[i].append((j,0))
    for i,j in blueEdges:
        m[i].append((j,1))
    ans = [-1]*n
    mem = set([(0,0),(0,1)])
    l = [(0,0),(0,1)]
    step = 0
    while l:
        tmp = []
        for i,cl in l:
            if ans[i]<0:
                ans[i] = step
            for nt in m[i]:
                if nt[1]!=cl and nt not in mem:
                    mem.add(nt)
                    tmp.append(nt)
        step+=1
        l = tmp
    return ans

---

2/3 1145. 二叉树着色游戏

一号玩家已选择节点x 将二叉树分为三个区域
左子树节点 右子树节点 其他节点
二号玩家选节点后 真能在一个区域内选择 为了使得节点数最大
二号玩家选择与x临近的节点 即x的左子节点 右子节点 根节点
在树中找到x节点后 统计其左子树节点个数 右子树节点个数 其他节点个数
如果存在某个区域节点个数>=(n+1)//2 则二号玩家选择该区域能够取胜
如果每个区域都<(n+1)//2 则二号玩家不可能取胜

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def btreeGameWinningMove(root, n, x):
    """
    :type root: TreeNode
    :type n: int
    :type x: int
    :rtype: bool
    """
    global xnode
    xnode = None
    
    def getNodeNum(node):
        global xnode
        if not node:
            return 0
        if node.val==x:
            xnode = node
        return 1+getNodeNum(node.left)+getNodeNum(node.right)
    
    getNodeNum(root)
    lsize = getNodeNum(xnode.left)
    if lsize>=(n+1)//2:
        return True
    rsize = getNodeNum(xnode.right)
    if rsize >=(n+1)//2:
        return True
    other = n-lsize-rsize-1
    return other>=(n+1)//2
            

---

2/4 1798. 你能构造出连续值的最大数目

将coins从小到大排序
对于前x个coins 能够凑出最大数目为ans
那么加入第x+1个银币c 如果c<=ans
那么最大数目可以达到ans+c

def getMaximumConsecutive(coins):
    """
    :type coins: List[int]
    :rtype: int
    """
    coins.sort()
    ans = 1
    for c in coins:
        if c>ans:
            break
        ans += c
    return ans

---

2/5 1210. 穿过迷宫的最少移动次数

使用(i,j,s)来判断蛇的位置 i,j为坐标 s=0为水平 s=1为垂直
mem[(i,j,s)]用来记录该位置移动次数
BFS 从起点(0,0,0)开始广搜
如果s=0
向右 (i,j+2) 为空
向下 (i+1,j),(i+1,j+1)为空
顺时针 (i+1,j),(i+1,j+1)为空
如果s=1
向右 (i,j+1),(i+1,j+1)为空
向下 (i+2,j) 为空
逆时针 (i,j+1),(i+1,j+1)为空

def minimumMoves(grid):
    """
    :type grid: List[List[int]]
    :rtype: int
    """
    n = len(grid)
    mem = {}
    mem[(0,0,0)]=0
    l = [(0,0,0)]
    while l:
        tmp = []
        for i,j,s in l:
            if s==0:
                if j+2<n and (i,j+1,0) not in mem and grid[i][j+2]==0:
                    mem[(i,j+1,0)] = mem[(i,j,0)]+1
                    tmp.append((i,j+1,0))
                if i+1<n and (i+1,j,0) not in mem and grid[i+1][j]==grid[i+1][j+1]==0:
                    mem[(i+1,j,0)] = mem[(i,j,0)]+1
                    tmp.append((i+1,j,0))
                if i+1<n and j+1<n and (i,j,1) not in mem and grid[i+1][j]==grid[i+1][j+1]==0:
                    mem[(i,j,1)] = mem[(i,j,0)]+1
                    tmp.append((i,j,1))
            else:
                if j+1<n and (i,j+1,1) not in mem and grid[i][j+1]==grid[i+1][j+1]==0:
                    mem[(i,j+1,1)] = mem[(i,j,1)]+1
                    tmp.append((i,j+1,1))
                if i+2<n and (i+1,j,1) not in mem and grid[i+2][j]==0:
                    mem[(i+1,j,1)] = mem[(i,j,1)]+1
                    tmp.append((i+1,j,1))
                if i+1<n and j+1<n and (i,j,0) not in mem and grid[i][j+1]==grid[i+1][j+1]==0:
                    mem[(i,j,0)] = mem[(i,j,1)]+1
                    tmp.append((i,j,0))
        l=tmp
    return mem.get((n-1,n-2,0),-1)

---