算法题复健之路 第21 22 23天 主要还是递归

第21天：

对应leetcode:

240. 搜索二维矩阵 II

没什么特别的 就是二分查找 然后以行为单位 一行行的往下遍历 这种算是使用了什么分治？

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        def binary_search(nums, target):
            l, r = 0, len(nums)-1
            while l <= r:
                mid = (l + r) // 2
                if nums[mid] == target:
                    return True
                if nums[mid] < target:
                    l = mid+1
                if nums[mid] > target:
                    r = mid-1
            return False

        l_l = len(matrix[0])

        for line in matrix:
            if line[0] <= target and line[l_l - 1] >= target:
                if binary_search(line, target):
                    return True
        return False

面试题 08.12. 八皇后

听说八皇后是经典回溯题

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        board = [['.' for _ in range(n)] for _ in range(n)]
        res = []

        def helper(left_diagonal, right_diagonal, column):
            j = len(column)
            if len(column) == n:
                tmp = []
                for k in board:
                    tmp.append(''.join(k))
                res.append(tmp)
            for i in range(n):
                if (i in column) or (i - j in left_diagonal) or (i + j in right_diagonal):
                    continue
                board[j][i] = 'Q' 
                helper(left_diagonal + [i - j], right_diagonal + [i + j], column + [i])
                board[j][i] = '.' 

        helper(left_diagonal=[], right_diagonal=[], column=[])
        return res

实际做了后，其实理解的也不是很深，大概意思就是深搜那样的，不停往前走，判断条件然后递归吧 感觉掌握的也不是很好，后续可以复盘，题解大家先看看。

第22天：

神秘的22，但是我还是做了题.

62. 不同路径

超经典的动态规划，唯一需要注意的是，它只能往下或者右走，所以边界状态都是1，因为只能往下或者右，所以在边界的时候一定只有一种走法。

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[0]*n for _ in range(m)]
        if m == n == 1:
            return 1
        for i in range(1, n):
            dp[0][i] = 1
        for i in range(1, m):
            dp[i][0] = 1

        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i-1][j]+dp[i][j-1]

        return dp[m-1][n-1]

第23天：

​​​​​​10. 正则表达式匹配

今天做的，并没有所谓的正则表达式太多的内容，其实本质上还是一个动态规划，题解也有用正则做的，这方面没太了解过，之后可以去看看，动态规划的话，这题还挺难，主要难点就是状态转移方程，DP的两个维度是S P两个数组，就是遇到*的时候往前匹配 ，然后遇到问题就直接跳过两个点。

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        m, n = len(s), len(p)
        dp = [[False]*(n+1) for _ in range(m+1)]

        dp[0][0] = True
        for j in range(1, n+1):
            if p[j-1] == '*':
                dp[0][j] = dp[0][j-2]

        for i in range(1, m+1):
            for j in range(1, n+1):
                if s[i-1] == p[j-1] or p[j-1] == '.':
                    dp[i][j] = dp[i-1][j-1]
                elif p[j-1] == '*':
                    if s[i-1] != p[j-2] and p[j-2] != '.':
                        dp[i][j] = dp[i][j-2]
                    else:
                        dp[i][j] = dp[i][j-2] | dp[i-1][j]

        return dp[m][n]