Python每日一练(20230416) 有效数字、二叉树最大深度、单词搜索

class Solution(object):
    def isNumber(self, s):
        s = s.strip()
        ls, pos = len(s), 0
        if ls == 0:
            return False
        if s[pos] == '+' or s[pos] == '-':
            pos += 1
        isNumeric = False
        while pos < ls and s[pos].isdigit():
            pos += 1
            isNumeric = True
        if pos < ls and s[pos] == '.':
            pos += 1
            while pos < ls and s[pos].isdigit():
                pos += 1
                isNumeric = True
        elif pos < ls and s[pos] == 'e' and isNumeric:
            isNumeric = False
            pos += 1
            if pos < ls and (s[pos] == '+' or s[pos] == '-'):
                pos += 1
            while pos < ls and s[pos].isdigit():
                pos += 1
                isNumeric = True
        if pos == ls and isNumeric:
            return True
        return False
# %%
s = Solution()
print(s.isNumber(s = "0"))
print(s.isNumber(s = "e"))
print(s.isNumber(s = "."))
print(s.isNumber(s = ".1"))

class TreeNode:
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None
def listToTree(lst: list) -> TreeNode:
    if not lst:
        return None
    root = TreeNode(lst[0])
    queue = [root]
    i = 1
    while i < len(lst):
        node = queue.pop(0)
        if lst[i] is not None:
            node.left = TreeNode(lst[i])
            queue.append(node.left)
        i += 1
        if i < len(lst) and lst[i] is not None:
            node.right = TreeNode(lst[i])
            queue.append(node.right)
        i += 1
    return root
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root is None:
            return 0
        maxdepth = max(self.maxDepth(root.left),self.maxDepth(root.right)) + 1
        return maxdepth
# %%
s = Solution()
null = None
nums = [3,9,20,null,null,15,7]
root = listToTree(nums)
print(s.maxDepth(root))

class TreeNode:
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None
def listToTree(lst: list) -> TreeNode:
    if not lst:
        return None
    root = TreeNode(lst[0])
    queue = [root]
    i = 1
    while i < len(lst):
        node = queue.pop(0)
        if lst[i] is not None:
            node.left = TreeNode(lst[i])
            queue.append(node.left)
        i += 1
        if i < len(lst) and lst[i] is not None:
            node.right = TreeNode(lst[i])
            queue.append(node.right)
        i += 1
    return root
class Solution:
    def maxDepth(self, root: TreeNode):
        if not root:
            return 0
        depth = []
        def dfs(node, nodes=[]):
            if not node:
                return
            nodes.append(node.val)
            if node.left or node.right:
                dfs(node.left, nodes)
                dfs(node.right, nodes)
            else:
                depth.append(len(nodes))
            nodes.pop()
        dfs(root)
        return max(depth)
# %%
s = Solution()
null = None
nums = [3,9,20,null,null,15,7]
root = listToTree(nums)
print(s.maxDepth(root))

class Solution(object):
    def exist(self, board, word):
        """
        :type board: List[List[str]]
        :type word: str
        :rtype: bool
        """
        check_board = [[True] * len(board[0]) for _ in range(len(board))]
        for i in range(len(board)):
            for j in range(len(board[0])):
                if board[i][j] == word[0] and check_board:
                    check_board[i][j] = False
                    res = self.check_exist(check_board, board, word, 1, len(word), i, j)
                    if res:
                        return True
                    check_board[i][j] = True
        return False
    def check_exist(self, check_board, board, word, index, ls, row, col):
        if index == ls:
            return True
        for temp in [(0, 1),(0, -1),(1, 0),(-1, 0)]:
            curr_row = row + temp[0]
            curr_col = col + temp[1]
            if curr_row >= 0 and curr_row < len(board) and curr_col >= 0 and curr_col < len(board[0]):
                if check_board[curr_row][curr_col] and board[curr_row][curr_col] == word[index]:
                    check_board[curr_row][curr_col] = False
                    res = self.check_exist(check_board, board, word, index + 1, len(word), curr_row, curr_col)
                    if res:
                        return res
                    check_board[curr_row][curr_col] = True
        return False
if __name__ == "__main__":
    s = Solution()
    print (s.exist(board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"))