leetcode-动态规划

53. 最大子序和

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:    
        n = len(nums)
        dp = nums
        if n == 1:
            return dp[0]
        for i in range(1, n):
            dp[i] = max(dp[i - 1] + dp[i], dp[i])
        return max(dp)

70. 爬楼梯

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

746. 使用最小花费爬楼梯

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        if n == 1:
            return cost[0]
        if n == 2:
            return min(cost)
        
        dp = cost.copy()
        dp[0] = cost[0]
        dp[1] = cost[1]

        for i in range(2,n):
            dp[i] = min(dp[i - 2], dp[i - 1]) + cost[i]
        print(dp)
        return min(dp[-1], dp[-2])

198. 打家劫舍

class Solution:
    def rob(self, nums: List[int]) -> int:     
        n = len(nums)
        if n <= 0:
            return 0
        if n == 1:
            return nums[0]
        if n == 2:
            return max(nums)
        dp = nums.copy()
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])
        for i in range(2, n):
            dp[i] = max(dp[i] + dp[i - 2], dp[i - 1])
        print(dp)
        return dp[-1]

213. 打家劫舍 II

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 0:
            return 0

        if n <= 3:
            return max(nums)
        a = nums[1:]
        b = nums[:-1]
        dp1 = a.copy()
        dp1[0] = a[0]
        dp1[1] = max(a[0], a[1])
        for i in range(2, n - 1):
            dp1[i] = max(dp1[i - 2] + a[i], dp1[i - 1])
        
        dp2 = b.copy()
        dp2[0] = b[0]
        dp2[1] = max(b[0], b[1])
        for i in range(2, n - 1):
            dp2[i] = max(dp2[i - 2] + b[i], dp2[i - 1])

        return max(dp1[-1], dp2[-1])
            

64. 最小路径和

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

62. 不同路径

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[1 for i in range(n)] for i in range(m)]
        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[-1][-1]

63. 不同路径 II

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

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

322. 零钱兑换

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        size = len(coins)
        dp = [0] * (amount + 1)
        for i in range(1,amount+1):
            dp[i] = 9999
            for coin in coins:
                if i - coin >= 0:
                    dp[i] = min(dp[i], dp[i - coin] + 1)
        if dp[-1] == 9999:
            return -1
        else:
            return dp[-1]
        

392. 判断子序列

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        for i in s:
            if i in t:
                index = t.index(i)
                t = t[index+1:]
            else:
                return False
        return True

338. 比特位计数

class Solution:
    def countBits(self, num: int) -> List[int]:
        arr = []
        for i in range(num + 1):
            arr.append(str(bin(i)[2:]).count('1'))
        return arr