LeetCode 每日一题 2021/7/26-2021/8/1

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

---

7/26 1713. Minimum Operations to Make a Subsequence 得到子序列的最少操作次数

target = [5,1,3], arr = [9,4,2,3,4]
将arr转变为每个数在target的坐标 不存在的数直接去除 arrb = [2]
target转变为每个数的坐标 targetb = [0,1,2]
要在arrb中添加数字 使得能够找到targetb targetb严格递增
题目转换为在arrb内找最长递增子序列长度x 需要插入的个数及len(target)-x
dp记录最长递增子序列 dp[0] = arrb[0]
如果arrb[i]大于dp[-1] 那么最长递增子序列可以扩大 将arrb[i]加入
否则找到离起点最后一个比它小的位置dp[k]<arrb[i] 更新后一位dp[k+1] = arrb[i]

def minOperations(target, arr):
    """
    :type target: List[int]
    :type arr: List[int]
    :rtype: int
    """
    n = len(target)
    m = {}
    for i in range(n):
        m[target[i]] = i
    arrb = []
    for c in arr:
        if c in m:
            arrb.append(m[c])
    dp = []   
    if len(arrb)==0:
        return n
    dp.append(arrb[0])
    
    for i in range(1,len(arrb)):
        if arrb[i]>dp[-1]:
            dp.append(arrb[i])
        else:
            l,r = 0,len(dp)
            while l<=r:
                mid = (l+r)>>1
                if dp[mid]<arrb[i]:
                    l = mid+1
                else:
                    r = mid-1
            dp[l] = arrb[i]
    return n-len(dp)

---

7/27 671. Second Minimum Node In a Binary Tree 二叉树中第二小的节点

dfs 深搜左右
root.val必定是最小值
如果当前val大于ans 那么之后的子节点必定大于ans 不必继续
如果有val大于root.val 那么为当前第二小值

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def findSecondMinimumValue(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    global ans
    ans = -1
    minv = root.val
    def dfs(node):
        global ans
        if not node:
            return
        if ans!=-1 and node.val>ans:
            return
        if node.val>minv:
            ans = node.val
        dfs(node.left)
        dfs(node.right)
    dfs(root)
    return ans

---

7/28 863. All Nodes Distance K in Binary Tree 二叉树中所有距离为 K 的结点

find用来寻找距离node为k个位置的点 pos代表往左往右寻找
dfs用来判断这个点是否要寻找 深搜找到target
那么target的父节点要找距离k-1位置的点 并且是在另一个子树中找

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def distanceK(root, target, k):
    """
    :type root: TreeNode
    :type target: TreeNode
    :type k: int
    :rtype: List[int]
    """
    global ans
    ans = []
    def find(node,k,pos):
        global ans
        if not node:
            return
        if k==0:
            ans.append(node.val)
            return
        if pos==1:
            find(node.left,k-1,0)
        elif pos==2:
            find(node.right,k-1,0)
        else:
            find(node.left,k-1,0)
            find(node.right,k-1,0)
        return
    
    def dfs(node):
        if not node:
            return -1
        if node==target:
            return k-1
        tmp = dfs(node.left)
        if tmp>=0:
            find(node,tmp,2)
            return tmp-1
        tmp = dfs(node.right)
        if tmp>=0:
            find(node,tmp,1)
            return tmp-1
        return -1
    
    find(target,k,0)
    dfs(root)
    return ans

---

7/29 1104. Path In Zigzag Labelled Binary Tree 二叉树寻路

从0开始 第i层增加2^i个 正反相隔

def pathInZigZagTree(label):
    """
    :type label: int
    :rtype: List[int]
    """
    if label==1:
        return [1]
    curr = 1
    l = [1]
    n = 2
    rev = True
    while curr+n<label:
        tmp = [curr+x for x in range(1,n+1)]
        if rev:
            tmp.reverse()
        rev = not rev
        l.extend(tmp)
        curr +=n
        n <<=1
        

    tmp = [curr+x for x in range(1,n+1)]
    if rev:
        tmp.reverse()
        
    for i in tmp:
        l.append(i)
        if i==label:
            break
    loc = len(l)-1
    ans = []
    while loc>0: 
        ans =[l[loc]]+ans
        loc = (loc-1)//2
    ans = [1]+ans
    return ans

---

7/30 171. Excel Sheet Column Number Excel 表列序号

27进制

def titleToNumber(columnTitle):
    """
    :type columnTitle: str
    :rtype: int
    """
    base = 1
    ans = 0
    for i in range(len(columnTitle)-1,-1,-1):
        tmp = ord(columnTitle[i])-ord('A')+1
        ans += tmp*base
        base *=26
    return ans

---

7/31 987. Vertical Order Traversal of a Binary Tree 二叉树的垂序遍历

dfs 记录每一个col下的(row,v)
对col从小到大考虑 每一个col的list tmp
在tmp中根据row,v排序 得到需要的v序列

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
    
def verticalTraversal(root):
    """
    :type root: TreeNode
    :rtype: List[List[int]]
    """
    from collections import defaultdict
    global dic
    dic = defaultdict(list)
    def find(node,row,col):
        global dic
        if not node:
            return
        dic[col].append((row,node.val))
        find(node.left,row+1,col-1)
        find(node.right,row+1,col+1)
    find(root,0,0)
    
    l = dic.keys()
    l.sort()
    ans = []
    for i in l:
        tmp = dic[i]
        tmp.sort(key=lambda x:(x[0],x[1]))
        t = [x[1] for x in tmp]
        ans.append(t)
    return ans

---

8/1 1337. The K Weakest Rows in a Matrix 矩阵中战斗力最弱的 K 行

记录每一行的战斗力 按战斗力排序

def kWeakestRows(mat, k):
        """
        :type mat: List[List[int]]
        :type k: int
        :rtype: List[int]
        """
        l = []
        for i in range(len(mat)):
            l.append((i,sum(mat[i])))
        l.sort(key=lambda x:x[1])
        ans = [x[0] for x in l[:k]]
        return ans

---