动态规划总结笔记

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/target-sum
侵权请联系。

1 LeetCode 516 最长回文子序列

测试用例
输入：s = “bbbab”
输出：4
解释：一个可能的最长回文子序列为 “bbbb”

最核心代码

class Solution {
   
public:
    int longestPalindromeSubseq(string s) {
   
        int n = s.size();
        vector<vector<int>> dp(n,vector<int>(n,0));
        // 输出 测试结果，可能导致超时
        for(int i=n-1;i>=0;--i){
   
            for(int j=i;j<n;j++){
   
                if(s[i] == s[j]){
   
                    if(i==j || j == i+1)
                        dp[i][j] = j-i+1;
                    else{
   
                        dp[i][j] = dp[i+1][j-1]+2;
                    }
                }else{
   
                    dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
                }
            }
        }
        return dp[0][n-1];
    }
};

2. leetcode 115 不同子序列

测试用例
输入：s = “rabbbit”, t = “rabbit”
输出：3
输入：s = “babgbag”, t = “bag”
输出：5

最核心代码

class Solution {
   
public:
    int numDistinct(string s, string t) {
   
        int n = s.size(),m = t.size();
        vector<vector<int>> dp(n+1, vector<int>(m+1,0));
        for(int i=0;i<=n;i++){
   
            dp[i][0] = 1;
        }
        for(int i=1;i<=n;i++){
   
            for(int j=1;j<=m;j++){
   
                if(s[i-1] != t[j-1]){
   
                    dp[i][j] = dp[i-1][j];
                }else{
   
                    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                }
            }
        }
        return dp[n][m];
    }
};

3. 经典 0-1背包

结论：true、false类的 01背包，递归基 dp[0] = 1。

but, 普通的0-1背包，递归基为 dp[0] = 0

核心代码

true、false类的 01背包，递归基 dp[0] = 1。

4 leetcode 416 分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等

        dp[0] = 1;
        for(int i=0;i<n;i++){
   
            for(int j=sum;j>=nums[i];--j){
   
                dp[j] = dp[j] || (dp[j-nums[i]]);
            }
        }

5. 1049 最后一块石头的重量II

普通的0-1背包，递归基为 dp[0] = 0

dp[0] = 0;
        for(int i=0;i<n;i++){
   
            for(int j=m;j>=stones[i];--j){
   
                dp[j] = max(dp[j], dp[j-stones[i]] + stones[i])