动态规划算法模板和demo

366. 斐波纳契数列

样例

样例  1:
	输入:  1
	输出: 0
	
	样例解释: 
	返回斐波那契的第一个数字，是0.

样例 2:
	输入:  2
	输出: 1
	
	样例解释: 
	返回斐波那契的第二个数字是1.

class Solution:
    """
    @param n: an integer
    @return: an ineger f(n)
    """
    def fibonacci(self, n):
        # write your code here
        if n == 1:
            return 0
        if n == 2:
            return 1
             
        dp = [0]*n
        dp[1] = 1
        for i in range(2, n):
            dp[i] = dp[i-1]+dp[i-2]
        return dp[n-1]

最原始的DP！！！

在测试数据中第 N 个斐波那契数不会超过32位带符号整数的表示范围

纯用递归会超时，如果用带有记忆化的递归就可以，使用循环和记忆化递归的时间复杂度一样，都是

优化：

class Solution:
    def fibonacci(self, n):
        a = 0
        b = 1
        for i in range(n - 1):
            a, b = b, a + b
        return a

近期（20230124）补充含子状态的dp！ 309. 最佳买卖股票时机含冷冻期详见：https://www.cnblogs.com/bonelee/p/17077984.html

322. 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：

[1, 2, 5]
11
3

示例 2：

[2]
3

示例 3：

输入：coins = [1], amount = 0
输出：0

提示：

1 <= coins.length <= 12
1 <= coins[i] <= 2³¹ - 1
0 <= amount <= 10⁴

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        if amount == 0:
            return 0
 
        inf = float('inf')
        dp = [inf]*(amount+1)
        coins.sort()
        for i in range(1, amount+1):
            for j in range(len(coins)):
                if coins[j] > i:
                    break
                 
                if coins[j] == i:
                    dp[i] = 1
                    break
 
                dp[i] = min(dp[i], dp[coins[j]]+dp[i-coins[j]])                    
                 
        if dp[amount] == inf:
            return -1
         
        return dp[amount]

关键是注意2个for的正确设置！！！我原本两个for amount的，结果超时了！所以上面包含了剪纸的技巧。

337. 打家劫舍 III

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额。

示例 1:

输入: root = [3,2,3,null,3,null,1]
输出: 7 
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7

示例 2:

输入: root = [3,4,5,1,3,null,1]
输出: 9
解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9

这个是属于树类dp，有两种解法，见：https://leetcode.cn/problems/house-robber-iii/solution/san-chong-fang-fa-jie-jue-shu-xing-dong-tai-gui-hu/

本质上是dfs，无非是返回节点标记了2个state！

class Solution:
    def rob(self, root: Optional[TreeNode]) -> int:        
        def dfs(root):
            if not root:
                return 0, 0
            l_steal, l_unsteal = dfs(root.left)
            r_steal, r_unsteal = dfs(root.right)
            unsteal = max(l_steal, l_unsteal) + max(r_steal, r_unsteal)
            steal = l_unsteal + r_unsteal + root.val
            return steal, unsteal
         
        return max(dfs(root))

110. 最小路径和

样例

样例 1:
	输入:  [[1,3,1],[1,5,1],[4,2,1]]
	输出: 7
	
	样例解释：
	路线为： 1 -> 3 -> 1 -> 1 -> 1。


样例 2:
	输入:  [[1,3,2]]
	输出:  6
	
	解释:  
	路线是： 1 -> 3 -> 2

注意事项

你在同一时间只能向下或者向右移动一步

Dp[i][j] 存储从（0， 0）到（i, j）的最短路径。
Dp[i][j] = min(Dp[i-1][j]), Dp[i][j-1]) + grid[i][j];

class Solution:
    """
    @param grid: a list of lists of integers
    @return: An integer, minimizes the sum of all numbers along its path
    """
    def minPathSum(self, grid):
        # write your code here
        row, col = len(grid), len(grid[0])
        dp = [[0]*col for i in range(row)]
         
        dp[0][0] = grid[0][0]
        for i in range(1, row):
            dp[i][0] = grid[i][0]+dp[i-1][0]
         
        for j in range(1, col):
            dp[0][j] = grid[0][j]+dp[0][j-1]
         
        for i in range(1, row):
            for j in range(1, col):
                dp[i][j] = min(dp[i-1][j], dp[i][j-1])+grid[i][j]
         
        return dp[row-1][col-1]

记得画图，二维矩阵。

dp的过程，初始化，状态转移方程：

空间优化：

滚动数组代码，java，考试不用这么肝，面试有明确思路即可：

public class Solution {
    /**
     * @param grid: a list of lists of integers.
     * @return: An integer, minimizes the sum of all numbers along its path
     */
    public int minPathSum(int[][] A) {
        if (A == null || A.length == 0 || A[0].length == 0) {
            return 0;
        }
         
        int m = A.length, n = A[0].length;
        int[][] f = new int[2][n];
        int i, j;
        int old, now = 0; // f[i] is stored in rolling array f[0]
        for (i = 0; i < m; ++i) {
            old = now;
            now = 1 - now; // 0 --> 1, 1 --> 0
             
            for (j = 0; j < n; ++j) {
                if (i == 0 && j == 0) {
                    f[now][j] = A[0][0];
                    continue;
                }
                 
                f[now][j] = Integer.MAX_VALUE;
                if (i > 0) {
                    f[now][j] = Math.min(f[now][j], f[old][j]);
                }
                 
                if (j > 0) {
                    f[now][j] = Math.min(f[now][j], f[now][j - 1]);
                }
                 
                f[now][j] += A[i][j];
            }
        }
         
        return f[now][n - 1];
    }
}

其实滚动数组的代码还是很简单，画一个图就知道了：

class Solution:
    """
    @param grid: a list of lists of integers
    @return: An integer, minimizes the sum of all numbers along its path
    """
    def minPathSum(self, grid):
        # write your code here
        m, n = len(grid), len(grid[0])
        dp = [0] * n
         
        dp[0] = grid[0][0]
        for j in range(1, n):
            dp[j] = dp[j-1] + grid[0][j]
         
        for i in range(1, m):
            dp[0] = dp[0] + grid[i][0]
            for j in range(1, n):
                dp[j] = min(dp[j-1], dp[j]) + grid[i][j]
         
        return dp[n-1]

436. 最大正方形

样例

样例 1:

输入:
[
  [1, 0, 1, 0, 0],
  [1, 0, 1, 1, 1],
  [1, 1, 1, 1, 1],
  [1, 0, 0, 1, 0]
]
输出: 4

样例 2:

输入: 
[
  [0, 0, 0],
  [1, 1, 1]
]
输出: 1

设定状态: dp[i][j] 表示以(i, j)为右下顶点的最大全1矩阵的边长.

状态转移方程:

if matrix[i][j] == 0
	dp[i][j] = 0
else                 // 此时为dp[i-1][j-1], dp[i-1][j], dp[i][j-1] 确定的区域的最大全1矩阵
	dp[i][j] = min{dp[i-1][j-1], dp[i-1][j], dp[i][j-1]} + 1	// 得到此方程需要一定推导, 纸笔画一下

边界: if i == 0 or j == 0: dp[i][j] = matrix[i][j]

答案: $max{dp[i][j]}^2$

class Solution:
    """
    @param grid: a matrix of 0 and 1
    @return: an integer
    """
    def maxSquare(self, grid):
        # write your code here
        row, col = len(grid), len(grid[0])
        dp = [[0]*col for i in range(row)]
         
        for i in range(0, row):
            dp[i][0] = grid[i][0]
         
        for j in range(0, col):
            dp[0][j] = grid[0][j]
         
        for i in range(1, row):
            for j in range(1, col):
                if grid[i][j]:
                    dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1])+1
                else:
                    dp[i][j] = 0
         
        max_edge = max(max(dp[i]) for i in range(row))
        return max_edge*max_edge

也可以利用滚动数组优化。

也不复杂！！！

class Solution:
    """
    @param matrix: a matrix of 0 and 1
    @return: an integer
    """
    def maxSquare(self, matrix):
        # write your code here
        m, n = len(matrix), len(matrix[0])
        dp = [[0] * n for i in range(2)]
         
        ans = 0
        for i in range(m):
            for j in range(n):
                if  i == 0 or j == 0:
                    dp[i&1][j] = matrix[i][j]
                else:
                    if matrix[i][j]:
                        dp[i&1][j] = min(dp[(i-1)&1][j-1], dp[i&1][j-1], \
                                     dp[(i-1)&1][j]) + 1
                    else:
                        dp[i&1][j] = 0
                 
                ans = max(dp[i&1][j]**2, ans)
                 
        return ans

补充下最大矩形，比最大正方形要复杂：

动态规划8最大矩形(maximal-rectangle)

1. 问题描述

??给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

??示例:
??输入:
??[
?? [“1”,“0”,“1”,“0”,“0”],
?? [“1”,“0”,“1”,“1”,“1”],
?? [“1”,“1”,“1”,“1”,“1”],
?? [“1”,“0”,“0”,“1”,“0”]
??]
??输出: 6

2. 解法

2.1 暴力法

2.2 动态规划1【容易理解掌握】

??我们定义一个dp数组，用于存储矩阵中以给定坐标为右下角的矩形的最大长度（每一行的更新可以视为row[i] = row[i - 1] + 1 if row[i] == ‘1’）。确定了每个点对应的最大长度，就可以在线性时间内计算出以该点为右下角的最大矩形。当我们遍历列时，可知从初始点到当前点矩形的最大高度，C++代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//解法2：动态规划1：时间复杂度O(N^2*M)[计算每个点的最大面积需O(N)，全部N*M个点]，空间复杂度O(NM)
int maximalRectangle(vector<vector<char>>& matrix) {
if (matrix.size() == 0) return 0;
int maxarea = 0;
vector<vector<int>> dp(matrix.size(), vector<int>(matrix[0].size(), 0));

for (int i = 0; i < matrix.size(); i++) {
for (int j = 0; j < matrix[0].size(); j++) {
if (matrix[i][j] == '1') {
//逐行更新该点对应的最大长度（横向）
dp[i][j] = j == 0 ? 1 : dp[i][j - 1] + 1;
int length = dp[i][j];
//自当前点竖直向上遍历得到不同的高度，在该高度下我们应该选这一列中较小的宽度
//毕竟短板才是能构成最大的。
for (int k = i; k >= 0; k--) {
length = min(length, dp[k][j]);
maxarea = max(maxarea, length * (i - k + 1));
}
}
}
}
return maxarea;
}

2.3 动态规划2【技巧性很强】

??考虑这样一个算法，对于每个点，我们先不断向上直到遇到零，然后向两边扩展，直到某列出现0。这种方式构建的矩形中必然存在最大矩形。
??我们通过定义三个数组height，left，right来记录每个点的高度，左边界和右边界，问题转化为如何更新每个数组。
??对于height数组，new_height[j]=old_height[j]+1 if row[j]==‘1’。
??对于left数组，new_left[j]=max(old_left[j],cur_left)，其中cur_left是遇到的最右边的0的序号加1，向左扩展矩形时不能超过改点，否则会遇到0。
??对于right数组，new_right[j]=min(old_right[j],cur_right)，cur_right表示我们遇到的最左边的0的序号。这里不减去1是因为这样就可以用height[j]*(right[j]-left[j])来计算矩形面积，也就是说矩形的底边由半开半闭区间[l,r)决定。为了记录正确的cur_right需要从右向左迭代，因此更新right时需要从右向左。C++代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//解法3：动态规划2：时间复杂度O(NM)[]，空间复杂度O(N)
int maximalRectangle(vector<vector<char>>& matrix) {
if (matrix.size() == 0) return 0;
int m = matrix.size();
int n = matrix[0].size();
//分别存储每一行上元素对应的最大矩形的高度以及左右区间
vector<int> left(n, 0);//最大的左边界为左端
vector<int> right(n, n);//最大的有边界为右端
vector<int> height(n, 0);

int maxarea = 0;
for (int i = 0; i < m; i++) {
int cur_left = 0, cur_right = n;
//更新高度,最后存储在height数组的就是每一列‘1’的个数
for (int j = 0; j < n; j++) {
if (matrix[i][j] == '1')
height[j]++;
else
height[j] = 0;
}
//更新左边界，
for (int j = 0; j < n; j++) {
if (matrix[i][j] == '1')
left[j] = max(left[j], cur_left);
else {
left[j] = 0;
cur_left = j + 1;
}
}
//更新右边界
for (int j = n - 1; j >= 0; j--) {
if (matrix[i][j] == '1')
right[j] = min(right[j], cur_right);
else
{
right[j] = n;
cur_right = j;
}
}
for (int j = 0; j < n; j++) {
maxarea = max(maxarea, (right[j] - left[j]) * height[j]);
}
}
return maxarea;
}

114. 不同的路径

样例

Example 1:

Input: n = 1, m = 3
Output: 1	
Explanation: Only one path to target position.

Example 2:

Input:  n = 3, m = 3
Output: 6	
Explanation:
	D : Down
	R : Right
	1) DDRR
	2) DRDR
	3) DRRD
	4) RRDD
	5) RDRD
	6) RDDR

解法1:
数学模型：在n-1 + m-1长度的序列中，有n-1个D，和m-1个组成。
其中D表示向下，R表示向右。
因此满足组合数：C(n+m-2, n-1), 从n+m-2个位置中选n-1个位置放D的方案数。

解法2:
可以用Dp过程来求解：
Dp[i][j] 表示走到(i,j)的路径数，
考虑最后一步是从上往下走，还是从左往右走。
Dp[i][j] = Dp[i-1][j] + Dp[i][j-1];

class Solution:
    # @return an integer
    """
    def c(self, m, n):
        mp = {}
        for i in range(m):
            for j in range(n):
                if(i == 0 or j == 0):
                    mp[(i, j)] = 1
                else:
                    mp[(i, j)] = mp[(i - 1, j)] + mp[(i, j - 1)]
        return mp[(m - 1, n - 1)]
 
    def uniquePaths(self, m, n):
        return self.c(m, n)
    """
     
    def uniquePaths(self, m, n):
        dp = [[0]*n for i in range(m)]
         
        for i in range(m):
            dp[i][0] = 1   
             
        for j in range(n):
            dp[0][j] = 1
                 
        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[m-1][n-1]

200. 最长回文子串

挑战

O(n²) 时间复杂度的算法是可以接受的，如果你能用 O(n) 的算法那自然更好。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        dp = [[False]*n for i in range(n)]
 
        ans = ""
        for i in range(n-1, -1, -1):
            for j in range(i, n):
                if j == i:
                    dp[i][j] = True
                elif j == i + 1:
                    dp[i][j] = s[i] == s[j]
                else:
                    if s[j] == s[i]:
                        dp[i][j] = dp[i+1][j-1] 
         
                if dp[i][j] and len(ans) < (j-i+1):
                    ans = s[i:j+1]
             
        return ans

我的最新解法：2个for递增！！！记住下面的写法，几个if逻辑非常清晰！！！

class Solution99:
    """
    @param s: input string
    @return: the longest palindromic substring
    """
    def longestPalindrome(self, s):        
        def calc_dp(s):     
            n = len(s)
            dp = [[False]*n for i in range(n)]
            for j in range(n):
                for i in range(0, j+1):
                    if i == j:
                        dp[i][j] = True
                    elif i == j - 1:
                        dp[i][j] = s[i] == s[j]
                    else:                        
                        if i < n - 1 and j > 0 and s[i] == s[j]:
                            dp[i][j] = dp[i+1][j-1]                                 
                    # print(i, j, dp[i][j])
            return dp
         
        n = len(s)
        dp = calc_dp(s)
        ans = ""
        for i in range(n):
            for j in range(i+1, n):
                if dp[i][j] and len(ans) < (j-i+1):
                    ans = s[i:j+1]        
        return ans
         
print(Solution99().longestPalindrome("abcdzdcab")) # 

我的老式解法，不建议再使用了，容易出错：

class Solution:
    """
    @param s: input string
    @return: the longest palindromic substring
    """
    def longestPalindrome(self, s):
        # write your code here
        start,end = 0,0
        n = len(s)
 
        def locatePalindrome(s, i, j):
            nonlocal start,end
            while i>=0 and j<n:
                if s[i] == s[j]:
                    if end-start < j-i+1:
                        start,end = i,j+1
                else:
                    break
                i -= 1
                j += 1
                 
        for i in range(n):
            # center i
            locatePalindrome(s, i, i)
            # center i,i+1
            locatePalindrome(s, i, i+1)
        return s[start:end]            
 
            

最常规的解法。

使用dp的：

我们首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…

注意为什么两个for一个递减一个递增？？？==》为了帮助理解，我来示意下：

举例说明：
 
字符串为：a b c d a X a d c 3 2 1
假设i，j位置如下：
 
<-----i
              j=i+1 ---->
a b c d a X a d c 3 2 1
 
为了知道d a X a d是不是回文？怎么办呢？
因为左右两边都是d，所以看a X a是不是回文对不对！！！那再往前追呢？
因为左右两边都是a，所以看X是不是回文。
 
而DP的本质就是用迭代的思路，上面反过来迭代就是DP了！！！
 
所以才得出来，i，j的方向是两边扩展！！！
 
因为一开始的时候，只知道单个字符是回文！如果是两个字符，则当两个字符相等的时候才是回文！
好了，上面2个是初始条件。
 
好了，开始迭代：
 
a b c d a X a d c 3 2 1
----------------------i在这里最后一个位置 ，j越界，dp[i][i] = True
 
a b c d a X a d c 3 2 1
--------------------i在这里，j在1的位置，dp[i][j] = False，因为2!=1
 
 
a b c d a X a d c 3 2 1
------------------i在这里，j在2的位置，dp[i][j] = False，因为3!=2
 
a b c d a X a d c 3 2 1
------------------i在这里，j在1的位置，dp[i][j] = False，因为3!=1

==>哈哈哈，意识到本质了，两个for递增也可行的了。

class Solution:
    """
    @param s: input string
    @return: the longest palindromic substring
    """
    def longestPalindrome(self, s):
        # write your code here
        # dp[i][j] = dp[i+1][j-1] + (s[i]==s[j])  if i<j         
        n = len(s)
        dp = [[False]*n for i in range(n)]
         
        ans = s[0]
        for i in range(n):
            dp[i][i] = True
            if i < n-1 and s[i] == s[i+1]:
                dp[i][i+1] = True
                 
        for i in range(n, -1, -1):
            for j in range(i+1, n):
                if i < n-1 and j > 0: 
                    if s[i] == s[j] and j != i+1:
                        dp[i][j] = dp[i+1][j-1]
         
        for i in range(n):
            for j in range(i+1, n):
                if dp[i][j] and len(ans) < (j-i+1):
                    ans = s[i:j+1]
        return ans
                                 

换一种两个for递增的写法：

398. 最长上升连续子序列 II

样例

样例 1:

输入: 
    [
      [1, 2, 3, 4, 5],
      [16,17,24,23,6],
      [15,18,25,22,7],
      [14,19,20,21,8],
      [13,12,11,10,9]
    ]
输出: 25
解释: 1 -> 2 -> 3 -> 4 -> 5 -> ... -> 25 (由外向内螺旋)

样例 2:

输入: 
    [
      [1, 2],
      [5, 3]
    ]
输出: 5
解释: 1 -> 2 -> 3 -> 5

动态规划, 设定状态 f[i][j] 表示矩阵中坐标 (i, j) 的点开始的最长上升子序列

状态转移方程:

int dx[4] = {0, 1, -1, 0};
int dy[4] = {1, 0, 0, -1};

f[i][j] = max{ f[i + dx[k]][j + dy[k]] + 1 }

k = 0, 1, 2, 3, matrix[i + dx[k]][j + dy[k]] > matrix[i][j]

这道题目可以向四个方向走, 所以推荐使用记忆化搜索(递归)的写法. 本质上就是dfs+cache！！！

public class Solution {
    /**
     * @param matrix: A 2D-array of integers
     * @return: an integer
     */
 
    int[][] dp;
    int n, m;
 
    public int longestContinuousIncreasingSubsequence2(int[][] A) {
        if (A.length == 0) {
            return 0;
        }
 
        n = A.length;
        m = A[0].length;
        int ans = 0;
        dp = new int[n][m]; // dp[i][j] means the longest continuous increasing path from (i,j)
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                dp[i][j] = -1; // dp[i][j] has not been calculated yet
            }
        }
 
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                search(i, j, A);
                ans = Math.max(ans, dp[i][j]);
            }
        }
 
        return ans;
    }
 
    int[] dx = { 1, -1, 0, 0 };
    int[] dy = { 0, 0, 1, -1 };
 
    void search(int x, int y, int[][] A) {
        if (dp[x][y] != -1) { // if dp[i][j] has been calculated, return directly
            return;
        }
 
        int nx, ny;
        dp[x][y] = 1;
        for (int i = 0; i < 4; ++i) {
            nx = x + dx[i];
            ny = y + dy[i];
            if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
                if (A[nx][ny] > A[x][y]) {
                    search(nx, ny, A); // dp[nx][ny] must be calcuted
                    dp[x][y] = Math.max(dp[x][y], dp[nx][ny] + 1);
                }
            }
        }
    }
}

什么时候用记忆化搜索? 1. 状态转移特别麻烦，不是顺序性

2. 初始化状态不是很容易找到

记忆化搜索的缺陷

耗费更多空间，无法使用滚动数组优化递归深度可能会很深

博弈类动态规划 Game DP

见：https://www.cnblogs.com/bonelee/p/17076086.html

区间类DP

特点:
1. 求一段区间的解max/min/count 2. 转移方程通过区间更新
3. 大区间的值依赖于小区间

168. 吹气球

https://leetcode.cn/problems/burst-balloons/

样例

样例 1:

输入：[4, 1, 5, 10]
输出：270
解释：
nums = [4, 1, 5, 10] 吹爆 1, 得分 4 * 1 * 5 = 20
nums = [4, 5, 10]   吹爆 5, 得分 4 * 5 * 10 = 200 
nums = [4, 10]   吹爆 4, 得分 1 * 4 * 10 = 40
nums = [10]   吹爆 10, 得分 1 * 10 * 1 = 10
总得分 20 + 200 + 40 + 10 = 270

样例 2:

输入：[3,1,5]
输出：35
解释：
nums = [3, 1, 5] 吹爆 1, 得分 3 * 1 * 5 = 15
nums = [3, 5] 吹爆 3, 得分 1 * 3 * 5 = 15
nums = [5] 吹爆 5, 得分 1 * 5 * 1 = 5
总得分 15 + 15 + 5  = 35

class Solution:
    def maxCoins(self, nums: List[int]) -> int:
        n = len(nums)
        rec = [[0] * (n + 2) for _ in range(n + 2)]
        val = [1] + nums + [1]
 
        for i in range(n - 1, -1, -1):
            for j in range(i + 2, n + 2):
                for k in range(i + 1, j):
                    total = val[i] * val[k] * val[j]
                    total += rec[i][k] + rec[k][j]
                    rec[i][j] = max(rec[i][j], total)
         
        return rec[0][n + 1]

注意n是递减的，因为dp[i][j] = dp[i][k] + dp[k][j] k比i大，所以i如果递增就取不到后面dp[k][j]的值！

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

396. 硬币排成线 III

样例

样例 1:

输入: [3, 2, 2]
输出: true
解释: 第一个玩家在刚开始的时候拿走 3, 然后两个人分别拿到一枚 2.

样例 2:

输入: [1, 20, 4]
输出: false
解释: 无论第一个玩家在第一轮拿走 1 还是 4, 第二个玩家都可以拿到 20.

挑战

在 n 是偶数时做到O(1) 空间, O(n) 时间

区间动态规划问题, 具体定义状态的方式有很多种, 但是大同小异, 时空复杂度都相似. 这里只介绍 version 1 的具体实现.

设定 dp[i][j] 表示当前剩余硬币的区间为 [i, j] 时, 此时该拿硬币的人能获取的最大值.

注意, dp[i][j] 并没有包含角色信息, dp[0][values.length - 1] 表示的是先手的人能获得的最大值, 而 dp[1][values.length -1] 表示的则是后手的人能获得的最大值. 需要这样做是因为: 两个人都会采用最优策略.

当前的人的决策就是拿左边还是拿右边, 而下一个人仍然会最优决策, 所以应该是最小值中取最大值:

dp[i][j] = max(	                                     // 取max表示当前的人选用最优策略		
    min(dp[i + 2][j], dp[i + 1][j - 1]) + values[i], // 取min表示下一个人选用最优策略
    min(dp[i][j - 2], dp[i + 1][j - 1]) + values[j]
)

几个边界:

i > j : dp[i][j] = 0
i == j : dp[i][j] = values[i]
i + 1 == j : dp[i][j] = max(values[i], values[j])

class Solution:
    # @param values: a list of integers
    # @return: a boolean which equals to True if the first player will win
    def firstWillWin(self, values):
        if not values:
            return False
             
        n = len(values)
        dp = [[0] * n for _  in range(n)]
        sum = [[0] * n for _  in range(n)]
         
        for i in range(n):
            dp[i][i] = values[i]
            sum[i][i] = values[i]
         
        for i in range(n - 2, -1, -1):  # n-2 => 0
            for j in range(i + 1, n):  # i+1 => n-1
                sum[i][j] = sum[i + 1][j] + values[i]
                dp[i][j] = sum[i][j] - min(dp[i + 1][j], dp[i][j - 1])
                 
        return dp[0][n - 1] > sum[0][n - 1] - dp[0][n - 1]

区间类的动态规划还是挺难的！！！看情况掌握吧。

双序列动态规划

77. 最长公共子序列

class Solution:
    """
    @param A: A string
    @param B: A string
    @return: The length of longest common subsequence of A and B
    """
    def longestCommonSubsequence(self, A, B):
        # write your code here
        if not A or not B:
            return 0
             
        m, n = len(A), len(B)
        dp = [[0]*n for i in range(m)]
         
        for i in range(0, m):
            if A[i] == B[0]:
                dp[i][0] = 1
         
        for j in range(0, n):
            if A[0] == B[j]:
                dp[0][j] = 1
         
        for i in range(1, m):
            for j in range(1, n):
                if A[i] == B[j]:
                    dp[i][j] = max(dp[i-1][j-1]+1, dp[i][j-1], dp[i-1][j])
                else:
                    dp[i][j] = max(dp[i][j-1], dp[i-1][j])
         
        return dp[m-1][n-1]
        

记得画个二维的图！！！

Dp[i][j] 表示A序列前i个数，与B的前j个数的LCS长度。
对A的每个位置i，枚举B的每个位置j。

更精简的代码：

class Solution:
    """
    @param A, B: Two strings.
    @return: The length of longest common subsequence of A and B.
    """
    def longestCommonSubsequence(self, A, B):
        n, m = len(A), len(B)
        f = [[0] * (n + 1) for i in range(m + 1)]
        for i in range(n):
            for j in range(m):
                f[i + 1][j + 1] = max(f[i][j + 1], f[i + 1][j])
                if A[i] == B[j]:
                    f[i + 1][j + 1] = f[i][j] + 1
        return f[n][m]

备注：也可以使用滚动数组进行优化！！！

119. 编辑距离

样例

样例 1:

输入: 
"horse"
"ros"
输出: 3
解释: 
horse -> rorse (替换 'h' 为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')

样例 2:

输入: 
"intention"
"execution"
输出: 5
解释: 
intention -> inention (删除 't')
inention -> enention (替换 'i' 为 'e')
enention -> exention (替换 'n' 为 'x')
exention -> exection (替换 'n' 为 'c')
exection -> execution (插入 'u')

class Solution:
    """
    @param A: A string
    @param B: A string
    @return: The minimum number of steps.
    """
    def minDistance(self, A, B):
        # write your code here
        m, n = len(A), len(B)
        dp = [[0]*(n+1) for i in range(m+1)]
         
        for i in range(m+1):
            dp[i][0] = i
             
        for j in range(n+1):
            dp[0][j] = j
         
        for i in range(1, m+1):
            for j in range(1, n+1):
                if A[i-1] == B[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j-1], dp[i][j-1], dp[i-1][j])+1
         
        return dp[m][n]

dp[i][j] 代表第一个字符串以i结尾匹配上（编辑成）第二个字符串以j结尾的字符串，最少需要多少次编辑。
通过去判断i与j的匹配关系来变为更小的状态。

字符串相似性！！！

10. 正则表达式匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素

所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。

示例 1：

输入：s = "aa", p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。

示例 2:

输入：s = "aa", p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。

示例 3：

输入：s = "ab", p = ".*"
输出：true
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。


核心是对于.*场景 匹配2个以上的状态转移推导!如下：
摘录自：https://leetcode.cn/problems/regular-expression-matching/solution/by-flix-musv/

代码如下：

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        m, n = len(s), len(p)
        dp = [[False]*(n+1) for _ in range(m+1)]
        dp[0][0] = True
 
        for j in range(2, n+1): # 这里容易踩坑，不要漏掉了
            if p[j-1] == '*':
                dp[0][j] = dp[0][j-2]
 
        # 下面就是公式转换了
        for i in range(1, m+1):
            for j in range(1, n+1):
                if p[j-1] == '*':
                    if p[j-2] != '.':
                        if p[j-2] != s[i-1]:
                            dp[i][j] = dp[i][j-2]
                        else:
                            dp[i][j] = dp[i][j-2] or dp[i-1][j]
                    else:
                        dp[i][j] = dp[i][j-2] or dp[i-1][j]
                elif p[j-1] == '.':
                    dp[i][j] = dp[i-1][j-1]
                else:
                    if p[j-1] == s[i-1]:
                        dp[i][j] = dp[i-1][j-1]
 
        return dp[m][n]

精简点可以：

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        m, n = len(s), len(p)
        dp = [[False] * (n+1) for _ in range(m+1)]
         
        # 初始化
        dp[0][0] = True
        for j in range(1, n+1):
            if p[j-1] == '*':
                dp[0][j] = dp[0][j-2]
 
        # 状态更新
        for i in range(1, m+1):
            for j in range(1, n+1):
                if s[i-1] == p[j-1] or p[j-1] == '.':
                    dp[i][j] = dp[i-1][j-1]
                elif p[j-1] == '*':     # 【题目保证'*'号不会是第一个字符，所以此处有j>=2】
                    if s[i-1] != p[j-2] and p[j-2] != '.':
                        dp[i][j] = dp[i][j-2]
                    else:
                        dp[i][j] = dp[i][j-2] | dp[i-1][j]
         
        return dp[m][n]

总之，这个题目还是有难度的，公式推导也有难度，尤其是匹配2个以上的情形。

29. 交叉字符串

挑战

要求时间复杂度为O(n²)或者更好

class Solution:
    """
    @param A: A string
    @param B: A string
    @param C: A string
    @return: Determine whether s3 is formed by interleaving of s1 and s2
    """
    def isInterleave(self, A, B, C):
        # write your code here
        m, n = len(A), len(B)
         
        if m + n != len(C):
            return False
             
        dp = [[False]*(n+1) for i in range(m+1)]
         
        dp[0][0] = True
         
        for i in range(1, m+1):
            if A[i-1] == C[i-1]:
                dp[i][0] = dp[i-1][0]
             
        for j in range(1, n+1):
            if B[j-1] == C[j-1]:
                dp[0][j] = dp[0][j-1]
         
        for i in range(1, m+1):
            for j in range(1, n+1):
                if A[i-1] == C[i+j-1]:
                    dp[i][j] = dp[i-1][j]
                if B[j-1] == C[i+j-1]:
                    dp[i][j] |= dp[i][j-1]
                 
        return dp[m][n]
         
        

dp[i][j]代表由s1的前i个字母和s2的前j个字母是否能构成当前i+j个字母。
然后状态转移即可。（看第i+j+1个是否能被s1的第i+1个构成或被s2的第j+1个构成）

623. K步编辑

样例

样例 1:

给出字符串 `["abc","abd","abcd","adc"]`，目标字符串为 `"ac"` ，k = `1`
返回 `["abc","adc"]`
输入:
["abc", "abd", "abcd", "adc"]
"ac"
1
输出:
["abc","adc"]

解释:
"abc" 去掉 "b"
"adc" 去掉 "d"

样例 2:

输入:
["acc","abcd","ade","abbcd"]
"abc"
2
输出:
["acc","abcd","ade","abbcd"]

解释:
"acc" 把 "c" 变成 "b"
"abcd" 去掉 "d"
"ade" 把 "d" 变成 "b"把 "e" 变成 "c"
"abbcd" 去掉 "b" 和 "d"

class TrieNode:
    def __init__(self):
        # Initialize your data structure here.
        self.children = [None for i in range(26)]
        self.hasWord = False
        self.str = None
     
    @classmethod
    def addWord(cls, root, word):
        node = root
        for letter in word:
            child = node.children[ord(letter) - ord('a')]
            if child is None:
                child = TrieNode()
                node.children[ord(letter) - ord('a')] = child
            node = child
     
        node.hasWord = True
        node.str = word
 
class Solution:
    # @param {string[]} words a set of strings
    # @param {string} target a target string
    # @param {int} k an integer
    # @return {string[]} output all the stirngs that meet the requirements 
    def kDistance(self, words, target, k):
        # Write your code here
        root = TrieNode()
        for word in words:
            TrieNode.addWord(root, word)
 
        result = []
        n = len(target)
        dp = [i for i in range(n + 1)]
 
        self.find(root, result, k, target, dp)
        return result
 
    def find(self, node, result, k, target, dp):
        n = len(target)
 
        if node.hasWord and dp[n] <= k:
            result.append(node.str)
 
        next = [0 for i in range(n + 1)]
 
        for i in range(26):
            if node.children[i] is not None:
                next[0] = dp[0] + 1
                for j in range(1, n + 1):
                    if ord(target[j - 1]) - ord('a') == i:
                        next[j] = min(dp[j - 1], min(next[j - 1] + 1, dp[j] + 1))
                    else:
                        next[j] = min(dp[j - 1] + 1, min(next[j - 1] + 1, dp[j] + 1))
 
                self.find(node.children[i], result, k, target, next)

挺难的题目，使用了Trie，结合DP。

背包类DP

92. 背包问题

class Solution:
    """
    @param m: An integer m denotes the size of a backpack
    @param A: Given n items with size A[i]
    @return: The maximum size
    """
    def backPack(self, m, A):
        # write your code here
        # f[i][j]表示前i个物品选一些物品放入容量为j的背包中能否放满。
        n = len(A)
        f = [[False] * (m + 1) for _ in range(n + 1)]
         
        f[0][0] = True
        for i in range(1, n + 1):
            f[i][0] = True
            for j in range(1, m + 1):
                if j >= A[i - 1]:
                    f[i][j] = f[i - 1][j] or f[i - 1][j - A[i - 1]]
                else:
                    f[i][j] = f[i - 1][j]
                     
        for i in range(m, -1, -1):
            if f[n][i]:
                return i
        return 0
             
         
        

自己画一个二维的矩阵图，推演下。

125. 背包问题 II

样例

样例 1:

输入: m = 10, A = [2, 3, 5, 7], V = [1, 5, 2, 4]
输出: 9
解释: 装入 A[1] 和 A[3] 可以得到最大价值, V[1] + V[3] = 9

样例 2:

输入: m = 10, A = [2, 3, 8], V = [2, 5, 8]
输出: 10
解释: 装入 A[0] 和 A[2] 可以得到最大价值, V[0] + V[2] = 10

设定 f[i][j] 表示前 i 个物品装入大小为 j 的背包里, 可以获取的最大价值总和. 决策就是第i个物品装不装入背包, 所以状态转移方程就是 f[i][j] = max(f[i - 1][j], f[i - 1][j - A[i]] + V[i])

class Solution:
    # @param m: An integer m denotes the size of a backpack
    # @param A & V: Given n items with size A[i] and value V[i]
    def backPackII(self, m, A, V):
        # write your code here
        f = [0 for i in range(m+1)]
        n = len(A)
        for i in range(n):
            for j in range(m, A[i]-1, -1):
                f[j] = max(f[j] , f[j-A[i]] + V[i])
        return f[m]

440. 背包问题 III

样例

样例 1:

输入: A = [2, 3, 5, 7], V = [1, 5, 2, 4], m = 10
输出: 15
解释: 装入三个物品 1 (A[1] = 3, V[1] = 5), 总价值 15.

样例 2:

输入: A = [1, 2, 3], V = [1, 2, 3], m = 5
输出: 5
解释: 策略不唯一. 比如, 装入五个物品 0 (A[0] = 1, V[0] = 1).

posted @ 2019-12-01 21:06 bonelee 阅读(790) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· DeepSeek 开源周回顾「GitHub 热点速览」

历史上的今天：
2017-12-01 dns tunnel C&C
2016-12-01 linux tcpdump 抓包
2016-12-01 Asterisk——part 1
2016-12-01 spark出现task不能序列化错误的解决方法 org.apache.spark.SparkException: Task not serializable

公告

昵称： bonelee
园龄： 8年6个月
粉丝： 892
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

将者，智、信、仁、勇、严也。

Hi，我是李智华，华为-安全AI算法专家，欢迎来到安全攻防对抗的有趣世界。

动态规划算法模板和demo

366. 斐波纳契数列

110. 最小路径和

注意事项

436. 最大正方形

动态规划8最大矩形(maximal-rectangle)

1. 问题描述

2. 解法

2.1 暴力法

2.2 动态规划1【容易理解掌握】

2.3 动态规划2【技巧性很强】

114. 不同的路径

200. 最长回文子串

168. 吹气球

396. 硬币排成线 III

公告

搜索

常用链接

我的标签

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

Hi，我是李智华，华为-安全AI算法专家，欢迎来到安全攻防对抗的有趣世界。

366. 斐波纳契数列

样例

110. 最小路径和

样例

注意事项

436. 最大正方形

样例

动态规划8最大矩形(maximal-rectangle)

1. 问题描述

2. 解法

2.1 暴力法

2.2 动态规划1【容易理解 掌握】

2.3 动态规划2【技巧性很强】

114. 不同的路径

样例

注意事项

200. 最长回文子串

样例

挑战

注意为什么两个for一个递减一个递增？？？==》为了帮助理解，我来示意下：

398. 最长上升连续子序列 II

样例

挑战

168. 吹气球

样例

注意事项

396. 硬币排成线 III

样例

挑战

双序列动态规划

77. 最长公共子序列

样例

说明

119. 编辑距离

样例

29. 交叉字符串

样例

挑战

623. K步编辑

样例

背包类DP

92. 背包问题

样例

挑战

注意事项

125. 背包问题 II

样例

挑战

注意事项

440. 背包问题 III

样例

注意事项

公告

搜索

常用链接

随笔档案

2.2 动态规划1【容易理解掌握】