代码随想录算法营||动态规划

m0_50719851

已于 2024-09-01 11:04:20 修改

阅读量791

点赞数 27

文章标签：动态规划算法

于 2024-08-28 15:32:23 首次发布

本文链接：https://blog.csdn.net/m0_50719851/article/details/141300491

版权

动规基础

1. 常见问题

背包问题
打家劫舍
股票问题
子序列问题

2. 搞清楚：

dp数组的下标及含义dp[i][j]和dp[i]
递推公式：
dp数组如何初始化
遍历顺序
打印数组

题目一：斐波那契数列

1. 题目：509. 斐波那契数 - 力扣（LeetCode）

2. 思路

dp数组的下标及含义：dp[i]第i个斐波那契的数值
递推公式：dp[i] = dp[i-1] + dp[i-2]
dp数组如何初始化: dp[0]=1 dp[1]=1
遍历顺序：从前向后
打印数组

    public static int fib(int n) {
        if (n <= 1) return n; 
        int[] dp = new int[n + 1];
        dp[0] = 0;//初始化增加0
        dp[1] = 1;
        for (int i = 2; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }

题目二：爬楼梯

1. 题目：70. 爬楼梯 - 力扣（LeetCode）

 public static int climbstair(int n){
        int[] dp=new int[n+1];//长度是n+1
        //1. dp[i]的含义到第i台阶的方法
        dp[1]=1;//3.初始化
        dp[2]=2;
        for (int i=3;i<=n;i++){//4.遍历顺序：从前往后
            dp[i]=dp[i-1]+dp[i-2];//2. 递推公式
        }
        return dp[n];
    }

题目三：使用最小花费爬楼梯

1. 题目：746. 使用最小花费爬楼梯 - 力扣（LeetCode）

2. 思路：站在第0个或者第一个台阶上是不花费体力的，爬到楼顶是cost.length+1的位置

dp数组的下标及含义：dp[i]表示到达i的最小花费（主要是求到最后一个台阶的最小花费）
递推公式：dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])
dp数组如何初始化: dp[0]=0 dp[1]=0
遍历顺序：从前向后
打印数组

  public int minCostClimbingStairs(int[] cost) {
         //1.dp[i]表示到达i的最小花费
        //2.dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])
        int[] dp=new int[cost.length+1];//长度多了一个
        dp[0]=0;//3.初始化都为0
        dp[1]=0;
        for (int i=2;i<=cost.length;i++){//cost是到cost[cost.length-1]
            dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[cost.length];
    }

题目四：不同路径

1. 题目：62. 不同路径 - 力扣（LeetCode）从(0,0)到(m.n)有多少种路径

 public int uniquePaths(int m, int n) {//62.不同路径
        //从(0,0)到(m.n)有多少种路径
        //1.dp[i][j]是从(0,0)到(i,j)的方法
        //2.初始化dp[i][0]和dp[0][i]都是1
        //3.递归方向是从左到右一层一层
        //4.递归公式：dp[i][j]=dp[i-1][j]+dp[i][j-1]
        int[][] dp=new int[m][n];//m行n列，都是从0开始到m-1和n-1
        for(int i=0;i<m;i++)dp[i][0]=1;
        for(int j=0;j<n;j++)dp[0][j]=1;
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];//右下角
    }

题目五：不同路径（有障碍物）

1. 题目：63. 不同路径 II - 力扣（LeetCode）

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //1.dp[i][j]表示到达[i][j]总共有几种方法
        //3.初始化:当没遇到障碍物的时候设为1
        //4.遍历顺序：从前往后
        int m=obstacleGrid.length;
        int n=obstacleGrid[0].length;
        int[][] dp=new int[m][n];
        if (obstacleGrid[0][0]==1 || obstacleGrid[m-1][n-1]==1)return 0;
        for (int i=0;i<m && obstacleGrid[i][0]==0;i++){
            dp[i][0]=1;
        }
        for (int j=0;j<n && obstacleGrid[0][j]==0;j++){
            dp[0][j]=1;
        }
        for (int i=1;i<m;i++){
            for (int j=1;j<n;j++){
                if (obstacleGrid[i][j]==1)dp[i][j]=0;//2.递归公式
                else dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }

题目六：整数拆分

1. 题目：343. 整数拆分 - 力扣（LeetCode）

2.思路：

dp数组的下标及含义：dp[i]表示对i进行拆分，得到的最大乘积
递推公式：dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])
dp数组如何初始化: dp[0]=0 dp[1]=0
遍历顺序：从前向后

 public int integerBreak(int n) {
        //dp[i] 为正整数 i 拆分后的结果的最大乘积
        int[] dp = new int[n+1];
        dp[2] = 1;
        for(int i = 3; i <= n; i++) {
            for(int j = 1; j <= i-j; j++) {
                // 这里的 j 其实最大值为 i-j,再大只不过是重复而已，
                //并且，在本题中，我们分析 dp[0], dp[1]都是无意义的，
                //j 最大到 i-j,就不会用到 dp[0]与dp[1]
                dp[i] = Math.max(dp[i], Math.max(j*(i-j), j*dp[i-j]));
                // j * (i - j) 是单纯的把整数 i 拆分为两个数 也就是 i,i-j ，再相乘
                //而j * dp[i - j]是将 i 拆分成两个以及两个以上的个数,再相乘。
            }
        }
        return dp[n];
    }

题目七：不同的二叉搜索树

1. 题目：. - 力扣（LeetCode）

public int numTrees(int n) {
        //初始化 dp 数组
        int[] dp = new int[n + 1];
        //初始化0个节点和1个节点的情况
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                //对于第i个节点，需要考虑1作为根节点直到i作为根节点的情况，所以需要累加
                //一共i个节点，对于根节点j时,左子树的节点个数为j-1，右子树的节点个数为i-j
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }

0-1背包

题目八：0-1背包问题（装满背包价值是多少）

基础知识

1.背包种类

0-1背包：有n种物品，每种物品只有1个，有自己的重量和价值，一个最多只能放重量为m的背包，问最多能装价值为多少的物品
完全背包：有n种物品，每种物品有无限个
多重背包：有n种物品，每种物品个数各不相同

2. 二维dp[i][j]数组的含义: [0,i]之间的物品任取然后放进容量为j的背包中

(1) 不放物品i的最大价值: d p[i-1][j]；放物品i的最大价值：dp[i-1][j-weight[i]]+value[i]

(2) dp[i][j]=不放物品i和放物品i两个取最大价值

(3) 初始化：j的背包容量为0，i放第一个物品时

(4) 遍历顺序：先背包先物品都可以，因为左上方和上面都有值

3. 一维dp[j]数组:容量为j的背包所能装的最大价值为dp[j]

(1) 递推公式：dp[j]=max(dp[j]，dp[j-weight[i]]+value[i])

(2) 初始化：dp数组全都初始化为0

(3) 遍历顺序：先遍历物品、再倒叙遍历背包（保证每一个物品只被添加一次）因为如果从前往后就会有物品放重复的问题

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

题目九：分割等和子集（能不能装满背包）

1. 题目：https://leetcode.cn/problems/partition-equal-subset-sum/

2. 思路：可以看成背包是否能被物品填满，只能使用一次

dp[j]：容量为j的背包所背的所背的最大价值，对应到本题价值和重量一样
递推公式：dp[j] = Math.max(dp[j] , dp[j-nums[i]]+nums[i])
初始化：dp[0]=0
遍历顺序：先物品后背包，背包倒序遍历因为只能放一次

 public boolean canPartition(int[] nums) {
        if (nums.length==0||nums.length==1)return false;
        int sum=0;//1.求总和
        for(int i:nums){
            sum+=i;
        }
        if (sum%2!=0)return false;//2.如果是奇数则false
        int target=sum/2;
        int[] dp=new int[target+1];//因为dp[0]
        for (int i=0;i<nums.length;i++){//先物品
            for (int j=target;j>=nums[i];j--){//后背包
                dp[j]=Math.max(dp[j],dp[j-nums[i]]+nums[i]);
            }
        }
        if (dp[target]==target)return true;
        else return false;
    }

题目十：最后一块石头的重量（尽量装背包）

1. 题目：1049. 最后一块石头的重量 II - 力扣（LeetCode）

2. 思路：和上一题思路一样，看背包容量是总石头的一半是能装多少重量。在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。

    public int lastStoneWeightII(int[] stones) {
         int sum=0;
        for(int i:stones){
            sum+=i;
        }
        int target=sum/2;
        int[] dp=new int[target+1];//因为dp[0]
        for (int i=0;i<stones.length;i++){
            for (int j=target;j>=stones[i];j--){
                dp[j]=Math.max(dp[j],dp[j-stones[i]]+stones[i]);
            }
        }
       return sum-dp[target]-dp[target];  
    }

题目十一：目标和（装满有多少种方法）

1. 题目：494. 目标和 - 力扣（LeetCode）

2. 思路：分出加法一个集合和减法一个集合

left + right=sum；left - right=target所以求出left=(target + sum)/2
dp[j]数组含义：装满容量为j的背包有dp[j]种方法
递推公式：dp[j] +=dp[ j-nums[i] ]
dp数组初始化：dp[0]=1，带入数组里只有0、target是0、dp[0]=1
遍历顺序：先遍历物品、再倒叙遍历背包因为每个物品只能用一次

public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
        //如果target的绝对值大于sum，那么是没有方案的
        if (Math.abs(target) > sum) return 0;
        //如果(target+sum)除以2的余数不为0，也是没有方案的
        if ((target + sum) % 2 == 1) return 0;
        int bagSize = (target + sum) / 2;
        int[] dp = new int[bagSize + 1];
        dp[0] = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }

题目十二：零和一

1.题目：474. 一和零 - 力扣（LeetCode）

2.思路：定义一个二维的数组，m n最多有多少个物品

dp[i][j]数组的含义: 装满i个0、j个1最多背dp[i][j]个物品。最终求dp[m][n]
递推公式：物品的重量是x个0和y个1，xy是单个字符串中0和1的数量。dp[i][j]=Math.max(dp[i][j] , dp[i-x][j-y]+1)
初始化：dp[0][0]=0，非零下标也初始化为0
遍历顺序：先物品，后倒序遍历背包

public int findMaxForm(String[] strs, int m, int n) {
        //dp[i][j]表示i个0和j个1时的最大子集
        int[][] dp = new int[m + 1][n + 1];
        int oneNum, zeroNum;
        for (String str : strs) {
            oneNum = 0;
            zeroNum = 0;
            for (char ch : str.toCharArray()) {
                if (ch == '0') {
                    zeroNum++;
                } else {
                    oneNum++;
                }
            }
            //倒序遍历
            for (int i = m; i >= zeroNum; i--) {
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }

打家劫舍

题目二十九：打家劫舍（线性数组）

1.题目：198. 打家劫舍 - 力扣（LeetCode）

2. 思路：相邻房间不能偷

dp[i]数组的含义: 包含下标i之前所偷的房间的钱的最大数。最终求dp[nums.length-1]
递推公式：dp[i] =Math.max(dp[i-1], dp[i-2]+nums[i]) 因为相邻房间不能偷所以i-2
初始化：dp[0]=nums[0], dp[1]=Math.max(nums[0], nums[1])
遍历顺序：for(int i=2;i<nums.length;i++)

 public int rob(int[] nums) {
        if(nums.length==1)return nums[0];
        if(nums.length==2)return Math.max(nums[0],nums[1]);
         int[] dp=new int[nums.length];
        dp[0]=nums[0];
        dp[1]=Math.max(nums[0],nums[1]);
        for (int i=2;i<nums.length;i++){
            //偷i家和不偷第i家
            dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[nums.length-1];
    }

题目三十：打家劫舍||（首尾成环）

1. 题目：213. 打家劫舍 II - 力扣（LeetCode）

2. 思路：首尾都不考虑（其它两种情况包含了），考虑首不考虑尾巴，考虑尾不考虑首

也就是将后两种情况求最大

   public int rob(int[] nums) {
        if (nums.length==1)return nums[0];
        if (nums.length==2)return Math.max(nums[0],nums[1]);
        int result1=robaction(nums,0,nums.length-2);
        int result2=robaction(nums,1,nums.length-1);
        return Math.max(result1,result2);

    }

    public int robaction(int[] nums,int start,int end) {
        if(start==end)return nums[start];
        int[] dp=new int[nums.length];
        dp[start]=nums[start];
        dp[start+1]=Math.max(nums[start],nums[start+1]);
        for (int i=start+2;i<=end;i++){
            dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[end];
    }

题目三十一：大家劫舍|||（树形dp）

1.题目：. - 力扣（LeetCode）

2.思路：父节点偷完之后，孩子节点不能偷。后序遍历

递归函数的返回值：返回的是长度为2的dp数组，参数是树形根节点

终止条件：当前遍历的是null，返回空的数组

// 3.状态标记递归
    // 执行用时：0 ms , 在所有 Java 提交中击败了 100% 的用户
    // 不偷：Max(左孩子不偷，左孩子偷) + Max(右孩子不偷，右孩子偷)
    // root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) +
    // Math.max(rob(root.right)[0], rob(root.right)[1])
    // 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷
    // root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;
    public int rob3(TreeNode root) {
        int[] res = robAction1(root);
        return Math.max(res[0], res[1]);
    }

    int[] robAction1(TreeNode root) {
        int res[] = new int[2];
        if (root == null)
            return res;

        int[] left = robAction1(root.left);
        int[] right = robAction1(root.right);

        res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        res[1] = root.val + left[0] + right[0];
        return res;
    }

买卖股票

题目三十二：买卖股票一次买入卖出操作

1. 题目：121. 买卖股票的最佳时机 - 力扣（LeetCode）

2.思路：持有是保持已经买股票的状态，不一定是第i天卖出

dp[i][0]:第i天持有这个股票所得到的最大现金；dp[i][1]:第i天不持有这个股票所得到的最大现金，最终求的结果：dp[nums.length-1][0]和dp[nums.length-1][1]的最大值
递推公式：
- dp[i][0]表示持有
  - 第i-1天就持有股票，那么就保持现状，即：dp[i - 1][0]
  - 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]
- dp[i][1]表示不持有
  - 第i-1天就不持有股票，那么就保持现状，即：dp[i - 1][1]
  - 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]
初始化：dp[0][0]=-prices[0]；dp[0][1]=0
遍历顺序：for(int i=1;i<nums.length;i++)

 public int maxProfit(int[] prices) {
        int[][] dp=new int[prices.length][2];
        dp[0][0]=-prices[0];//持有股票
        dp[0][1]=0;
        for (int i=1;i<prices.length;i++){
            //第i天持有：不操作，操作
            dp[i][0]=Math.max(dp[i-1][0],-prices[i]);
            //第i天不持有：不操作，操作
            dp[i][1]=Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        return Math.max(dp[prices.length-1][0],dp[prices.length-1][1]);
    }

题目三十三：买卖股票不限次数

1. 题目：122. 买卖股票的最佳时机 II - 力扣（LeetCode）

2.思路：和买卖一次的区别就是买入股票的时候dp[i][0]=0-prices[i] 还是dp[i][0] = dp[i-1][1]-prices[i]之前持有然后卖出

   public int maxProfit(int[] prices) {
        int[][] dp=new int[prices.length][2];
        dp[0][0]=-prices[0];//持有股票
        dp[0][1]=0;
        for (int i=1;i<prices.length;i++){
            //第i天持有：不操作，操作
            dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
            //第i天不持有：不操作，操作
            dp[i][1]=Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        return Math.max(dp[prices.length-1][0],dp[prices.length-1][1]);
    }

题目三十四：买卖股票至多两次

1. 题目：. - 力扣（LeetCode）

2. 思路：不一定是第i天一定买入或卖出

递推公式：
- 不操作：dp[i][0]=dp[i-1][0]
- 第一次持有：dp[i][1]=Math.max(dp[i-1][1] , dp[i-1][0]-prices[i])
- 第一次不持有：dp[i][2]=Math.max(dp[i-1][2] , dp[i-1][1]+prices[i])
- 第二次持有：dp[i][3]=Math.max(dp[i-1][3] , dp[i-1][2]-prices[i])
- 第二次不持有：dp[i][4]=Math.max(dp[i-1][0] , dp[i-1][3]+prices[i])
初始化：dp[0][0]=0；dp[0][1]=-prices[0]；dp[0][2]=0；dp[0][3]=-prices[0]
遍历顺序：for(int i=1; i<nums.length;i++)

  public int maxProfit(int[] prices) {
        int len = prices.length;
        // 边界判断, 题目中 length >= 1, 所以可省去
        if (prices.length == 0) return 0;
        int[][] dp = new int[len][5];
        dp[0][1] = -prices[0];
        // 初始化第二次买入的状态是确保 最后结果是最多两次买卖的最大利润
        dp[0][3] = -prices[0];

        for (int i = 1; i < len; i++) {
            dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
            dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }

        return dp[len - 1][4];
    }

子序列

题目四十一：最长递增子序列

1.题目：300. 最长递增子序列 - 力扣（LeetCode）

2. 思路：

dp[i]含义：以nums[i]为结尾的最长递增子序列的长度
递推公式：遍历i之前的所有元素，如果nums[i]>nums[j]，dp[i] =Math.max(dp[i], dp[j] +1)
dp数组初始化：dp[i]=1
遍历顺序：for(int i=1;i<nums.length;i++){for(int j=0;j<i;j++){递推公式}}
最终结果：遍历dp数组，找到最大值

  public int lengthOfLIS(int[] nums) {
        int[] dp=new int[nums.length];
        Arrays.fill(dp,1);
        for (int i=0;i<nums.length;i++){
            for (int j=0;j<i;j++){
                if (nums[i]>nums[j])dp[i]=Math.max(dp[i],dp[j]+1);
            }
        }
        int ans=1;
        for (int i=0;i<dp.length;i++){
            ans=Math.max(ans,dp[i]);
        }
        return ans;
    }

题目四十二：最长连续递增子序列

1.题目：674. 最长连续递增序列 - 力扣（LeetCode）

2. 思路：去掉j只和前一个比较

   public int findLengthOfLCIS(int[] nums) {
        int[] dp=new int[nums.length];
        Arrays.fill(dp,1);
        for (int i=1;i<nums.length;i++){
            if (nums[i]>nums[i-1])dp[i]=dp[i-1]+1;
        }
        int ans=1;
        for (int i=0;i<dp.length;i++){
            ans=Math.max(ans,dp[i]);
        }
        return ans;
    }

题目四十三：最长重复子数组(连续)

1.题目：718. 最长重复子数组 - 力扣（LeetCode）

2. 思路：用二维dp数组来表示

如果nums1[i] 与 nums2[0] 相同的话，对应的 dp[i][0]就要初始为1，因为此时最长重复子数组为1。在初始化的时候麻烦

public int findLength(int[] nums1, int[] nums2) {
        int result = 0;
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        for (int i = 1; i < nums1.length + 1; i++) {
            for (int j = 1; j < nums2.length + 1; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    result = Math.max(result, dp[i][j]);
                }
            }
        }    
        return result;
    }

题目四十四：最长公共子序列（可不连续）

1. 题目：. - 力扣（LeetCode）

2. 思路：定义二维dp数组

定义dp[i][j]数组：以0开头i-1为结尾的nums1和以0开头j-1为结尾的num2，最长公共子序列的长度。好进行初始化
递推公式：if(nums1[i-1]==nums2[j-1]) dp[i][j]=dp[i-1][j-1]+1；如果不相同取最大值dp[i-1][j]和dp[i][j-1]
初始化：dp[i][0]=0；dp[0][j]=0
遍历顺序：从左往右，从上往下
最终结果：dp[nums1.length][nums2.length]

 public int longestCommonSubsequence(String text1, String text2) {
        char[] info1=text1.toCharArray();
        char[] info2=text2.toCharArray();
        int[][] dp=new int[text1.length()+1][text2.length()+1];
        for (int i=1;i<info1.length+1;i++){
            for (int j=1;j<info2.length+1;j++){
                if (info1[i-1]==info2[j-1])dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[text1.length()][text2.length()];
    }

题目四十五：不相交的线

1.题目：. - 力扣（LeetCode）

  public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int[][] dp=new int[nums1.length+1][nums2.length+1];
        for (int i=1;i<nums1.length+1;i++){
            for (int j=1;j<nums2.length+1;j++){
                if (nums1[i-1]==nums2[j-1])dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[nums1.length][nums2.length];
    }

题目四十六：判断子序列

1. 题目：. - 力扣（LeetCode）

2. 思路：求s和t的最长公共子序列的长度，如果长度是s的长度，那么s是t的子序列

public boolean isSubsequence(String s, String t) {
        char[] info1=s.toCharArray();
        char[] info2=t.toCharArray();
        int[][] dp=new int[s.length()+1][t.length()+1];
        for (int i=1;i<s.length()+1;i++){
            for (int j=1;j<t.length()+1;j++){
                if (info1[i-1]==info2[j-1])dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        if (dp[s.length()][t.length()]==s.length())return true;
        else return false;
    }

题目四十七：不同的子序列

1. 题目：代码随想录

2. 思路：也就是s中有多少种删除元素的方式，使得s可以变成t

 public int numDistinct(String s, String t) {
        int[][] dp = new int[s.length() + 1][t.length() + 1];
        for (int i = 0; i < s.length() + 1; i++) {
            dp[i][0] = 1;
        }    
        for (int i = 1; i < s.length() + 1; i++) {
            for (int j = 1; j < t.length() + 1; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                }else{
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }       
        return dp[s.length()][t.length()];
    }

题目四十八：两个字符串的删除操作

1. 题目：代码随想录

2.思路：找到两个字符串的公共子序列，用两个字符串的长度减去2个公共子序列的长度

 public int minDistance(String word1, String word2) {
        int len1 = word1.length();
        int len2 = word2.length();
        int[][] dp = new int[len1 + 1][len2 + 1];
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return len1 + len2 - dp[len1][len2] * 2;
    }

题目四十九：编辑距离

1. 题目： . - 力扣（LeetCode）

2. 思路：求最少操作多少步使得word1和word2相等

定义dp[i][j]数组：以0开头i-1为结尾的word1和以0开头j-1为结尾的word2，最少的操作次数
递推公式：
- 相同：if(word1[i-1]==word2[j-1]) dp[i][j]=dp[i-1][j-1];
- 不相同：取最小值
  - 删除和添加效果一样，删除word1[i-1]，则dp[i][j] = dp[i-1][j]+1；删除word2则dp[i][j]=dp[i][j-1]+1
  - 替换：dp[i][j] = dp[i-1][j-1]+1
初始化：那么dp[i][0]就应该是i，对word1里的元素全部做删除操作，即：
for(int i=0;i<=word1.size;i++)dp[i][0] = i; 同理dp[0][j]=j
遍历顺序：从左往右，从上往下
最终结果：dp[nums1.length][nums2.length]

public int minDistance(String word1, String word2) {
        int[][] dp=new int[word1.length()+1][word2.length()+1];
        //2.初始化
        for(int i=0;i<=word1.length();i++)dp[i][0]=i;
        for (int j=0;j<=word2.length();j++)dp[0][j]=j;
        for(int i=1;i<=word1.length();i++){
            for(int j=1;j<=word2.length();j++){
                if(word1.charAt(i-1)==word2.charAt(j-1))dp[i][j]=dp[i-1][j-1];
                else dp[i][j]=Math.min(Math.min(dp[i-1][j-1]+1,dp[i-1][j]+1),dp[i][j-1]+1);
            }
        }
        return dp[word1.length()][word2.length()];
    }

题目五十：回文子串

1. 题目：. - 力扣（LeetCode）

2. 思路：

定义dp[i][j]数组：dp[i][j]表示从i到j的子串是不是回文串，左闭右闭
递推公式：有三种情况 j-i<=1和j-i>1
初始化：dp[i][j]=false
遍历顺序：从底往上，从左往右
最终结果：ans

public int countSubstrings(String s) {
        boolean[][] dp=new boolean[s.length()][s.length()];
        char[] word=s.toCharArray();
        int ans=0;
        for(int i=s.length()-1;i>=0;i--){
            for(int j=i;j<s.length();j++){
                if(word[i]==word[j]){
                    if(j-i<=1){
                        dp[i][j]=true;
                        ans++;
                    }else if(dp[i+1][j-1]){
                        ans++;
                        dp[i][j]=true;
                    }
                }
            }
        }
        return ans;
    }

题目五十一：最长回文子序列

1. 题目：. - 力扣（LeetCode）

2. 思路：

定义dp[i][j]数组：dp[i][j]表示从i到j的范围内的回文子序列的长度，左闭右闭
递推公式：if(s[i]==s[j])dp[i][j] = dp[i+1][j-1]+2；如果不相同：取最大值(dp[i][j-1] , dp[i+1][j])
初始化：dp[i][i]=1，其他位置初始化为0
遍历顺序：从底往上，从左往右
最终结果：dp[0][len-1]

public int longestPalindromeSubseq(String s) {
        int len = s.length();
        int[][] dp = new int[len + 1][len + 1];
        for (int i = len - 1; i >= 0; i--) { // 从后往前遍历 保证情况不漏
            dp[i][i] = 1; // 初始化
            for (int j = i + 1; j < len; j++) {
                if (s.charAt(i) == s.charAt(j)) {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                } else {
                    dp[i][j] = Math.max(dp[i + 1][j], Math.max(dp[i][j], dp[i][j - 1]));
                }
            }
        }
        return dp[0][len - 1];
    }