[Leetcode]动态规划之游戏&贪心问题——python版本

本篇文章根据labuladong的算法小抄汇总动态规划（游戏和贪心问题）的常见算法，采用python3实现

一、用动态规划玩游戏

最小路径和

#dp函数：从左上角(0,0)到(i,j)都最小路径和为dp(grid,i,j)
def minPathSum(grid):
	def dp(grid,i,j):
        if (i == 0) and (j == 0):
            return grid[0][0]
        if (i < 0) or (j < 0):
            return float("inf")
        return min(
            dp(grid,i-1,j),
            dp(grid,i,j-1)
        ) + grid[i][j]
    m = len(grid)
    n = len(grid[0])
    return dp(grid,m-1,n-1)

备忘录改进：

#时间O(MN)，空间O(MN)
def minPathSum(grid):
    def dp(grid,i,j):
        if (i == 0) and (j == 0):
            return grid[0][0]
        if (i < 0) or (j < 0):
            return float("inf")
        if memo[i][j] != -1:
            return memo[i][j]
        memo[i][j] = min(dp(grid,i-1,j),dp(grid,i,j-1)) + grid[i][j]
        return memo[i][j]
    m = len(grid)
    n = len(grid[0])
    memo = [[-1 for i in range(n)] for j in range(m)]
    return dp(grid,m-1,n-1)

dp数组：

#dp[i][j]：从(0,0)到(i,j)的最小路径和
def minPathSum(grid):
    m = len(grid)
    n = len(grid[0])
    dp = [[0 for i in range(n)] for j in range(m)]
    dp[0][0] = grid[0][0]
    for i in range(1,m):
        dp[i][0] = dp[i-1][0] + grid[i][0]
    for j in range(1,n):
        dp[0][j] = dp[0][j-1] + grid[0][j]
    for i in range(1,m):
        for j in range(1,n):
            dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + grid[i][j]
    return dp[m-1][n-1]

K站中转内最便宜的航班

• 求最短路径，肯定可以用BFS解决
• 对于加权图的场景，需要优先级队列[自动排序]的特性，将路径权重较小的节点排在队列前面
• 下面用动态规划解决

def findCheapestPrice(n,flights,src,dst,k):
    #dp函数：从src出发，k步之内到达s的最小路径权重为dp(s,k)
    def dp(s,k):
        if s == src:
            return 0
        if k == 0:
            return -1
        res = float("inf")
        if s in indegree:
            for v in indegree[s]:
                from_ = v[0]
                price = v[1]
                subProblem = dp(from,k-1)
                if subProblem != -1:
                    res = min(res,subProblem + price)
        return res if res != float("inf") else -1
        
    k += 1
    indegree = dict() #to -> [from,price]
    for f in flights:
        from_ = f[0]
        to = f[1]
        price = f[2]
        if to in indegree:
            indegree[to].append([from_,price])
        else:
            indegree[to] = [from_,price]
    return dp(dst,k)

• dp数组

class Solution:
    def findCheapestPrice(self, n: int, flights: List[List[int]], src: int, dst: int, k: int) -> int:

        #dp[i][j]=x表示从src到i，j步之内的最便宜的价格(行表示n个城市对应索引，列表示k步之内)
        k += 1
        dp = [[float("inf") for i in range(k+1)] for j in range(n)]
        for f,t,p in flights:
            if f == src:
                dp[t][1] = p
        for x in range(2,k+1):
            for f,t,p in flights:
                dp[t][x] = min(dp[t][x],dp[t][x-1],dp[f][x-1]+p)

        return dp[dst][k] if dp[dst][k] != float("inf") else -1

高楼扔鸡蛋

题目：给定k枚鸡蛋，1…n层楼。已知存在楼层f（0…n），任何高于f的楼层落下的鸡蛋都会碎，从f楼层或比它低的楼层落下的鸡蛋都不会破。如果鸡蛋碎了就不能用，如果没碎就可以用。请你计算并返回要确定f值的最小操作次数。

#时间O(K*N^2)，空间O（KN）
def superEggDrop(K,N):
    memo = dict()
    def dp(K,N):
        if K == 1:
            return N
        if N == 0:
            return 0
        if (K,N) in memo:
            return memo[(K,N)]
        res = float("inf")
        for i in range(1,N+1):
            res = min(res,max(dp(K,N-i),dp(K-1,i-1))+1)
        memo[(K,N)] = res
        return res
    return dp(K,N)

• 二分查找优化

#时间O(K,N,logN)，空间O(KN)
class Solution:
    def superEggDrop(self, k: int, n: int) -> int:

        def dp(k,n):
            if k == 1:
                return n
            if n == 0:
                return 0
            if (k,n) in memo:
                return memo[(k,n)]
            res = float("inf")
            # 用二分搜索代替线性搜索
            lo, hi = 1, n
            while lo <= hi:
                mid = (lo + hi) // 2
                broken = dp(k - 1, mid - 1) # 碎
                not_broken = dp(k, n - mid) # 没碎
                # res = min(max(碎，没碎) + 1)
                if broken > not_broken:
                    hi = mid - 1
                    res = min(res, broken + 1)
                else:
                    lo = mid + 1
                    res = min(res, not_broken + 1)
            memo[(k,n)] = res
            return res

打家劫舍1

备忘录：

def rob(nums):
    def dp(nums,start):
        if start >= len(nums):
            return 0
        if memo[start] != -1:
            return memo[start]
        memo[start] = max(dp(nums,start+1),dp(nums,start+2)+nums[start])
        return memo[start]
        
    memo = [-1 for i in range(nums)]
    return dp(nums,0)

dp数组

def rob(nums):
    n = len(nums)
    dp = [0 for i in range(n+2)]
    for i in range(n-1,-1,-1):
        dp[i] = max(dp[i+1],dp[i+2]+nums[i])
    
    return dp[0]

状态压缩

def rob(nums):
    n = len(nums)
    dp_i_1 = 0
    dp_i_2 = 0
    for i in range(n-1,-1,-1):
        dp_i = max(dp_i_1,dp_i_2+nums[i])
        dp_i_2 = dp_i_1
        dp_i_1 = dp_i
    return dp_i

打家劫舍2

def rob(nums):
    def robRange(nums,start,end):
        n = len(nums)
        dp_1 = 0
        dp_2 = 0
        for i in range(end,start-1,-1):
            dp_i = max(dp_1,dp_2+nums[i])
            dp_2 = dp_1
            dp_1 = dp_i
        return dp_i
    
    n = len(nums)
    if n == 1:
        return nums[0]
    return max(robRange(nums,0,n-2),robRange(nums,1,n-1))

打家劫舍3

class Solution:
    def rob(self, root: TreeNode) -> int:
        def dp(root):
            if root is None:
                return 0
            if root in memo:
                return memo.get(root)
            do_it = root.val + (0 if root.left is None else dp(root.left.left)+dp(root.left.right))+(0 if root.right is None else dp(root.right.left) + dp(root.right.right))
            not_do = dp(root.left) + dp(root.right)
            res = max(do_it,not_do)
            memo[root] = res
            return res
        memo = dict()
        return dp(root)

实现strStr()

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

暴力解法

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        M = len(needle)
        N = len(haystack)
        if M == 0:
            return 0
        if M > N:
            return -1
        for i in range(N-M+1):
            j = 0
            while j < M:
                if haystack[i+j] != needle[j]:
                    break
                else:
                    j += 1
            if j == M:
                return i
        return -1

KMP算法

#dp[j][c]=next表示状态j碰到字符c转移到状态next
def KMP(pat):
    M = len(pat)
    dp = [[0 for i in range(256)] for j in range(M)]
    dp[0][ord(pat[0])] = 1
    X = 0
    for j in range(1,M):
        for c in range(256):
            if ord(pat[j]) == c:
                dp[j][c] = j + 1
            else:
                dp[j][c] = dp[X][c]
            X = dp[X][ord(pat[j])]
    
def search(txt):
    M = len(pat)
    N = len(txt)
    j = 0
    for i in range(N):
        j = dp[j][txt[i]]
        if j == M:
            return i-M+1
    return -1

四键键盘

def maxA(n):
	def dp(n,a_num,copy):
        if n <= 0:
            return a_num
        if (n,a_num,copy) in memo:
            return memo[(n,a_num,copy)]
        memo[(n,a_num,copy)] = max(dp(n-1.a_num+1,copy),
                                   dp(n-1,a_num+copy,copy),
                                   dp(n-2,a_num,a_num)
                                  )
        return memo[(n,a_num,copy)]
    memo = dict()
    return dp(n,0,0)

def maxA(N):
    dp = [0 for i in range(N+1)]
    dp[0] = 0
    for i in range(N+1):
        #按A
        dp[i] = dp[i-1] + 1
        #第j个是ctrl+v
        for j in range(2,i):
            dp[i] = max(dp[i],dp[j-2]*(i-j+1))
    return dp[N]

石子游戏

def stoneGame(piles):
    n = len(piles)
    dp = [[[0 for i in range(n)] for j in range(n)] for k in range(2)]
    for i in range(n):
        dp[i][i][0] = piles[i]
        dp[i][i][1] = 0
    for i in range(n-2,-1,-1):
        for j in range(i+1,n):
            left = piles[i] + dp[i+1][j][1]
            right = piles[j] + dp[i][j-1][1]
            if left > right:
                dp[i][j][0] = left
                dp[i][j][1] = dp[i+1][j][0]
            else:
                dp[i][j][0] = right
                dp[i][j][1] = dp[i][j-1][0]
    return dp[0][i-1][0] - dp[0][i-1][1]

构造回文的最小插入次数

def minInsertions(s):
    n = len(s)
    dp = [[0 for i in range(n)] for j in range(n)]
    for i in range(n-2,-1,-1):
        for j in range(i+1,n):
            if s[i] == s[j]:
                dp[i][j] = dp[i+1][j-1]
            else:
                dp[i][j] = min(dp[i+1][j],dp[i][j-1]) + 1
    return dp[0][n-1]

买卖股票的最佳时机只买卖一次

给定一个数组，第i个元素是一支给定股票在第i天的价格，设计一个算法来计算你所能获取的最大利润。你最多可以完成k笔交易。注意：你不能同时参与多笔交易。

#原始版本
def maxProfits(prices):
    n = len(prices)
    dp = [[0 for i in range(2)] for j in range(n)]
    dp[0][0] = 0
    dp[0][1] = -prices[0]
    for i in range(1,n):
        dp[i][0] = max(dp[i-1][0],dp[i-1][1] + prices[i])
        dp[i][1] = max(dp[i-1][1],- prices[i])
    return dp[n-1][0]
#空间复杂度优化版本
def maxProfits(prices):
    n = len(prices)
    dp_i_0 = 0
    dp_i_1 = -prices[0]
    for i in range(1,n):
        dp_i_0 = max(dp_i_0,dp_i_1 + prices[i])
        dp_i_1 = max(dp_i_1,- prices[i])
    return dp_i_0

股票买卖的最佳时机不限次数

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp_i_0 = 0
        dp_i_1 = -prices[0]
        for i in range(1,n):
            dp_i_0 = max(dp_i_0,dp_i_1 + prices[i])
            dp_i_1 = max(dp_i_1,dp_i_0 - prices[i])
        return dp_i_0 

股票买卖的最佳时机含冷冻期不限次数

def maxProfit(prices):
    n = len(prices)
    dp = [[0 for i in range(2)] for j in range(n)]
    dp[0][0] = 0
    dp[0][1] = -prices[0]
    for i in range(1,n):
        dp[i][0] = max(dp[i-1][0],dp[i-1][1] + prices[i])
        dp[i][1] = max(dp[i-1][1],dp[i-2][0] - prices[i])
    return dp[n-1][0]

股票买卖的最近时机含手续费不限次数

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        dp = [[0 for i in range(2)] for j in range(n)]
        dp[0][0] = 0
        dp[0][1] = - prices[0]
        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0],dp[i-1][1] + prices[i] - fee)
            dp[i][1] = max(dp[i-1][1],dp[i-1][0] - prices[i])
        return dp[n-1][0]

股票买卖问题的最佳时机最多买卖两次

def maxProfit(prices):
    max_k = 2
    n = len(prices)
    dp = [[[0 for i in range(max_k+1)] for j in range(3)] for k in range(n)]
    for i in range(n):
        for k in range(max_k,0,-1):#遍历顺序？
            if i - 1 == -1:
                dp[i][k][0] = 0
                dp[i][k][1] = - prices[0] #不消耗交易次数？
                continue
            dp[i][k][0] = max(dp[i-1][k][0],dp[i-1][k][1] + prices[i])
            dp[i][k][1] = max(dp[i-1][k][1],dp[i-1][k-1][0] - prices[i])
    return dp[n-1][max_k][0]
            

股票买卖的最佳时机限制k次

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        n = len(prices)
        if n == 0:
            return 0
        dp = [[[0 for i in range(2)] for j in range(k+1)] for h in range(n)]
        for h in range(1,k+1):
            dp[0][h][0] = 0
            dp[0][h][1] = - prices[0]
        for i in range(1,n):
            for j in range(1,k+1):
                dp[i][j][0] = max(dp[i-1][j][0],dp[i-1][j][1] + prices[i])
                dp[i][j][1] = max(dp[i-1][j][1],dp[i-1][j-1][0] - prices[i])
        return dp[n-1][k][0]

二、贪心类型问题

贪心算法是动态规划的一个特例，需要满足更多条件（贪心选择性质），但效率比动态规划高。

贪心选择性质：每一步都做出一个局部最优的选择，最终结果就是全局最优。

区间调度问题

def intervalSchedule(intvs):
    if len(intvs) == 0:
        return 0
    intvs.sort(key = lambda a : a[1])
    count = 1
    x_end = intvs[0][1]
    for interval in intvs:
        start = interval[0]
        if start >= x_end:
            count += 1
            x_end = interval[1]
    return count

无重叠区间,435

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        n = len(intervals)
        if n == 0:
            return 0
        intervals.sort(key=lambda a:a[1])
        end = intervals[0][1]
        count = 1
        for interval in intervals:
            if interval[0] >= end:
                end = interval[1]
                count += 1
        return n - count

用最少数量的箭引爆气球，452

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        n = len(points)
        if n == 0:
            return 0
        points.sort(key=lambda a:a[1])
        count = 1
        end = points[0][1]
        for point in points:
            if point[0] > end:
                end = point[1]
                count += 1
        return count

安排会议室，253

#计算最多有几个重叠区间
def minMeetingRooms(meetings):
    n = len(meetings)
    begin = [0 for i in range(n)]
    end = [0 for i in range(n)]
    for i in range(n):
        begin[i] = meetings[i][0]
        end[i] = meetings[i][1]
    begin.sort()
    end.sort()
    count = 0
    res = 0
    i = 0
    j = 0
    while (i < n) and (j < n):
        if begin[i] < end[j]:
            count += 1
            i += 1
        else:
            count -= 1
            j += 1
        res = max(res,count)
    return res

视频拼接

def videoStitching(clips,T):
    n = len(clips)
    clips.sort(key = lambda a:(a[0],-a[1]))
    curEnd = 0
    nextEnd = 0
    count = 0
    i = 0
    while (i < n) and (clips[i][0] <= curEnd):
        while (i < n) and (clips[i][0] <= curEnd):
            nextEnd = max(nextEnd,clips[i][1])
            i += 1
        curEnd = nextEnd
        count += 1
        if curEnd >= T:
            return count
    return -1

跳跃游戏一,55

def canJump(nums):
    n = len(nums)
    farthest = 0
    for i in range(n-1):
        farthest = max(farthest,i + nums[i])
        if farthest <= i:
            return False
    return farthest >= n-1

跳跃游戏二，45

动态规划：

def jump(nums):
    def dp(nums,p):
        n = len(nums)
        if p >= n-1:
            return 0
        if memo[p] != n:
            return memp[p]
        steps = nums[p]
        for i in range(1,steps+1):
            subProblem = dp(nums,p+i)
            memo[p] = min(memo[p],subProblem+1)
        return memo[p]
    n = len(nums)
    memo = [n for i in range(n)]
    return dp(nums,0)

贪心算法：

def jump(nums):
    n = len(nums)
    end = 0
    count = 0
    farthest = 0
    for i in range(n-1):
        farthest = max(nums[i] + i,farthest)
        if end == i:
            count += 1
            end = farthest
    return count

加油站

数学图像：

def canCompleteCircuit(gas,cost):
    n = len(gas)
    sum = 0
    minSum = 0
    start = 0
    for i in range(n):
        sum += gas[i] - cost[i]
        if sum < minSum:
            start = i + 1
            minSum = sum
    if sum < 0:
        return -1
    return start if start != n else 0

贪心算法：

def canCompleteCircuit(gas,cost):
    n = len(gas)
    sum = 0
    for i in range(n):
        sum += gas[i] - cost[i]
    if sum < 0:
        return -1
    tank = 0
    start = 0
    for i in range(n):
        tank += gas[i] - cost[i]
        if tank < 0:
            tank = 0
            start = i+1
    return start if start != n else 0