[力扣] 动态规划（DP）问题分类汇总

动态规划是算法面试的一个重点，在力扣上有很多这类题目，题目是刷不完的，将动态规划的全部类型题目刷一遍可以达到事半功倍的效果。

1.线性动态规划

1.1 子序列系列：

题目一：最长上升子序列（300. 最长上升子序列）

题解：注意这里要求的子序列不是连续的，使用动态规划，dp[i]表示的是以下标i的数字作为结尾不连续最长上升子序列的长度，动态转移方程：dp[i] = max{dp[j] + 1, (0 <= j < i,a[j] < a[i]},dp表的初始状态为1，最后统计表中的最大值即为该序列的最长上升子序列。
代码如下：

class Solution {
   
    public int lengthOfLIS(int[] nums) {
   
        // 参数判断
        if (null == nums || 0 == nums.length) {
   
            return 0;
        }
        int[] dp = new int[nums.length];
        int res = 0;
        for (int i = 0; i < nums.length; i ++) {
   
            // 初始值
            dp[i] = 1;
            for (int j = 0; j < i; j ++) {
   
                if (nums[j] < nums[i]) {
   
                    // 在以nums[i]结尾的所有子序列中筛选出最大值
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            // dp表中筛选出最大值即是答案
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

题目二：最长连续上升子序列（674. 最长连续递增序列）

题解：注意这里求的是连续子序列，使用动态规划，dp[i]表示的是以下标i的数字作为结尾最长连续子序列的长度，动态转移方程：(dp[i] = dp[i - 1] + 1,a[i-1] < a[i];dp[i] = 1,a[i - 1] > a[i]),最后统计表中的最大值即为该序列的最长连续上升子序列。
代码如下：

class Solution {
   
    public int findLengthOfLCIS(int[] nums) {
   
        // 参数判断
        if (null == nums || 0 == nums.length) {
   
            return 0;
        }
        int[] dp = new int[nums.length];
        dp[0] = 1;
        int res = dp[0];
        for (int i = 1; i < nums.length; i ++) {
   
            // nums[i] 大于前面一个nums[i - 1]
            if (nums[i] > nums[i - 1]) {
   
                dp[i] = dp[i - 1] + 1;
            // nums[i] 小于前面一个nums[i - 1]，最长连续上升子序列即为他自己    
            } else {
   
                dp[i] = 1;
            }
            // 筛选出最大值即是答案
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

题目三：最长公共子序列（1143. 最长公共子序列）

题解：状态转移方程：

代码如下：

class Solution {
   
    public int longestCommonSubsequence(String text1, String text2) {
   
        if (null == text1 || 0 == text1.length() || null == text2 || 0 == text2.length()) {
   
            return 0;
        }    
        int[][] dp = new int[text1.length()][text2.length()];
        char[] t1 = text1.toCharArray();
        char[] t2 = text2.toCharArray();
        dp[0][0] = t1[0] == t2[0] ? 1 : 0;
        for (int i = 1; i < text1.length(); i ++) {
   
            dp[i][0] = Math.max(dp[i - 1][0], t1[i] == t2[0] ? 1 : 0);
        }
        for (int j = 1; j < text2.length(); j ++) {
   
            dp[0][j] = Math.max(dp[0][j - 1], t2[j] == t1[0] ? 1 : 0);
        }
        for (int i = 1; i < text1.length(); i ++) {
   
            for (int j = 1; j < text2.length(); j ++) {
   
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                if (t1[i] == t2[j]) {
   
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + 1);
                }
            }
        }
        return dp[text1.length() - 1][text2.length() - 1];
    }
}

题目四：最长公共连续子序列

题解：定义状态：dp[i][j]以i为下标a[i],b[j]字符结尾的公共连续子序列。

代码如下：

public static int lcs(String str1, String str2) {
   
	int len1 = str1.length();
	int len2 = str2.length();
	int result = 0;     //记录最长公共子串长度
	int c[][] = new int[len1+1][len2+1];
	for (int i = 0; i <= len1; i++) {
   
		for( int j = 0; j <= len2; j++) {
   
			if(i == 0 || j == 0) {
   
				c[i][j] = 0;
			} else if (str1.charAt(i-1) == str2.charAt(j-1)) {
   
				c[i][j] = c[i-1][j-1] + 1;
				result = max(c[i][j], result);
			} else {
   
				c[i][j] = 0;
			}
		}
	}
	return result;
}

1.2 股票系列：推荐资料

股票类题解：dp模板，股票类型的题目都是基于这个模板，根据具体的题目来修改调整相应的参数。结果是取没有持有状态下最后一天的dp。因为 [1] 代表手上还持有股票，[0] 表示手上的股票已经卖出去了，很显然后者得到的利润一定大于前者。

题目一：121. 买卖股票的最佳时机

题解：题目要求最多只进行1次交易，即k = 1，所以

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])
base case
dp[0][k][0] = 0
dp[0][k][1] = -prices[0]

化简为：

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], - prices[i])
base case
dp[0][0] = 0
dp[0][1] = -prices[0]

代码如下：

class Solution {
   
    public int maxProfit(int[] prices) {
   
        if (null == prices ||