MS leetcode 题目

# 717 1比特与2比特字符：判断末尾符号是哪一种

思路：线性从前向后遍历，维护一个映射list。

class Solution:
    def isOneBitCharacter(self, bits: List[int]) -> bool:
        if len(bits)==1:
            return True
        else:
            mapList=[]
            while len(bits)>0:
                if bits[0]==1:
                    mapList.append('F')
                    bits.pop(0)
                    bits.pop(0)
                else:
                    mapList.append('T')
                    bits.pop(0)
            if mapList[-1]=='T':
                return True
            else:
                return False

# 67 二进制求和：二进制加法

思路：首先处理字符串长度不一致的问题，为较短的字符串前面添0，将两个字符串补齐。然后从后往前加即可，当前位置上的两个数+进位。

class Solution:

    def addZero(self,a,b):
        diff=abs(len(b)-len(a))
        if len(a)<len(b):
            a='0'*diff+a
        elif len(a)>len(b):
            b = '0' * diff + b
        return a,b

    def addBinary(self, a: str, b: str) -> str:
            result=''
            a,b=self.addZero(a,b)
            flag=0 # 进位
            for i in range(len(a)):
                tmp=int(a[len(a)-i-1])+int(b[len(b)-i-1])+flag
                if tmp==2:
                    flag=1
                    result+='0'
                elif tmp==3:
                    flag = 1
                    result += '1'
                else:
                    flag=0
                    result += str(tmp)
            if flag==1:
                result += '1'
            back=''.join(list(reversed(result)))
            return back

 # 415: 67的升级版, replace if-else with //(整除) and %(取余)

class Solution:
    def addZero(self,a,b):
        diff=abs(len(b)-len(a))
        if len(a)<len(b):
            a='0'*diff+a
        elif len(a)>len(b):
            b = '0' * diff + b
        return a,b

    def addStrings(self, num1: str, num2: str) -> str:
        result=''
        a,b=self.addZero(num1,num2)
        flag=0 # 进位
        for i in range(len(a)):
            tmp=int(a[len(a)-i-1])+int(b[len(b)-i-1])+flag
            result+=str(tmp%10) # 10进制数
            flag=tmp//10 
        if flag!=0: #由于题目要求字符串前面不能有0，所以只有非0才添加
            result += str(flag)
        back=''.join(list(reversed(result)))
        return back

 ### 从这道题开始，我就不按照LC官网类的方式记录了，直接贴函数代码>>_<<

# 107: DFS+维护一个以深度为key的字典, value是一个list, 在DFS时依次append, 最后按照key从大到小返回对应value(主要难点在于DFS的实现，DFS的实现方式主要有两种，一种是递归，一种是栈，这里采用递归的实现方式)

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def DFS(root,depth,depthDict):
    if root!=None:
        if depth not in depthDict.keys():
            depthDict[depth]=[]
            depthDict[depth].append(root.val)
        else:
            depthDict[depth].append(root.val)
        DFS(root.left,depth+1,depthDict)
        DFS(root.right, depth+1, depthDict)
    else:
        return

def levelOrderBottom(root): # root: TreeNode
    res=[]
    depthDict={}
    depth=0
    DFS(root,depth,depthDict)
    keysSort=list(reversed(sorted(list(depthDict.keys()))))
    for i in keysSort:
        res.append(depthDict[i])
    return res

# Test sample
rr=TreeNode(3)
rr.left=TreeNode(9)
rr.right=TreeNode(20)
rr.right.left=TreeNode(15)
rr.right.right=TreeNode(7)
print(levelOrderBottom(rr))

 # 257: DFS (这两道二叉树的题目做起来都有点困难，可能因为对递归理解还不是非常透彻，这里关键在于递归的过程中path会被自动维护)

# Use the definition for a binary tree node in 107.
def binaryTreePaths(root): # List[str]
    Paths=[]
    Path=''

    def DFS_257(root, path):
        if root != None:
            if path == '':
                path += str(root.val)
            else:
                path += ('->' + str(root.val))
            if root.left==None and root.right==None:
                Paths.append(path)
            DFS_257(root.left, path)
            DFS_257(root.right, path)
        else:
            return

    DFS_257(root,Path)
    return Paths

# Test sample
# rr=TreeNode(3)
# rr.left=TreeNode(9)
# rr.right=TreeNode(20)
# rr.right.left=TreeNode(15)
# rr.right.right=TreeNode(7)
# print(binaryTreePaths(rr))

 这里补充一下递归分析：

 # 70: DP (乍一看以为这道题就是求二叉树的路径条数，以为可以使用DFS，然递归DFS超时==), 用DP的话首先需要写出通项公式，这里假设f(x)是爬x阶楼梯的方案数，而最后一步可以走1步或者2步，我们可以得到f(x)=f(x-1)+f(x-2)，这个比较难想，竟然是斐波那契数。

def climbStairs(n): # DP
    l=0
    r=1
    sum=0
    for i in range(n):
        sum=l+r
        l=r
        r=sum
    return r

(有关通项的理解后续再补充)

 # 30: 外观数列, 这道题的解法写的比较任意，就是线性扫描+集合判断，更加规范的应该用双指针。

线性扫描+集合

def count(num):
    str_num=str(num)
    descriptor=''
    filter_set=[]
    for i in str_num:
        filter_set.append(i)
        if len(set(filter_set))==2:
            descriptor+=(str(len(filter_set[:-1]))+filter_set[-2])
            filter_set = [filter_set[-1]]
        else:
            continue
    descriptor+=(str(len(filter_set))+str(filter_set[-1]))
    return int(descriptor)

def countAndSay(n):
    res=1
    for i in range(n-1):
        res=count(res)
    return str(res)

print(countAndSay(5))

 # 204 数质数，该题用常规方法去判断会超时，尝试加了很多trick还是会超时，最后参考了其他人的题解，采用了埃氏筛的方法，主要是对该方法的理解(算法实现)。

def countPrimes(n): # 埃氏筛
    isPrime=[1]*n # 初始化很重要
    cnt=0
    for i in range(2,n):
        if isPrime[i]:
            cnt+=1
        for j in range(i*i,n,i):
            isPrime[j]=0
    return cnt

 # 706 自己实现一个hash表，也就是python中的字典。解决两个问题，第一，哈希函数，第二，哈希碰撞。1，采用取模长%len；2，用一个数组把映射在同一位置的元素装起来，所以是两个数组的嵌套。(这里将第一个数组的长度设置为2069，参考解答的设置，any质数都可以，减小碰撞概率而已)

class MyHashMap:

    def __init__(self):
        self.map=[[]]*2069 # 2069 as a prime

    def put(self, key: int, value: int) -> None:
        index=key%2069
        for lst in self.map[index]:
            if lst[0]==key:
                lst[1]=value
                return None
        self.map[index].append([key,value])

    def get(self, key: int) -> int:
        index=key%2069
        for lst in self.map[index]:
            if lst[0]==key:
                return lst[1]
        return -1

    def remove(self, key: int) -> None:
        index = key % 2069
        for i in range(len(self.map[index])):
            if self.map[index][i][0] == key:
                del self.map[index][i]
                break # 要加break，不然会有错，因为这种for iterator删除当前元素继续访问会造成冲突

 # 509 斐波那契数（70题的本质）

def fib(n):
    if n==0:
        return 0
    else:
        l = 0
        r = 1
        sum = 0
        for i in range(n - 1):
            sum = l + r
            l = r
            r = sum
        return r

# 724 找中心索引使得左右两边和相等, 题目也比较好理解，我直接用了sum函数判断，发现两个有意思的点: sum([])=0 ; list[:0]=[] list[len(list):]=[] 第二个点说明切片不会造成越界问题，比如这样：

def pivotIndex(nums):
    for i in range(len(nums)):
        if sum(nums[:i])==sum(nums[(i+1):]):
            return i
    return -1

 # 387 字符串中的唯一字符，该题目比较简单，不多分析，就用字典存储频数即可。

def firstUniqChar(s):
    uniqueCharList=[]
    times={}
    for i in s:
        if i not in uniqueCharList:
            uniqueCharList.append(i)
            times[i]=1
        else:
            times[i]+=1
    print(uniqueCharList)
    print(times)
    for key in times.keys():
        if times[key]==1:
            return s.index(key)
    return -1

# 198: 数组中不相邻元素的最大和，使用动态规划，经典步骤，建立函数关系f(x)，写出子结构表达式。本题目分析如下 (代码部分参考精选题解)：

def rob(nums):
    if len(nums)==0:
        return 0
    elif len(nums)==1:
        return nums[0]
    else:
        N=len(nums)
        dp=[0]*(N+1)
        dp[0]=0
        dp[1]=nums[0]
        for i in range(2,N+1):
            dp[i]=max(dp[i-1],dp[i-2]+nums[i-1])
        return dp[N]

 # 232 用两个栈模拟队列，一个栈作为输入栈，一个栈作为输出栈，push的时候都加入输入栈，pop从输出栈弹出，此时如果为空就需要将输入栈的全部弹出到输出栈再输出。（相当于将一个队列拆成了两部分，入栈和出栈）

这个video很清晰==

class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.inputStack=[]
        self.outputStack=[]


    def push(self, x: int) -> None:
        """
        Push element x to the back of queue.
        """
        self.inputStack.append(x)


    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        if len(self.outputStack)!=0:
            value=self.outputStack.pop()
            return value
        else:
            for i in range(len(self.inputStack)):
                self.outputStack.append(self.inputStack.pop())
            value = self.outputStack.pop()
            return value


    def peek(self) -> int:
        """
        Get the front element.
        """
        if len(self.outputStack)!=0:
            value=self.outputStack[-1]
            return value
        else:
            for i in range(len(self.inputStack)):
                self.outputStack.append(self.inputStack.pop())
            value = self.outputStack[-1]
            return value


    def empty(self) -> bool:
        """
        Returns whether the queue is empty.
        """
        if len(self.inputStack)==0 and len(self.outputStack)==0:
            return True
        else:
            return False

 # 225 用两个队列模拟栈：核心思想就是将一个队列辅以某些操作直接变成栈的存储结构（元素取反存储）。实现：一个队列+一个tmp队列

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.Q=[]
        self.Q_tmp=[]

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.Q_tmp=[]
        self.Q_tmp.append(x)
        if len(self.Q)!=0:
            for i in range(len(self.Q)):
                self.Q_tmp.append(self.Q[i])
        self.Q=self.Q_tmp

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        res=self.Q[0]
        self.Q=self.Q[1:]
        return res

    def top(self) -> int:
        """
        Get the top element.
        """
        return self.Q[0]

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        if len(self.Q)==0:
            return True
        else:
            return False

 # 28 查找子字符串出现的位置

def strStr(haystack, needle):
    if needle=='' or needle==haystack:
        return 0
    elif len(needle)>len(haystack):
        return -1
    else: # needle 长度小于hay
        for i in range(len(haystack)):
            if i+len(needle)<=len(haystack):
                if haystack[i:i+len(needle)]==needle:
                    return i
                else:
                    if i + len(needle) == len(haystack): # 考虑最后一次不匹配的情况
                        return -1
                    continue
            else:
                return -1

写的太复杂了==按照相同的思路可以用一行代码实现（for start in range(n - L + 1):）or 还可以采用基于hash的方法，将字符串映射到hash，如Rabin Karp

 # 349 两个数组的交集（就遍历...）

def intersection(nums1, nums2):
    intersect=[]
    for i in nums1:
        if (i in nums2) and (i not in intersect):
            intersect.append(i)
    return intersect

# 784 字母大小写全排列。这个题目关键是抓住全排列和二进制数之间的关系。

def letterCasePermutation(S):
    L=[]
    letterIndex=[]
    idx=-1
    str=S # store numbers in S and reserve space for character
    for i in S: # 数字
        idx+=1
        if i>='0' and i<='9':
            L.append(i)
        else: # 字母
            letterIndex.append(idx)
            L.append([i.lower(),i.upper()])
    if len(letterIndex)==0: # 没有字母
        return [S]
    else: # 有字母
        # 全排列等价于二进制数
        sortArray = []
        for i in range(2 ** len(letterIndex)):
            tmp = bin(i)[2:]
            while len(tmp) < len(letterIndex):
                tmp = '0' + tmp
            sortArray.append(tmp)
        res = []
        for sort in sortArray:
            for ith in range(len(sort)):
                str = list(str)
                str[letterIndex[ith]] = L[letterIndex[ith]][int(sort[ith])]
                str = ''.join(str)
            res.append(str)
        return res

（代码写的太不算法了，完全是拿数学和规律来解==，标准做法应该是构建一棵树，用递归来做）

# 14 最长公共前缀：思路是先选取一个最短的字符串，然后与其他的进行比较，将模板字符串从长到短比较。

def longestCommonPrefix(strs):
    minl=201
    mintemplate=''
    for i in strs: # 取最短的字符串作为模板来匹配其他的
        if len(i)<minl:
            minl=len(i)
            mintemplate=i
    for i in reversed(range(minl)):
        TrueFalseSet=set()
        for j in range(len(strs)):
            TrueFalseSet.add(mintemplate[:i+1]==strs[j][:i+1])
        if len(TrueFalseSet)==1 and list(TrueFalseSet)[0]==True:
            return mintemplate[:i+1]
        else:
            continue
    return ''

Follow this repo, update this blog continuously. 1.28 暂时停更，准备开始按类型刷。