动态规划算法

动态规划算法

同分治算法一样，将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。
动态规划与分治算法：
都涉及到递归问题，不同之处在于动态规划考虑到运算时的重复性
步骤：

• 定义一个状态，这是一个最优解的结构特征
• 进行状态的递推，得到递推公式
• 进行初始化
• 返回结果

使用条件：
有重叠子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到。（该性质并不是动态规划适用的必要条件，但是如果没有这条性质，动态规划算法同其他算法相比就不具备优势）
例：

斐波那契：

def fib(int n):
   if (n<=0):
       return 0
   elif(n==1 or n==2):
       return 1
   else:
       return fib(n-1)+fib(n-2)

时间复杂度为2^n
因为每次都重复计算fib(3),fib(4)
先定义一个空间存放计算过的值：

def fib(int n):
    f[n+1]=0
    f[0] = 0
    f[1] = 1
    f[2] = 1
    if n<=0:
        return f[0]
    elif n==1:
        return f[1]
    else:
    for i in range(3,n+1):
        fib[i] = fib[i-1]+fib[i-2]
    return f[n]

优化：

def fib(int n):
    if n<=0:
        return 
    elif n ==1 or n==2:
        return 1
    f1 = 0
    f2 = 1
    result = 0
    for i in range(2,n+1):
        result = f1+f2
        f1 = f2
        f2 = result
    return result

解析：
f3 = f2+f1
f4 = f3+f2
自底向上
保存上次运算值

小结：动态规划主要是解决递归问题中的时空复杂度的优化问题
因此，根本还是在于求解通解或者说递归表达式
空间有两种：
自顶向下：先规定所有值为一个向量，调用向量值，靠近0，1，2，计算即可
自底向上：采用一个中间参数result，赋值递进往上推，靠近值
题：

买卖股票

买卖股票的最佳时机，即求买卖股票的最大利润，至多只能交易一次
解题思路：动态规划法
前i天的最大利润 = max(前i-1天的最大利润，第i天的价格-前i天的最低价格)

class Solution:
    def maxProft(self,prices):
        if len(prices)==0:
            return 0
        else:
            p = 0
            pmin = float('inf')
            for i in prices:
                p =max(p,i-pmin)
                pmin = min(i,pmin)
            return p

打家劫舍

打劫一条街上的人家，相邻人家不能打劫，否则触动报警，求最多金额

class Solution:
    def rob(self, nums: List[int]) -> int:
        if nums ==[]:
            return 0
        elif len(nums)==1:
            return nums[0]
        else:
            l = [0 for x in range(len(nums))]
            l[0] = nums[0]
            l[1] = max(nums[0],nums[1])
            for i in range(2,len(nums)):
                l[i] = max(l[i-2]+nums[i],l[i-1])
            return l[len(nums)-1]

爬楼梯最小代价问题

第i个阶梯对应着一个非负数的体力花费，cost[i]
每次爬1或2个台阶
起始位置为索引0或1

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        l = len(cost)
        if l ==0:
            return 0
        elif l==1:
            return cost[0]
        else:
            a = [0 for x in range(l+1)]
            a[0] ==0
            a[1] ==0
            for i in range(2,l+1):
                a[i] = min(a[i-1]+cost[i-1],a[i-2]+cost[i-2])
            return a[l]

这题唯一拗口的地方在于给出台阶，但目标是登顶，即最后的结果是爬第i个台阶上去还是第i-1个台阶上去
还有思路没问题，提交十次都出错原因在于头脑短路，循环时从(0,l+1)而a[0]和a[1]已赋值，需要注意这些小问题，小问题最愁人

除数博弈

爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作：选出任一 x，满足 0 < x < N 且 N % x == 0 。用 N - x 替换黑板上的数字 N 。如果玩家无法执行这些操作，就会输掉游戏。

class Solution:
    def divisorGame(self, N: int) -> bool:
        f = [0 for i in range(N+1)]
        if N ==1:
            return False
        else:
            f[1] = 0
            f[2] = 1
            for i in range(3,N+1):
                for j in range(1,int(i**0.5)):
                    if i%j==0 and f[i-j]==0:
                        f[i]=1
                        break
            if f[N]==0:
                return False
            else:
                return True