动态规划之最长递增子序列

已于 2023-09-16 02:00:18 修改
阅读量1.1k 收藏 10
点赞数 1
分类专栏： 代码随想录 文章标签： 动态规划 leetcode 算法
于 2023-06-26 16:51:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47460244/article/details/131335527
版权

leetcode 300 最长递增子序列

1.定义dp数组：dp[i]表示以nums[i]结尾的最长递增子序列的长度。
2.定义递推公式
dp[i] = max(dp[j] + 1, dp[i]) 因为dp[j] + 1中的dp[j]并非是在前一个已经加1的dp[j]的基础之上再加上1。若从初始状态加1，而dp[i]永远保持的是最大的状态，则dp[j] + 1肯定要小一些。
3.初始化
Arrays.fill(dp, 1);
4.遍历顺序
for(int i = 0; i < nums.length; i++){
for(int j = 0; j < i; j++){
if(nums[i] > nums[j]){
dp[i] = max(dp[j] + 1, dp[i]) ;
}
}
}
5.最后再遍历一遍dp数组，返回其中的最大值。

    public int lengthOfLIS(int[] nums) {
        int res = 0;
        //定义dp数组
        int[] dp = new int[nums.length];
        //初始化dp数组
        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[j] + 1, dp[i]);
                }
            }
            //每更新一次dp[i]的值便与以前一个nums[i]结尾的数组的最长递增子序列的值比较一次
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

leetcode 674 最长连续递增序列

1.定义dp数组：dp[i]是以i结尾的数列中的最长连续递增序列；
2.递推公式：本题只需考虑当前元素及其前一个元素；
dp[i] = dp[i - 1] + 1
3.初始化
Arrays.fill(dp, 1);
4.遍历顺序
只需要一层for循环，循环变量从1开始；
5.最后再遍历一遍dp数组，返回其最大值。

    public int findLengthOfLCIS(int[] nums) {
        //特判
        if(nums.length == 1){
            return 1;
        }
        int res = 0;
        //定义dp数组
        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;
            }
            res = Math.max(res,dp[i]);
        }
        return res;
    }
}

leetcode 718 最长重复子数组

1.定义dp数组
dp[i][j]:表示以num1[i - 1]和nums2[j - 1]为尾部的数组num1和nums2的最长重复子数组的长度。
初始化：将无意义的值赋值为0：dp[i][0] = 0; dp[0][j] = 0;其余的值也为0。
2.递推公式
if(nums[i - 1] == nums[j - 1]){
dp[i][j] = dp[i - 1][j - 1] + 1;
}
3.遍历顺序
for(int i = 1; i <= nums1.length; i++){
for(int j = 1; j <= nums2.length; j++){
}
}
4.返回值
每遍历完dp数组的一个值，便与result进行一次比较，选出较大的值赋给result。

    public int findLength(int[] nums1, int[] nums2) {
        int res = 0;
        //定义dp数组
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        //初始化dp数组
        for(int i = 0; i <= nums1.length; i++){
            dp[i][0] = 0;
        }
        for(int j = 0; j <= nums2.length; j++){
            dp[0][j] = 0;
        }
        //定义递推公式以及遍历顺序
        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;
                }
                if(dp[i][j] > res){
                    res = dp[i][j];
                }
            }
        }
        return res;
    }
}

leetcode1143 最长公共子序列

本题与上一题的区别在于本题的公共子序列可以在两个数组中不连续。
1.定义dp数组
dp[i][j]表示nums1[0, i -1]与nums2[0, j - 1]两个数组中最长公共子序列的长度。
初始化：dp[i][0]与dp[0][j]的值没有意义，故初始化为0。
2.定义递推公式与遍历顺序
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]);
}
注意：dp数组的遍历顺序由递推公式的推导方向而得出。
3.最后返回dp[nums1.length][nums2.length]。

    public int longestCommonSubsequence(String text1, String text2) {
        //定义dp数组
        int[][] dp = new int[text1.length() + 1][text2.length() + 1];
        //递推公式与遍历顺序
        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]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }
}

leetcode 1035 不相交的线

本题的思路完全与上一题一致。

    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        //定义dp数组
        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];
    }
}

leetcode 53 最大子序和

1.定义dp[i]:以nums[i]结尾的最大连续子序列的和。
2.递推公式
dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);

public:
    int maxSubArray(vector<int>& nums) {
        int res = nums[0];
        //定义dp数组
        vector<int> dp(nums.size());
        //初始化dp数组
        dp[0] = nums[0];
        //定义递推公式以及遍历顺序
        for(int i = 1; i < nums.size(); i++){
            dp[i] = dp[i - 1] + nums[i] > nums[i] ? dp[i - 1] + nums[i] : nums[i];
            res = dp[i] > res ? dp[i] : res;
        }
        return res;
    }
};

leetcode 392 判断子序列

本题思路与1143最长公共子序列基本一致，只是本题仅仅考虑在更长的字符串t中删除元素以和s匹配最长公共子序列。
故唯一的区别在于递推公式：
if(s.charAt(i - 1) == t.charAt(j - 1)){
dp[i][j] = dp[i - 1][j - 1] + 1;
}else{
dp[i][j] = dp[i][j - 1]
}

    public boolean isSubsequence(String s, String t) {
        if(s.length() > t.length()){
            return false;
        }
        //定义dp数组
        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] = dp[i][j - 1];
                }
            }
        }
        if(dp[s.length()][t.length()] == s.length()){
            return true;
        }
        return false;
    }
}

leetcode115 不同的子序列

1.定义dp数组
dp[i][j]:表示以下标i - 1为结尾的字符串中拥有以下标j - 1为结尾的字符串作为子序列的个数。
2.递推公式以及初始化
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];
}
初始化：
dp[i][0] = 1;表示一直删除字符串s中的元素，当s为空字符串时，恰好包含1个空字符串t。
dp[0][j] = 0;因为空字符串中一定不会包含非空字符串。
dp[0][0] = 1;因为空字符串中一定包含1个空字符串。
3.返回值
return dp[s.length()][t.length()];

    public int numDistinct(String s, String t) {
        //定义dp数组
        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];
                }else{
                    dp[i][j] = dp[i - 1][j];//相当于从s中删除1个元素后，再看其中有多少个子序列t
                }
            }
        }
        return dp[s.length()][t.length()];
    }
}

leetcode 583 两个字符串的删除操作

解法1：
1.定义dp数组：dp[i][j]表示使以i - 1下标结尾的字符串与以j - 1下标结尾的字符串相同所需要的最少的操作次数。
2.递推公式与初始化
if(s.charAt(i - 1) == t.charAt(j - 1))则dp[i][j] = dp[i - 1][j - 1];
否则的话：dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 2);
初始化：dp[i][0] = i, dp[0][j] = j。
3.返回值：return dp[s.length()][t.length()]

    public int minDistance(String word1, String word2) {
        //定义dp数组
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        //初始化dp数组
        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, dp[i][j - 1] + 1), dp[i - 1][j - 1] + 2);
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

解法2：
可以先求出两个字符串的最长公共子序列的长度，再s.length() + t.length() - 2 * 最长公共子序列的长度。

    public int minDistance(String word1, String word2) {
        //定义dp数组
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        //递推公式以及遍历顺序
        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] + 1;
                }else{
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return word1.length() + word2.length() - 2 * dp[word1.length()][word2.length()];
    }
}

leetcode 72 编辑距离

1.定义dp数组
dp[i][j]表示使以下标i - 1位置结尾的字符串与以下标j - 1位置结尾的字符串相同的话所需要的最小操作次数。
2.递推公式以及遍历顺序
if(s.charAt(i - 1) == t.charAt(j - 1))则将对应位置的字母去掉与否都不会影响最终的最少操作次数，故dp[i][j] = dp[i - 1][j - 1];
否则，dp[i][j] = Math.min(Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1), dp[i - 1][j - 1] + 1);
因为将s的最后一个字母去掉后，其本身便对应1次操作；同理将t的最后一个字母去掉后也对应1次操作，或者将s与t其中之一的最后一个字母替换为另一个的字母而使其相同。
注意：删除操作和增添操作是一一对应的关系，故它们的操作次数一样，所以只需要递推其中之一即可。
3.初始化
dp[i][0] = i; dp[0][j] = j （这里可以将下标0理解为空字符串）
4.返回值
return dp[s.length()][t.length()] (因为这对应完整长度的s与t的最少操作次数)

    public int minDistance(String word1, String word2) {
        //定义dp数组
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        //初始化dp数组
        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, dp[i][j - 1] + 1), dp[i - 1][j - 1] + 1);
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

leetcode 647 回文子串

1.定义dp数组：dp[i][j]表示子串[i, j]是否是回文子串，是则记录true，否则记录false。
2.定义递推公式：
if(s.charAt(i) == s.charAt(j)),且j - i <= 1，则一定是回文子串。此时，result++;
若在此前提下，j - i > 1,则继续判断s.charAt(i + 1)是否等于s.charAt(j - 1)，若是，则[i, j]是回文子串，dp[i][j]为true, result++。
3.定义遍历顺序
根据递推公式的推导顺序，遍历顺序应该是从下往上，从左往右。
for(int i = s.length() - 1; i >= 0; i–){
for(int j = i; j < s.length(); j++){}
}

    public int countSubstrings(String s) {
        int result = 0;
        //定义dp数组,默认初始化为false
        boolean[][] dp = new boolean[s.length()][s.length()];
        //定义递推公式以及遍历顺序,j始终大于等于i
        for(int i = s.length() - 1; i >= 0; i--){
            for(int j = i; j < s.length(); j++){
                if(s.charAt(i) == s.charAt(j)){
                    if(j - i <= 1){
                        dp[i][j] = true;
                        result++;
                    }else{
                        if(dp[i + 1][j - 1] == true){
                            dp[i][j] = true;
                            result++;
                        }
                    }
                }
            }
        }
        return result;
    }
}

leetcode 516 最长回文子串

本题与上一题的区别在于其回文子序列可以不连续。
1.定义dp数组：dp[i][j]表示子序列[i, j]的最长回文子串（可以不连续）的长度。
2.定义递推公式以及遍历顺序
if(s.charAt(i) == s.charAt(j))，则dp[i][j] = dp[i + 1][j - 1] + 2;
若上述条件不相等，则dp[i][j] = Math.max(dp[i][j - 1], dp[i + 1][j]);其分别表示只考虑字符串的左边或只考虑字符串的右边，选出两者最大的。
遍历顺序根据递推公式是从下往上，从左到右。
for(int i = s.length() - 1; i >= 0; i–){
for(int j = i + 1; j < s.length(); j++){}//j必须从i + 1开始，才能保证[i, j]子序列的长度至少为2。因为dp[i][i]已经被初始化为1了。
}
3.最后返回dp[0][s.length() - 1]。

    public int longestPalindromeSubseq(String s) {
        //定义dp数组
        int[][] dp = new int[s.length()][s.length()];
        //初始化dp数组
        for(int i = 0; i < s.length(); i++){
            dp[i][i] = 1;//只有1个字符的子序列也是长度为1的回文子序列
        }
        //定义递推公式以及遍历顺序
        for(int i = s.length() - 1; i >= 0; i--){
            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][j - 1], dp[i + 1][j]);
                }
            }
        }
        return dp[0][s.length() - 1];
    }
}
Maravilloso
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态规划问题-最长单调递增子序列问题
11-08
L={a1,a2,a3,…,an}，是由n个不同的实数组成的序列，求L的最长单调递增子序列的长度（下标可不连续）
动态规划：最长单调递增子序列
05-28
动态规划：最长单调递增子序列 A numeric sequence of ai is ordered if a1 < a2 < ... < aN. Let the subsequence of the given numeric sequence (a1, a2, ..., aN) be any sequence (ai1, ai2, ..., aiK), where 1 <= i1 < i2 < ... < iK <= N. For example, sequence (1, 7, 3, 5, 9, 4, 8) has ordered subsequences, e. g., (1, 7), (3, 4, 8) and many others. All longest ordered subsequences are of length 4, e. g., (1, 3, 5, 8). Your program, when given the numeric sequence, must find the length of its longest ordered subsequence.
最长递增子序列 动态规划法.cpp.rar
10-14
C++的课程作业，一个简单的程序，用dev就能直接运行，老师应该不会太仔细检查，糊弄一下肯定没事的，不过最好能自己看懂就是了
DAY52：动态规划（十七）子序列问题：最长递增子序列+最长连续递增序列+最长重复子数组
CFY1226的博客
07-26 628
本题的最大值并不在dp数组末尾，因为每个数据都可能比前面的数字要小。最大长度可能是dp数组中间位置的dp[i]，所以需要建个result存最大值。初始化要注意，本题每个以i为结尾的递增子序列，长度最小是1而不是0！本题难点在于，比较两个数组，得到重复且连续的最长子数组，用一维的DP数组无法同时表示两个数组的状态。我们需要用一个二维的矩阵来比较两个数组的所有状态。dp[0][j]和dp[i][0]的情况都需要单独初始化。
leetcode：300. 最长递增子序列
OceanStar的博客
05-11 2485
题目来源 leetcode：300. longest-increasing-subsequence最长递增子序列 题目描述 题目解析 题意： 需要对「子序列」和「子串」这两个概念进行区分； 子序列（subsequence）：子序列并不要求连续，例如：序列 [4, 6, 5] 是 [1, 2, 4, 3, 7, 6, 5] 的一个子序列； 子串（substring、subarray）：子串一定是原始字符串的连续子串 题目中的「上升」的意思是「严格上升」。反例： [1, 2, 2, 3] 不能算作
最长递增子序列问题（你真的会了吗）
qq_56999918的博客
07-03 8129
1.对应牛客网链接2.题目描述： 3.解题思路下面以[5,7,1,9,4,6,2,8,3]为例：4.对应代码：1.对应牛客网链接：2.题目描述： 3.解题思路：4.对应代码：1.对应letecode链接：2.题目描述：3.解题思路4.对应代码：...
如何给dropdownlist动态赋初始值_动态规划设计方法：归纳思想解决 LIS
weixin_39619635的博客
11-24 367
读完本文，你可以去力扣拿下如下题目：300.最长上升子序列-----------也许有读者看了前文 动态规划详解，学会了动态规划的套路：找到了问题的「状态」，明确了 dp 数组/函数的含义，定义了 base case；但是不知道如何确定「选择」，也就是不到状态转移的关系，依然写不出动态规划解法，怎么办？不要担心，动态规划的难点本来就在于寻找正确的状态转移方程，本文就借助经典的「最长递增子序列问题」...
最长递增子序列
切梦
07-29 4263
问题 给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为6的数组A{5， 6， 7， 1， 2， 8}，则其最长的单调递增子序列为{5，6，7，8}，长度为4. 解法1：最长公共子序列法 这个问题可以转换为最长公共子序列问题。如例子中的数组A{5，6， 7， 1， 2， 8}，则我们排序该数组得到数组A‘{1， 2， 5， 6， 7，...
动态规划——最长递增子序列
白给、少年
02-21 8406
前言 最长递增子序列是动态规划中最经典的问题之一，该问题描述的是在一个已知序列{A1，A2，...,An}中，取出若干元素（不必连续）组成一个新的序列{Ax，...，Ay}，子序列的各个数先后顺序保持不变，且对子序列中的任意下标x<y有Ax<Ay，则称该子序列为原序列的一个递增子序列。最长递增子序列就是原序列的所有递增子序列最长的那个。 思路 令dp[i]表示以A[i]作为末尾的最长递增子序列的长度。于是，通过设置这么一个数组，最长递增子序列的长度便是数组dp中的最大值。 由于dp[i]
动态规划--＞最长递增子序列
qq_45774645的博客
04-23 1090
什么是动态规划？ 通过组合子问题的解来求解原问题的，动态规划对于每一个子子问题只求解一次，将其解保存在一个表格里面，从而无需每次求解一个子子问题时都重新计算，避免了不必要的计算工作，简单的说，动态规划的特征就是，当前状态的转移依赖于与前一个状态。 详细理解动态规划，点击这里，我觉得这位博主讲的很清楚。 下面将力扣中两道动态规划题列举出来，做一下比较。 最长递增子序列 给你一个整数数组nums，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的...
js代码-求最长递增子序列
07-16
js代码-求最长递增子序列
动态规划最长递增子序列
11-20
动态规划最长递增子序列 已经实现 请大家赐教
day2【动态规划】最长的递增子序列
Atticus_zhang的博客
03-29 236
给定一个数组，找出其中最长的递增子序列。 例如，输入如下数组： 返回最长的递增子序列长度是3枚举法的思路是依次从第一个数出发，依次遍历这个数可以到达（符合递增规则）的下一个数。 算法分为两个部分： ① 计算最长递增序列长度LTSLTSLTS，循环数组中的每个数，分别计算从位置iii出发能够得到的最长递增子序列长度记为L[i]L[i]L[i]，LTSLTSLTS = max{L[i]}max\{L[i]\}max{L[i]} ② 计算对于每个位置iii的L[i]L[i]L[i]，依次遍历之后的位置jjj，先判
经典动态规划：最长递增子序列
YSecret_Y的博客
11-13 775
每次处理一张扑克牌不是要找一个合适的牌堆顶来放吗，牌堆顶的牌不是有序吗，这就能用到二分查找了：用二分查找来搜索当前牌应放置的位置。因为10本身是一个，所以是1，9呢又比10小，所以也是1，2比前面的都小，所以也是1,那么5呢？比如说上述的扑克牌最终会被分成这样 5 堆（我们认为纸牌 A 的牌面是最大的，纸牌 2 的牌面是最小的）。,那我们从下标为0的数开始观察，看看有什么规律，为了方便，我们定义一个数组。是什么意思，结合案例我们知道，可以是不连续的，只要大就算。的结果，那么后面的应该是什么呢？
最长递增子序列（LIS）的三种算法
Irimsky
08-16 3748
最长递增子序列：给定一个长度为N的数组，找出一个最长的单调递增子序列，子序列不一定连续，但初始顺序不能乱。 比如数组A={1,3,4,2,5}，其最长递增子序列为1,3,4,5 方法一：最长公共子序列法 对于给定长度为N的数组A： 使数组B为排序后的数组A (O(NlogN)) 求出A与B的最长公共子序列(LCS) (O(N2)) 对求得的公共子序列进行去重 (O(N)...
图解：什么是最长递增子序列？
Z景明的博客
11-26 6521
最长递增子序列 普通动态规划问题解题四步骤 （涉及最优子结构和重叠子问题）基于状态压缩的动态规划解题步骤0-1背包问题在之前的文章中，我已经给大家介绍过了动态规划的常见类型、解题步骤，以...
动态规划设计：最长递增子序列（转载）
ccf19881030的专栏
12-02 664
Letcode刷题 最长递增子序列
最长递增子序列（Longest Increasing Subsequence）
努力中的老周的专栏
05-19 3692
定义 最长上升子序列（Longest Increasing Subsequence，LIS），在计算机科学上是指一个序列中最长的单调递增的子序列。 问题描述 给定一个长度为 N 的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为 5 的数组{5， 6， 1， 2， 8}，则其最长的单调递增子序列为 {5，6，8}，长度为 3。 解法 动态规划 时间复杂度 该方法的时间复杂度为 。 实现过程 下面我们用一个实例来分析一下动态规划求解 LIS 的整个过程。
LeetCode 543.二叉树的直径
最新发布
weixin_62438655的博客
05-01 212
刷leetcode冲冲冲
动态规划最长子序列和最大子段和
11-10
以下是动态规划求解最长子序列和和最大子段和的例子： 1. 最长子序列和 ```python def maxSubArray(nums): """ :type nums: List[int] :rtype: int """ if not nums: return 0 n = len(nums) dp = [0] * n dp[0] = nums[0] for i in range(1, n): dp[i] = max(dp[i-1] + nums[i], nums[i]) return max(dp) ``` 2. 最大子段和 ```python def maxSubArray(nums): """ :type nums: List[int] :rtype: int """ if not nums: return 0 n = len(nums) dp = [0] * n dp[0] = nums[0] for i in range(1, n): dp[i] = max(dp[i-1] + nums[i], nums[i]) return max(dp) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值