62 不同路径
很简单的dp
class Solution {
public int uniquePaths(int m, int n) {
//58-02
int[][] dp = new int[m][n];
//初始化
for(int i = 0;i<m;i++){
dp[i][0] = 1;
}
for(int i = 0;i<n;i++){
dp[0][i] = 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];
}
}
63 不同路径2
和前一题的区别在于只要判断当前有障碍物就dp对应数值设为0，否则就是正常算法，还有就是初始化的时候要判断前面出现过障碍物就得设为0
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
//05-13
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
int[][] dp = new int[m][n];
int f = 0;
for(int i=0;i<m;i++){
if(obstacleGrid[i][0]==1){
f = 1;
dp[i][0] = 0;
}
if(f==1) dp[i][0] = 0;//自从出现过之后就是0
else dp[i][0] = 1;
}
f = 0;
for(int j=0;j<n;j++){
if(obstacleGrid[0][j]==1){
f = 1;
dp[0][j] = 0;
}
if(f==1) dp[0][j] = 0;
else dp[0][j] = 1;
}
for(int i=1;i<m;i++){
for(int j=1;j<n;j++){
if(obstacleGrid[i][j]==0){
dp[i][j] = dp[i-1][j]+dp[i][j-1];
}
else dp[i][j] = 0;
}
}
return dp[m-1][n-1];
}
}
343 整数拆分
dp[i]表示拆分整数i能取得的最大乘积
递推表达：选择dp[i-j]*j和(i-j)*j中最大的一个，两个分别表示拆成大于两个和拆成两个
看题解之后觉得容易，但是如果没放在dp章节里也不太好想
class Solution {
public int integerBreak(int n) {
//06
int[] dp = new int[n+1];
dp[0] = 0;
dp[1] = 1;
dp[2] = 1;
for(int i=3;i<=n;i++){
for(int j=1;j<i;j++){
dp[i] = Math.max(dp[i],Math.max(dp[i-j]*j,(i-j)*j));
}
}
return dp[n];
}
}
96 不同的二叉搜索树
画图画了很久还是没找到规律，还是因为没有从搜索树的特点出发：总共有i个节点，每次以j为头节点，那左子树的节点有j-1个，右子树的节点的有i-j个，相乘再累加即可！！！
class Solution {
public int numTrees(int n) {
//14-10
int[] dp = new int[n+1];
if(n==1) return 1;
Arrays.fill(dp,0);
dp[0] = 1;
dp[1] = 1;
dp[2] = 2;
for(int i=3;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];
}
}
背包问题
- 二维数组
dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
- 一维数组写法（滚动数组）倒序遍历
dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
倒序遍历是为了保证物品i只被放入一次！。但如果一旦正序遍历了，那么物品0就会被重复加入多次！
要注意先遍历物品，再遍历背包容量，然后内层要从大到小！！
int wLen = weight.length;
//定义dp数组：dp[j]表示背包容量为j时，能获得的最大价值
int[] dp = new int[bagWeight + 1];
//遍历顺序：先遍历物品，再遍历背包容量 不能改变
for (int i = 0; i < wLen; i++){
for (int j = bagWeight; j >= weight[i]; j--){
dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
}
}
416 分割等和子集
第一反应是用双指针，先排序之后从两边往中间指，但是后来发现这是不行的，因为两个集合完全是可以数值交叉的，所以还是需要转成01背包问题（回溯会超时）
class Solution {
public boolean canPartition(int[] nums) {
//41 不能用双指针因为两个集合可以交叉 像1122是可以的 但是双指针就不行-13
int sum = 0;
for(int num:nums) sum+=num;
if(sum%2==1) return false;
int target = sum/2;
int[] dp = new int[target+1];
Arrays.fill(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]);
}
}
return dp[target]==target;
}
}
1049 最后一块石头的重量 II
也不好想！！要多思考
可以转换成上一题，就是尽量分成两堆相同的，差值就是剩下的
class Solution {
public int lastStoneWeightII(int[] stones) {
//16
//分成尽量相同的两堆 之后的差值就是最小的
int sum = 0;
for(int num:stones) sum+=num;
int target = sum/2;
int[] dp = new int[target+1];
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]*2;
}
}
最后dp[target]就是分成的一堆的数量之和，另一堆的重量就是sum-dp[target], 两堆之差就是sum-dp[target]*2;
494 目标和
用之前的回溯还是有问题，因为不用把具体的列出来，只要计算数字就可以用dp.转换为01背包问题。dp[j]表示装进j容量的包有最多多少种解法
组合类的公式
dp[j] += dp[j - nums[i]]
class Solution {
public int findTargetSumWays(int[] nums, int target) {
int sum = 0;
for(int i=0;i<nums.length;i++){
sum+=nums[i];
}
if(sum+target<0||sum<target) return 0;//target可能为负 不能过大或过小
if((sum+target)%2==1) return 0;
int left = (sum+target)/2;
int[] dp = new int[left+1];
dp[0]=1;
for(int i=0;i<nums.length;i++){
for(int j = left;j>=nums[i];j--){
dp[j]+=dp[j-nums[i]];
}
}
return dp[left];
}
}
474 0和1
可以转换为01背包问题，就是重量有m和n两个维度，dp[i][j]表示最多由i个0和j个1组成的最大长度
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
//53
int[][] dp = new int[m+1][n+1];//表最多装m个0 n个1
dp[0][0]=0;
for(String str:strs){//外层 遍历物品
int zero = 0;
int one = 0;
for(int i=0;i<str.length();i++){
if(str.charAt(i)=='0') zero++;
if(str.charAt(i)=='1') one++;
}
for(int i=m;i>=zero;i--){//内层 从大到小遍历两个维度的“背包重量”
for(int j=n;j>=one;j--){
dp[i][j] = Math.max(dp[i][j],dp[i-zero][j-one]+1);
}
}
}
return dp[m][n];
}
}
518 零钱兑换2
class Solution {
public int change(int amount, int[] coins) {
//12
int[] dp = new int[amount+1];
dp[0] = 1;
for(int i=0;i<coins.length;i++){
for(int j=coins[i];j<=amount;j++){
dp[j]+=dp[j-coins[i]];
}
}
return dp[amount];
}
}
377. 组合总和 Ⅳ
完全背包问题的排列数，外层遍历背包，内层遍历物品，都是从小到大遍历
class Solution {
public int combinationSum4(int[] nums, int target) {
//17-23
int[] dp = new int[target+1];
dp[0]=1;
for(int i=0;i<=target;i++){
for(int j=0;j<nums.length;j++){
if(i>=nums[j]) dp[i] +=dp[i-nums[j]];
}
}
return dp[target];
}
}
爬楼梯问题的进阶版
每次一步可以选择一个台阶，两个台阶，三个台阶，…，直到 m个台阶。问有多少种不同的方法可以爬到楼顶呢？
转换一下就是完全背包问题的排列问题！因为顺序是有关系的
class Solution {
public int climbStairs(int n) {
int[] dp = new int[n + 1];
int[] weight = {1,2,...m};
dp[0] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < weight.length; j++) {
if (i >= weight[j]) dp[i] += dp[i - weight[j]];
}
}
//或者直接
for (int i = 1; i <= n; i++) { // 遍历背包
for (int j = 1; j <= m; j++) { // 遍历物品
if (i - j >= 0) dp[i] += dp[i - j];
}
}
return dp[n];
}
}
322 零钱兑换
完全背包问题 注意要把0下标和非0下标的初始化分开
class Solution {
public int coinChange(int[] coins, int amount) {
//31
//完全背包问题 个数
int[] dp = new int[amount+1];
Arrays.fill(dp,amount+1);//初始化一个最大的
dp[0] = 0;//0下标
for(int i=0;i<coins.length;i++){
for(int j=coins[i];j<=amount;j++){
dp[j]=Math.min(dp[j-coins[i]]+1,dp[j]);
}
}
return dp[amount]==amount+1?-1:dp[amount];
}
}
279 完全平方数
class Solution {
public int numSquares(int n) {
//完全背包 49-51
int[] dp = new int[n+1];
Arrays.fill(dp,n+1);//初始化最大的
dp[0]=0;
for(int i=1;i*i<=n;i++){
for(int j=i*i;j<=n;j++){
dp[j] = Math.min(dp[j],dp[j-i*i]+1);
}
}
return dp[n];
}
}
139 单词拆分
dp[i] : 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。
如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。（j < i ）。
所以递推公式是 if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true。
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
//55 完全背包 跟顺序有关
int n = s.length();
boolean[] dp = new boolean[n+1];//dp[i]表示0-i下标的s可以被组成的个数
dp[0]=true;
for(int i=1;i<=s.length();i++){//排列问题 背包在外层
for(String str:wordDict){//物品内层
int len = str.length();
if(i>=len&&dp[i-len]&&s.substring(i-len,i).equals(str)){//递推公式
dp[i] = true;
}
}
}
return dp[n];
}
}
198 打家劫舍
class Solution {
public int rob(int[] nums) {
//7-12
int[] dp = new int[nums.length];
dp[0] = nums[0];
if(nums.length==1) return nums[0];
dp[1] = Math.max(nums[0],nums[1]);
for(int i=2;i<nums.length;i++){
dp[i] = Math.max(nums[i]+dp[i-2],dp[i-1]);
}
return dp[nums.length-1];
}
}
213 打家劫舍2
class Solution {
public int rob(int[] nums) {
//14-20
int[] dp = new int[nums.length];
int[] dp2 = new int[nums.length];
//偷第一家
dp[0] = nums[0];
if(nums.length==1) return nums[0];
dp[1] = nums[0];//第二家就不偷了
for(int i=2;i<nums.length;i++){
dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);
}
//最后一家不偷 就是dp[nums.length-2]
//不偷第一家
dp2[0] = 0;
dp2[1] = nums[1];
for(int i=2;i<nums.length;i++){
dp2[i] = Math.max(dp2[i-2]+nums[i],dp2[i-1]);
}
//选两种中大的
return Math.max(dp[nums.length-2],dp2[nums.length-1]);
}
}
337 打家劫舍3
树形dp!!!其实和数组一样，就是要确定遍历方式，这里需要用后序遍历，从下往上
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rob(TreeNode root) {
int[] res = af(root);
return Math.max(res[0],res[1]);
}
public int[] af(TreeNode root){
int[] res = new int[2];
if(root==null) return new int[]{0,0};
int[] left = af(root.left);
int[] right = af(root.right);//下标0：偷，下标1：不偷 0是选了当前节点值 1是没选
res[0] = root.val+left[1]+right[1];
res[1] = Math.max(left[0],left[1])+Math.max(right[0],right[1]);
return res;
}
}
121 买卖股票的最佳时机
class Solution {
public int maxProfit(int[] prices) {
//41-44
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
for(int i=0;i<prices.length;i++){
if(prices[i]<min) min = prices[i];
max = Math.max(max,prices[i]-min);
}
return max;
}
}
122 买卖股票的最佳时机2
class Solution {
public int maxProfit(int[] prices) {
//47-49
int max = 0;
if(prices.length==1) return 0;
for(int i=1;i<prices.length;i++){
max += Math.max(0,prices[i]-prices[i-1]);
}
return max;
}
}
123 买卖股票的最佳时机2
class Solution {
public int maxProfit(int[] prices) {
//50
//下标为1 表示买了一次 2：表示买了一次又卖了一次 3：表示买了两次卖了一次 4：买了两次卖了两次
int[][] dp = new int[prices.length][5];
dp[0][1] = -prices[0];
dp[0][3] = -prices[0];
for(int i=1;i<prices.length;i++){
dp[i][0] = 0;
dp[i][1] = Math.max(dp[i-1][1],dp[i][0]-prices[i]);
dp[i][2] = Math.max(dp[i-1][2],dp[i][1]+prices[i]);
dp[i][3] = Math.max(dp[i-1][3],dp[i][2]-prices[i]);
dp[i][4] = Math.max(dp[i-1][4],dp[i][3]+prices[i]);
}
return dp[prices.length-1][4];
}
}
188
就是上一题的进阶版，把k也用数组表示即可
class Solution {
public int maxProfit(int k, int[] prices) {
//03-13
int[][] dp = new int[prices.length][2*k+1];
for(int i=1;i<=2*k;i+=2){
dp[0][i] = -prices[0];
}
for(int i=1;i<prices.length;i++){
dp[i][0] = 0;
for(int j=1;j<=2*k;j+=2){
dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]-prices[i]);
dp[i][j+1] = Math.max(dp[i-1][j+1],dp[i][j]+prices[i]);
}
}
return dp[prices.length-1][2*k];
}
}
309. 最佳买卖股票时机含冷冻期
状态一：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
不持有股票状态，这里就有两种卖出股票状态
状态二：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
状态三：今天卖出股票
状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！
确定递推公式
达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：
操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
操作二：今天买入了，有两种情况
前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
前一天是保持卖出股票的状态（状态二），dp[i - 1][1] - prices[i]
那么dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);
达到保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：
操作一：前一天就是状态二
操作二：前一天是冷冻期（状态四）
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
达到今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：
昨天一定是持有股票状态（状态一），今天卖出
即：dp[i][2] = dp[i - 1][0] + prices[i];
达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：
昨天卖出了股票（状态三）
dp[i][3] = dp[i - 1][2];
最后结果是取 状态二，状态三，和状态四的最大值，不少同学会把状态四忘了，状态四是冷冻期，最后一天如果是冷冻期也可能是最大值。
class Solution {
public int maxProfit(int[] prices) {
//15
int n = prices.length;
if (n == 0) return 0;
int[][] dp = new int[prices.length][4];
dp[0][0] -= prices[0]; // 持股票
for (int i = 1; i < n; i++) {
dp[i][0] = Math.max(dp[i - 1][0], Math.max(dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]));
dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][3]);
dp[i][2] = dp[i - 1][0] + prices[i];
dp[i][3] = dp[i - 1][2];
}
return Math.max(dp[n - 1][3], Math.max(dp[n - 1][1], dp[n - 1][2]));
}
}
714 买卖股票含手续费
class Solution {
public int maxProfit(int[] prices, int fee) {
int[][] dp = new int[prices.length][2];
// 0 : 持股（买入）
// 1 : 不持股（售出）
// dp 定义第i天持股/不持股 所得最多现金
dp[0][0] = -prices[0];
for(int i=1;i<prices.length;i++){
dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
dp[i][1]=Math.max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);
}
return dp[prices.length-1][1];
}
}
740 删除并获得点数
和打家劫舍有点像，不过要求的是相邻的数字 而不是相邻的nums
class Solution {
public int deleteAndEarn(int[] nums) {
//47 像打家劫舍
if(nums.length==1) return nums[0];
int[] count = new int[10001];
Arrays.fill(count,0);
for(int i=0;i<nums.length;i++){
count[nums[i]]++;
}
int[] dp = new int[10001];
dp[0] = 0;
dp[1] = count[1];
for(int i=2;i<dp.length;i++){
dp[i] = Math.max(dp[i-1],dp[i-2]+count[i]*i);
}
return dp[10000];
}
}
300. 最长递增子序列
好像过了十几天没刷题，有点生疏，明明指导写法还是改了十几分钟
class Solution {
public int lengthOfLIS(int[] nums) {
//02-19
//前面最长的
int[] dp = new int[nums.length];//以i为字符串结尾的最长长度
if(nums.length==1) return 1;
Arrays.fill(dp,1);
int res = -1;
for(int i=1;i<nums.length;i++){
//找前面的更小的，且dp最大的
for(int j=0;j<i;j++){
if(nums[i]>nums[j]) dp[i] = Math.max(dp[i],dp[j]+1);
}
res = Math.max(res,dp[i]);
}
return res;
}
}
718 最长重复子数组
class Solution {
public int findLength(int[] nums1, int[] nums2) {
//20-40
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]) {//注意如果没有相等就不用管，还是0，因为子数组要求是连续的
dp[i][j] = dp[i - 1][j - 1] + 1;
result = Math.max(result, dp[i][j]);
}
}
}
return result;
}
}
1143 最长公共子序列
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
//42-47
int res = 0;
int[][] dp = new int[text1.length()+1][text2.length()+1];//默认初始化为0
for(int i=1;i<=text1.length();i++){
for(int j=1;j<=text2.length();j++){
if(text1.charAt(i-1)==text2.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]);//不要求连续就需要写这个
res = Math.max(res,dp[i][j]);
}
}
return res;//其实最大值一定在最后，所以返回 dp[text1.length()][text2.length()] 也一样
}
}
1035 不相交的线
其实就是找最长公共子序列的个数即可
class Solution {
public int maxUncrossedLines(int[] nums1, int[] nums2) {
//01-03
int[][] dp = new int[nums1.length+1][nums2.length+1];
for(int i=1;i<=nums1.length;i++){
for(int j=1;j<=nums2.length;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];
}
}
53 最大子数组和
连续子数组
class Solution {
public int maxSubArray(int[] nums) {
//35-40
int[] dp = new int[nums.length];
int res = Integer.MIN_VALUE;
for(int i=0;i<nums.length;i++){
if(i==0) dp[i] = nums[i];
else{
dp[i] = Math.max(0,dp[i-1])+nums[i];
}
res = Math.max(res,dp[i]);
}
return res;
}
}
392 判断子序列
class Solution {
public boolean isSubsequence(String s, String t) {
//42-46
int[][] dp = new int[s.length()+1][t.length()+1];
for(int i=1;i<=s.length();i++){
for(int j=1;j<=t.length();j++){
if(s.charAt(i-1)==t.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]);
}
}
if(dp[s.length()][t.length()]==s.length()) return true;
else return false;
}
}
115 不同的子序列
第一眼没有想出来，还是看了题解，主要是递推公式的变化。因为要求s中包含t，所以递推的时候考虑删掉s中的字符
class Solution {
public int numDistinct(String s, String t) {
//47
int[][] dp = new int[s.length()+1][t.length()+1];
for(int i=0;i<s.length();i++){
dp[i][0] = 1;
}
for(int i=1;i<=s.length();i++){
for(int j=1;j<=t.length();j++){
if(s.charAt(i-1)==t.charAt(j-1)) dp[i][j] = dp[i-1][j-1]+dp[i-1][j];
//dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]
else dp[i][j] = dp[i-1][j];
}
}
return dp[s.length()][t.length()];
}
}
583. 两个字符串的删除操作
dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。
这里dp数组的定义有点点绕，大家要撸清思路。
确定递推公式
当word1[i - 1] 与 word2[j - 1]相同的时候
当word1[i - 1] 与 word2[j - 1]不相同的时候
当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i][j] = dp[i - 1][j - 1];
当word1[i - 1] 与 word2[j - 1]不相同的时候，有三种情况：
情况一：删word1[i - 1]，最少操作次数为dp[i - 1][j] + 1
情况二：删word2[j - 1]，最少操作次数为dp[i][j - 1] + 1
情况三：同时删word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1][j - 1] + 2
那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});
class Solution {
public int minDistance(String word1, String word2) {
//01
int[][] dp = new int[word1.length()+1][word2.length()+1];
//初始化
for(int i=0;i<=word1.length();i++){//记得要初始化到len+1位
dp[i][0] = i;
}
for(int i=0;i<=word2.length();i++){
dp[0][i] = i;
}
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(dp[i-1][j-1]+2,Math.min(dp[i-1][j]+1,dp[i][j-1]+1));
}
}
return dp[word1.length()][word2.length()];
}
}
72 编辑距离
class Solution {
public int minDistance(String word1, String word2) {
//57-05
int[][] dp = new int[word1.length()+1][word2.length()+1];
for(int i=0;i<=word1.length();i++){
dp[i][0] = i;
}
for(int i=0;i<=word2.length();i++){
dp[0][i] = i;
}
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(dp[i-1][j],Math.min(dp[i][j-1],dp[i-1][j-1]))+1;
}
}
}
return dp[word1.length()][word2.length()];
}
}
647 回文子串个数
class Solution {
int res = 0;
public int countSubstrings(String s) {
//20 从中心向两边扩展
for(int i=0;i<s.length();i++){
func(s,i,i);
func(s,i,i+1);
}
return res;
}
public void func(String s, int begin, int end){
while(begin>=0&&end<s.length()&&begin<=end&&s.charAt(begin)==s.charAt(end)){
begin--;
end++;
res++;
}
}
}
最长回文子串
class Solution {
public int longestPalindromeSubseq(String s) {
//32
int res = 0;
for(int i=0;i<s.length();i++){
res = Math.max(res,Math.max(func(s,i,i),func(s,i,i+1)));
}
return res;
}
public int func(String s, int begin, int end){
while(begin>=0&&end<s.length()&&begin<=end&&s.charAt(begin)==s.charAt(end)){
begin--;
end++;
}
return end-begin-1;
}
}
回文子串是要连续的，回文子序列可不是连续的！ 回文子串，回文子序列都是动态规划经典题目。
516 最长回文子序列
class Solution {
public int longestPalindromeSubseq(String s) {
//32
int[][] dp = new int[s.length()][s.length()];
for(int i=s.length()-1;i>=0;i--){//递推顺序要从下往上，从左往右
dp[i][i]=1;//初始化
for(int j=i+1;j<s.length();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],dp[i][j-1]);
}
}
}
return dp[0][s.length()-1];
}
}
363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
