2021/7/20:动态规划

 

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        res = [([0]*2) for _ in range(n)]
        res[0][0] = 0
        res[0][1] = nums[0] #0不偷，1偷
        for i in range(1,n):
            res[i][0] = max(res[i-1][0],res[i-1][1])
            res[i][1] = res[i-1][0]+nums[i]
        return max(res[n-1][0],res[n-1][1]) 

 

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)
        res_0 = [([0]*2) for _ in range(n-1)]
        res_1 = [([0]*2) for _ in range(n-1)]
        res_0[0][0] = 0
        res_0[0][1] = -1000 #0不偷，1偷
        res_1[0][0] = -1000
        res_1[0][1] = nums[0] #0不偷，1偷
        res_0[1][0] = 0
        res_0[1][1] = nums[1] #0不偷，1偷
        res_1[1][0] = nums[0]
        res_1[1][1] = -1000 #0不偷，1偷
        for i in range(2,n-1):
            res_0[i][0] = max(res_0[i-1][0],res_0[i-1][1])       #不偷1，不偷i
            res_0[i][1] = res_0[i-1][0]+nums[i]
            res_1[i][0] = max(res_1[i-1][0],res_1[i-1][1]) 
            res_1[i][1] = res_1[i-1][0]+nums[i]
        print(res_0)
        print(res_1)
        resn_0 = max(res_0[-1][0],res_0[-1][1],res_1[-1][0],res_1[-1][1])
        resn_1 = res_0[-1][0] +nums[-1]
        return max(resn_0,resn_1) 

 

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        minpath = [[0]*n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if i-1 >= 0 and j-1 >= 0:
                    minpath[i][j] = min(minpath[i][j-1]+grid[i][j],minpath[i-1][j]+grid[i][j])
                elif i-1 >=0:
                    minpath[i][j] = minpath[i-1][j]+grid[i][j]
                elif j-1 >=0:
                    minpath[i][j] = minpath[i][j-1]+grid[i][j]
                else:
                    minpath[i][j] = grid[i][j]
        return minpath[m-1][n-1]

 

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        minpath = [[0]*n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if i-1 >= 0 and j-1 >= 0:
                    minpath[i][j] = minpath[i-1][j] + minpath[i][j-1]
                elif i-1 >= 0 or j-1 >= 0:
                    minpath[i][j] = 1
                else:
                    minpath[i][j] = 1
        return minpath[m-1][n-1]

 

class NumArray:

    def __init__(self, nums: List[int]):
        self.nums = nums

    def sumRange(self, left: int, right: int) -> int:
        amount = 0
        for i in range(left,right+1):
            amount += self.nums[i]
        return amount


# Your NumArray object will be instantiated and called as such:
# obj = NumArray(nums)
# param_1 = obj.sumRange(left,right)

class NumArray:

    def __init__(self, nums: List[int]):
        if nums:
            self.nums = [0]
            for num in nums:
                self.nums.append(self.nums[-1]+num)
        else: self.nums = []
    def sumRange(self, left: int, right: int) -> int:
        return self.nums[right+1]-self.nums[left]


# Your NumArray object will be instantiated and called as such:
# obj = NumArray(nums)
# param_1 = obj.sumRange(left,right)

 

暴力破解法：判断每2个数之间是不是一个等差数列 时间复杂度n^3

class Solution:
    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
        n = len(nums)
        count = 0
        for a in range(n-2):
            d = nums[a+1]-nums[a]
            for b in range(a+2,n):
                flag=0
                for i in range(a+1,b+1):
                    if(nums[i]-nums[i-1] != d):
                        break;
                    flag = i
                if (flag == b):
                    count += 1
        return count

动态规划：时间复杂度：O(N) 空间复杂度O(N)

 

class Solution:
    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
        n = len(nums)
        amount = 0
        if n <3:
            return 0
        dp = [0]*n
        for i in range(2,n):
            if nums[i]-nums[i-1] == nums[i-1] -nums[i-2]:
                dp[i] = dp[i-1]+1
                amount += dp[i]
        return amount

动态规划：时间复杂度：O(N) 空间复杂度O(1)

class Solution:
    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
        n = len(nums)
        amount = 0
        if n <3:
            return 0
        predp = 0
        dp = 0
        for i in range(2,n):
            if nums[i]-nums[i-1] == nums[i-1] -nums[i-2]:
                dp = predp +1
                amount += dp
                predp = dp
            else:
                predp = 0
        return amount

 

 

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

 

class Solution:
    def numSquares(self, n: int) -> int:
        dp =  [n]*(n+1)
        dp[0] = 0
        for i in range(1,n+1):
            for j in range(1,int(i**0.5)+1):
                dp[i] = min(i,dp[i],dp[i-j*j]+1)
        print(dp)
        return dp[n]

 搞清楚状态转移方程的判定条件！ 

如果是两个字母，则要看s[i-2] 和s[i-1]，可以分开看

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