1.91. 解码方法 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def numDecodings(self, s: str) -> int:
        n=len(s)
        dp=[0 for i in range(n+1)]
        dp[0]=1
        s=" "+s
        for i in range(1,n+1):
            if int(s[i])>=1 and int(s[i])<=26:
                dp[i]+=dp[i-1]
            if  i-1>0 and i<=n and s[i-1]!='0' and int(s[i-1:i+1])>=1 and int(s[i-1:i+1])<=26:
                dp[i]+=dp[i-2]
        if 0 in dp:
            return 0
        else:
            return dp[-1]

2.264. 丑数 II - 力扣（LeetCode） (leetcode-cn.com)

（1）优先队列

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        import queue
        q=queue.PriorityQueue()
        q.put(1)
        hashtable=[]
        while n:
            n-=1
            if n==0:
                return(q.get())
            else:
                top=q.get()
                if 2 * top not in hashtable:
                    q.put(2 * top)
                    hashtable.append(2 * top)
                if 3 * top not in hashtable:
                    q.put(3 * top)
                    hashtable.append(3 * top)
                if 5 * top not in hashtable:
                    q.put(5 * top)
                    hashtable.append(5 * top)

（2）DP

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        dp=[0 for i in range(n+1)]
        dp[1]=1
        p2,p3,p5=1,1,1
        for i in range(2,n+1):
            num2,num3,num5=dp[p2]*2,dp[p3]*3,dp[p5]*5
            dp[i]=min(num2,num3,num5)
            if dp[i]==num2:
                p2+=1
            if dp[i]==num3:
                p3+=1
            if dp[i]==num5:
                p5+=1
        return dp[-1]

3.96. 不同的二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def numTrees(self, n: int) -> int:
        if n==1:
            return 1
        dp=[0 for i in range(n+1)]
        dp[0]=1
        dp[1]=1
        dp[2]=2
        for i in range(3,n+1):
            for j in range(0,i):
                dp[i]+=dp[j]*dp[i-j-1]
        print(dp)
        return dp[-1]

4.931. 下降路径最小和 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def minFallingPathSum(self, matrix: List[List[int]]) -> int:
        n=len(matrix)
        dp=[[1<<31 for i in range(n+2)]for j in range(n+1)]
        for i in range(1,n+1):
            dp[1][i]=matrix[0][i-1]
        for i in range(2,n+1):
            for j in range(1,n+1):
                dp[i][j]=min(dp[i-1][j],dp[i-1][j-1],dp[i-1][j+1])+matrix[i-1][j-1]
        return min(dp[-1])

5.120. 三角形最小路径和 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        n=len(triangle)
        dp=[[1<<31 for i in range(n+2)]for j in range(n+1)]
        dp[1][1]=triangle[0][0]
        for i in range(2,n+1):
            for j in range(1,i+1):
                dp[i][j]=min(dp[i-1][j],dp[i-1][j-1])+triangle[i-1][j-1]
        return min(dp[-1])

6.1314. 矩阵区域和 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def matrixBlockSum(self, mat: List[List[int]], k: int) -> List[List[int]]:
        m,n=len(mat),len(mat[0])
        for i in range(m):
            for j in range(n):
                if i==0 and j==0:
                    continue
                elif i==0:
                    mat[i][j]+=mat[i][j-1]
                elif j==0:
                    mat[i][j]+=mat[i-1][j]
                else:
                    mat[i][j]+=mat[i][j-1]+mat[i-1][j]-mat[i-1][j-1]
        for i in range(m):
            mat[i].insert(0,0)
        mat.insert(0,[0 for i in range(n+1)])
        dp=[[]for i in range(m)]
        for i in range(m):
            for j in range(n):
                leftx=max(0,i-k)
                lefty=max(0,j-k)
                rightx=min(m,i+k+1)
                righty=min(n,j+k+1)
                dp[i].append(mat[rightx][righty]+mat[leftx][lefty]-mat[rightx][lefty]-mat[leftx][righty])
        return dp

7.63. 不同路径 II - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        n=len(obstacleGrid)
        m=len(obstacleGrid[0])
        dp=[[0 for i in range(m)]for j in range(n)]
        for i in range(m):
            if obstacleGrid[0][i]==1:
                break
            dp[0][i]=1
        for i in range(n):
            if obstacleGrid[i][0]==1:
                break
            dp[i][0]=1
        for i in range(1,n):
            for j in range(1,m):
                if obstacleGrid[i][j]==1:
                    continue
                dp[i][j]=dp[i-1][j]+dp[i][j-1]
        return dp[-1][-1]

8.64. 最小路径和 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        n=len(grid)
        m=len(grid[0])
        dp=[[0 for i in range(m)]for j in range(n)]
        dp[0][0]=grid[0][0]
        for i in range(1,n):
            dp[i][0]=dp[i-1][0]+grid[i][0]
        for i in range(1,m):
            dp[0][i]=dp[0][i-1]+grid[0][i]
        for i in range(1,n):
            for j in range(1,m):
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j]
        return dp[-1][-1]

9.221. 最大正方形 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        n=len(matrix)
        m=len(matrix[0])
        dp=[[0 for i in range(m)]for j in range(n)]
        ans=0
        for i in range(n):
            dp[i][0]=int(matrix[i][0])
            ans=max(ans,dp[i][0])
        for i in range(m):
            dp[0][i]=int(matrix[0][i])
            ans=max(ans,dp[0][i])
        for i in range(1,n):
            for j in range(1,m):
                if matrix[i][j]=='1':
                    dp[i][j]=min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1
                    ans=max(dp[i][j],ans)
        return ans*ans