动规基础
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];
}
题目十二:零和一
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];
}
打家劫舍
题目二十九:打家劫舍(线性数组)
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[i][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]; }