LeetCode：动态规划-子序列问题

最新推荐文章于 2024-06-27 17:00:00 发布

丁真的小马

最新推荐文章于 2024-06-27 17:00:00 发布

阅读量656

点赞数

文章标签：动态规划 leetcode 算法

本文链接：https://blog.csdn.net/sfklyqh/article/details/122363660

版权

一、最大子数组和

53：给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。

贪心：

class Solution {
    public int maxSubArray(int[] nums) {
        int length = nums.length;
        int max = nums[0];
        int cur = 0;
        for(int i =0;i<length;i++){
            cur += nums[i];
            max = Math.max(max,cur);
            if(cur<0)
                cur = 0;
        }
        return max;
    }
}

动态规划：dp[i]记录以i为结尾的最大子数组和

class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }
}

二、最长递增子序列

300：给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列

class Solution {
    public int lengthOfLIS(int[] nums) {
        int length = nums.length;
        int result = 1;
        //dp[i]表示以i结尾的最长递增子序列长度
        int[] dp = new int[length];
        dp[0]=1;
        for(int i=1;i<length;i++){
            dp[i] = 1;
            for(int j=i-1;j>=0;j--){
                if(nums[j]<nums[i]){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
            result = Math.max(result,dp[i]);
        }
        return result;
    }
}

三、最长连续递增序列

674：给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

贪心：

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int length = nums.length;
        if(length==1) return 1;
        int result = 0;
        int cur = 1;
        for(int i=1;i<length;i++){
            //记录这次连续的长度
            if(nums[i]>nums[i-1])
                cur++;
            else
                cur=1;          
            //记录到目前位置最长的连续长度
            result=Math.max(cur,result);
        }
        return result;
    }
}

四、最长重复子数组

718：给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。

dp[i][j] ：以下标 i - 1 为结尾的 A ，和以下标 j - 1 为结尾的 B ，最⻓重复⼦数组⻓度为 dp[i][j] 。

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

五、最长公共子序列

1143：给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

dp[i][j] ：⻓度为 [0, i - 1] 的字符串 text1 与⻓度为 [0, j - 1] 的字符串 text2 的最⻓公共⼦序列为 dp[i][j]

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();
        int[][] dp = new int[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;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]);
                }

            }
        }
        return dp[m][n];
    }
}

六、判断子序列

392：给定字符串 s 和 t ，判断 s 是否为 t 的子序列。字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

双指针：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int length1 = s.length();
        int length2 = t.length();
        if(length1>length2){
            return false;
        }
        int sp=0,tp=0;
        while(sp<length1&&tp<length2){
            if(s.charAt(sp)==t.charAt(tp)){
                sp++;
                tp++;
            }else{
                tp++;
            }
        }
        return sp==length1;
    }
}

动态规划：dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的⻓度

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m =s.length();
        int n =t.length();
        int[][] dp = new int[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(s.charAt(i-1)==t.charAt(j-1))
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                //这一步和最长公共子序列有所区别，不需要判断max(dp[i-1][j],dp[i][j-1])
                //因为要保证s是连续的，所以d[i-1][j]破坏了s不连续没必要判断
                    dp[i][j]=dp[i][j-1];
            }
        }
        return dp[m][n]==m;
    }
}

七、不同的子序列

115：给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个子序列是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

有 3 种可以从 rabbbit 中得到 "rabbit" 的方案。

dp[i][j]：以i-1为结尾的s⼦序列中出现以j-1为结尾的t的个数为dp[i][j]

class Solution {
    public int numDistinct(String s, String t) {
        int m =s.length();
        int n =t.length();
        //dp[i][j]： s的前i个元素 包括多少个t的前j个元素 
        int[][]dp = new int[m+1][n+1];
        dp[0][0]=1;
        for(int i=0;i<m;i++){
            dp[i][0]=1;
        }

        for(int i =1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(j>i) dp[i][j]=0;
                else{
                    if(s.charAt(i-1)==t.charAt(j-1))
                    //分两种情况：s[i-1]参与的情况dp[i-1][j-1] 和 s[i-1]不参与的情况dp[i-1][j]
                        dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
                    else
                        dp[i][j]=dp[i-1][j];
                }
                
            }
        }
        return dp[m][n];
    }
}

八、两个字符串删除操作

583：给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。

dp[i][j]：word1前i个元素和word2前j个元素要上达到相同需要操作的最少步数

class Solution {
    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        //dp[i][j]：word1前i个元素 和word2前j个元素要上达到相同 需要操作的最少个数
        int[][] dp = new int[m+1][n+1]; 
        for(int i=0;i<=n;i++)
            dp[0][i]=i;
        for(int i=0;i<=m;i++)
            dp[i][0]=i;

        for(int i =1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(word1.charAt(i-1)==word2.charAt(j-1))
                    dp[i][j]=dp[i-1][j-1];
                else//三种情况：删除word1的元素/删除word2的元素/两个都删
                    dp[i][j]=Math.min(Math.min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+2);
            }
        }
        return dp[m][n];
    }
}

九、编辑距离

72：给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

dp[i][j]：word1前i个元素转为word2前j的元素需要的最少操作数

class Solution {
    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        //dp[i][j]：word1前i个元素转为word2前j的元素需要的最少操作数
        int[][] dp = new int[m+1][n+1];
        for(int i=0;i<=m;i++)
            dp[i][0]=i;
        for(int i=0;i<=n;i++)
            dp[0][i]=i;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(word1.charAt(i-1)==word2.charAt(j-1))
                    dp[i][j]=dp[i-1][j-1];
                else
                //对应元素不相等有3种情况：1.删除word1第i个元素 2.word1增加第word2的第j个元素 3.修改word1第i个元素为word2第j个元素
                    dp[i][j]=Math.min(Math.min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1])+1;
            }
        }
        return dp[m][n];
    }
}

丁真的小马

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode：动态规划-子序列问题

一、最大子数组和53：给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。贪心：class Solution { public int maxSubArray(int[] nums) { int length = nums.length; int max = nums[0]; int cur = 0; for(int i =0;i&lt
复制链接

扫一扫