leetcode初级算法——动态规划

（题目源自leetcode，方法都是自(cai)己(ji)写的，可能比较符合菜鸡们的思路）

1.爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

class Solution:
    def climbStairs(self, n: int) -> int:
        if n < 3: return n
        a,b,temp = 1,2,0
        for i in range(3,n+1):
            temp = a+b
            a = b
            b = temp
        return temp

这题从根本上来讲，就是n阶楼梯最后一步走1阶还是2阶，走1阶就是n-1阶楼梯的所有走法，走2阶就是n-2阶楼梯的所有走法，然后二者相加就是n阶楼梯的所有走法。
最开始写了个递归，但是测试过不了，超时严重。这种类型的题还是得把思路简化，然后尽量用一个循环解决。

解法2
斐波那契数列：每一项是前两项的和

class Solution:
    def climbStairs(self, n: int) -> int:
        import math
        sqrt5=5**0.5
        fibin=math.pow((1+sqrt5)/2,n+1)-math.pow((1-sqrt5)/2,n+1)
        return int(fibin/sqrt5)

公式属实容易记错，所以还是老老实实DP动态规划吧。

2.买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        profile = 0
        min = 10000
        for i in range(0,len(prices)):
            if prices[i]<min:   min = prices[i]
            profile = max(profile,prices[i]-min)            
        return profile

一开始想的太复杂了，其实每天能卖到的最大利润，就是这一天的价格减去之前的最低价，这是最理想的。所以一个循环就能搞定，一边找最低价min，一边算能获得的最大利润profile。

还有一种方法，是根据每天的价格差来做，和我的脑回路实在是有些不搭，所以就不用了。

3.最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

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

这题跟上一题一样，其实都是双指针一个循环，应该也是上一题的第二种解法，就是对每日价格差求最大子序和。

4.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

class Solution:
    def rob(self, nums: List[int]) -> int:
        # result = []
        # def search(left, total):
        #     if left == []:
        #         return total
        #     return max(search(left[1:],total), search(left[2:],total+left[0]))

        # return search(nums,0)
        if nums == []:
            return 0
        if len(nums) == 1:
            return nums[0]
        if len(nums) == 2:
            return max(nums)
        rob = [0]*len(nums)
        rob[0] = nums[0]
        rob[1] = max(rob[0],nums[1])
        for i in range(2,len(nums)):
            rob[i] = max(rob[i-2]+nums[i], rob[i-1])
        return max(rob)

当前房间偷就是rob[i-2]+nums[I]，不偷就是rob[i-1]，求max就可以了