leetcode动态规划

leetcode120. 三角形最小路径和[M]

### leetcode 120 三角形最小路径和 时间复杂度O(n**2)，空间复杂度O(n) ###
### 从下到上动态规划
class Solution:
    def minimumTotal(self, triangle):
        f=triangle[-1]    # 将路径最小和存入f
        row = len(triangle)
        for i in range(row-2,-1,-1):
            for j in range(len(triangle[i])):
                f[j] = min(f[j],f[j+1])+triangle[i][j]
        return f[0]

leetcode53最大子序和[E]

### leetcode53最大子序和[E] 时间复杂度O(n)，空间复杂度O(1)###
class Solution:
    def maxSubArray(self, nums):
        f = nums[0]
        maxsubarray=f
        for x in nums[1:]:
            f1 = max(f+x,x)   # 当前段和>0时有用，加上；否则另起开头
            f = f1
            if f1>maxsubarray:
                maxsubarray  = f1
        return maxsubarray

leetcode62不同路径[M]

### leetcode62不同路径 时间复杂度O(m*n) 空间复杂度O(m*n) ###
class Solution:
    def uniquePaths(self, m, n):
        f = [[1 for _ in range(n)] for _ in range(m)] # 将路径个数写到一个矩阵f中，第一行和第一列都为1,不用再进行计算
        for i in range(1,m):
            for j in range(1,n):
                f[i][j] = f[i-1][j]+f[i][j-1]  # 从（1，1）开始，从上到下进行计算
        return f[-1][-1]

leetcode64 最小路径和[M]

### leetcode64 最小路径和 时间复杂度O(m*n) 空间复杂度O(n) ###
class Solution:
    def minPathSum(self, grid):
        m = len(grid)
        n = len(grid[0])
        f = [grid[0][0]]*n
        for j in range(1,n):
            f[j] = f[j-1]+grid[0][j]
        for i in range(1,m):
            for j in range(n):
                if j==0:
                    f[j] += grid[i][j]
                else:
                    f[j] = min(f[j],f[j-1])+grid[i][j]
        return f[-1]

leetcode63 不同路径II[M]

### leetcode63 不同路径II 时间复杂度O(m*n) 空间复杂度O(1) ###
class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid):
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        if obstacleGrid[0][0]==1:  # 如果起始位置有障碍，返回0条路径
            return 0
        else:
            obstacleGrid[0][0] = 1
        for j in range(1,n):      # 遍历第一行，如果有障碍，路径设为0，否则延续前边的情况
            if obstacleGrid[0][j]==1:
                obstacleGrid[0][j]=0
            else:
                obstacleGrid[0][j] = obstacleGrid[0][j-1]
        for i in range(1,m):    # 遍历第一列，如果有障碍，路径设为0，否则延续上边的情况
            if obstacleGrid[i][0]==1:
                obstacleGrid[i][0]=0
            else:
                obstacleGrid[i][0] = obstacleGrid[i-1][0]
        for i in range(1,m):   # 从（1，1）遍历到结束，如果有障碍，路径设为0，否则延续前边和上边的情况
            for j in range(1,n):
                if obstacleGrid[i][j] == 1:
                    obstacleGrid[i][j] = 0
                else:
                    obstacleGrid[i][j] = obstacleGrid[i-1][j]+obstacleGrid[i][j-1]
        return obstacleGrid[-1][-1]

leetcode91解码方法 [M]

### leetcode91解码方法 时间复杂度O(n),空间复杂度O(n)（可减少为O(1)）###
class Solution:
    def numDecodings(self, s):
        n = len(s)
        if s[0] < '1':   # 如果开头为0，则返回0
            return 0
        else:
            f = [1] * n # f是存放解码方法个数的数组
        for i in range(1, n): 
            if i == 1:  # 对于第2个来说，先看是不是0，如果是0，再与前边一块看有没有在1-26范围内，如果不在则返回0，如果在赋值1
                if s[i] == '0':
                    if s[i - 1:i + 1] <= '26' and s[i - 1:i + 1] >= '1':
                        f[i] = 1
                    else:
                        return 0
                else:   # 如果不是0，再看是否在1-26范围内，如果在则赋值2，如果不在赋值1
                    if s[0:2] > '26':
                        f[i] = 1
                    else:
                        f[i] = 2
            else: # 对于从第三个数往后的数来说，也先看是不是0
                if s[i] == '0': # 如果是0，与前边数连在一起，如果在1-26范围内，则赋值f[i-2],如果不在返回0
                    if s[i - 1:i + 1] <= '26' and s[i - 1:i + 1] >= '1':
                        f[i] = f[i - 2]
                    else:
                        return 0
                else:  # 如果不是0，与前边数连在一起，如果在1-26范围内，则赋值f[i-2],如果不在则赋值f[i-2]+f[i-1]
                    if s[i - 1:i + 1] > '26' or s[i - 1] == '0':
                        f[i] = f[i - 1]
                    else:
                        f[i] = f[i - 1] + f[i - 2]
        return f[-1]

leetcode139单词拆分[M]

### leetcode139单词拆分 时间复杂度O(n**2) 空间复杂度O(n) ###
class Solution:
    def wordBreak(self, s, wordDict):
        n = len(s)
        f = [False]*(n+1)  # 用f[i]记录s[:i]是否能拆分
        f[0] = True
        for i in range(1,n+1):
            for j in range(0,i):
                if f[j] and s[j:i] in wordDict: # 如果从能拆分位置j开始到i-1这一段s[j:i]在字典里，f[i]记为True
                    f[i] = True
        return f[-1]