leetcode -指剑offer-2021-08-08

1. 剑指 Offer 20. 表示数值的字符串
2. 剑指 Offer 34. 二叉树中和为某一值的路径
3. 剑指 Offer 19. 正则表达式匹配
4. 剑指 Offer 37. 序列化二叉树
5. 剑指 Offer 67. 把字符串转换成整数
6. 剑指 Offer 66. 构建乘积数组

剑指 Offer 20. 表示数值的字符串

class Solution:
    def isNumber(self, s: str) -> bool:
        state=[
            {' ':0, 's':1, 'd':2, '.':4},               # 状态0，空格后面可以跟的字符
            {'d':2, '.':4},                             # 状态1，+ - 后面可以跟的字符
            {'d':2, '.':3, 'e':5, ' ':8},               # 2，数字后面可以跟的字符
            {'e':5, 'd':3, ' ':8},                      # 3，数字.数字 后面可以跟的字符
            {'d':3},                                    # 4，空格.数字 后面可以跟的字符
            {'s':6, 'd':7},                             # 5，e后面可以跟的字符
            {'d':7},                                    # 6，e+/- 后面可以跟的字符
            {'d':7, ' ':8},                             # 7，数字后可以跟的字符
            {' ': 8}                                    # 8， 末尾的空格可以跟的字符
        ]
        p = 0
        for c in s:
            if '0'<=c<='9': t = 'd'
            elif c in '+-': t = 's'
            elif c == ' ' or c=='.': t=c
            elif c in 'eE': t ='e'
            else: t = '?'
            if t not in state[p]:return False
            p = state[p][t]
        return p in [2,3,7,8]

剑指 Offer 34. 二叉树中和为某一值的路径

class Solution:
    def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
        path = []
        res = []
        def recur(node, target):
            if not node:
                return
            path.append(node.val)
            target-=node.val
            if target == 0 and not node.left and not node.right:
                res.append(list(path))
            recur(node.left,target)
            recur(node.right,target)
            path.pop()

        recur(root,target)
        return res

剑指 Offer 19. 正则表达式匹配

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        m = len(s)+1
        n =len(p)+1
        dp = [[False for _ in range(n)] for _ in range(m)]
        dp[0][0] = True
        for j in range(2,n,2):
            if p[j-1]=='*':
                dp[0][j]=dp[0][j-2]
        
        for i in range(1,m):
            for j in range(1,n):
                if p[j-1] == '*':
                    if dp[i][j-2]: dp[i][j]=True
                    elif dp[i-1][j] and s[i-1]==p[j-2]: dp[i][j]=True
                    elif dp[i-1][j] and p[j-2] == '.': dp[i][j]=True
                else:
                    if dp[i-1][j-1] and s[i-1]==p[j-1]: dp[i][j]=True
                    if dp[i-1][j-1] and p[j-1] == '.': dp[i][j]=True
        return dp[-1][-1]

剑指 Offer 37. 序列化二叉树

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

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if not root:
            return 'None'
        return str(root.val)+','+str(self.serialize(root.left))+','+str(self.serialize(root.right))
        

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        def dfs(datalist):
            val = datalist.pop(0)
            if val =='None':
                return None
            root = TreeNode(int(val))
            root.left = dfs(datalist)
            root.right = dfs(datalist)
            return root
        datalist = data.split(',')
        return dfs(datalist)
        

# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

剑指 Offer 67. 把字符串转换成整数

class Solution:
    def strToInt(self, str: str) -> int:
        s = str.strip() # 去除首部空格
        if not s:
            return 0
        res = 0
        max_num = 2**31-1 #数字上限
        min_num=-2**31 #数字下限
        bandry = 2**31//10 #门限，用来判断接下来的拼接是否能够顺利进行，是否会超过数字上下限
        sign = 1 # 假设符号为+
        i=1 # 假设第一位是符号位，数字从第二位开始
        if s[0] == '-': 
            sign = -1
        elif s[0] != '+': 
            i=0 # 第一位没有符号位，直接是数字
        for c in s[i:]:
            if not '0'<= c <='9':break
            if res>bandry or res==bandry and c > '7': return max_num if sign==1 else min_num
            res = res*10+ord(c)-ord('0')
        return sign*res

剑指 Offer 66. 构建乘积数组

class Solution:
    def constructArr(self, a: List[int]) -> List[int]:
        res = [1]*len(a)
        tmp = 1
        for i in range(1,len(a)):
            res[i] = res[i-1]*a[i-1] #前缀乘积
        for i in range(len(a)-2, -1, -1):
            tmp *= a[i+1] # 后缀乘积
            res[i] *= tmp
        return res