【力扣】最长递增子序列

一、题目描述

二、解题方法

1、使用递归(暴搜)+ 记忆化搜索

算法思路:

暴搜:
  1. 递归含义:dfs递归函数的作用,给他⼀个数 i ,返回以 i 位置为起点的最长递增子序列的长度;
  2. 函数体: 遍历 i 后面的所有位置,看看谁能加到 i 这个元素的后面(即看看谁能满足题目要求:递增的子序列)。 统计所有情况下的最大值
  3. 递归出口: 因为我们是判断之后再进入递归的,因此没有出口。
记忆化搜索:
  1. 加上⼀个备忘录(本题只需一个一维数组,如在递归返回前,用memo[i]来存放以 i 位置为起点的最长递增子序列的长度);
  2. 每次进入递归的时候,去备忘录里面看看;
  3. 每次返回的时候,将结果加入到备忘录里面。

2、递归(暴搜)+ 记忆化搜索 转为 动态规划

  1. 递归含义 -> 状态表示;
  2. 函数体 -> 状态转移方程;
  3. 递归出口 -> 初始化。

三、代码

1、使用递归(暴搜)+ 记忆化搜索

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] memo = new int[n];
        int ret = 0;
        for(int i = 0; i < n; i++) {
            ret = Math.max(ret, dfs(i,nums,memo));
        }
        return ret;
    }
    public int dfs(int pos, int[] nums, int[] memo) {
        if(memo[pos] != 0) {
            return memo[pos];
        }
        int ret = 1;
        for(int i = pos + 1; i < nums.length; i++) {
            if(nums[i] > nums[pos]) {
                ret = Math.max(ret, dfs(i,nums,memo) + 1);
            }
        }
        memo[pos] = ret;
        return ret;
    }
}

 2、动态规划

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

 

上面的动态规划代码是以 i 位置为起点的。

下面我们来看一下,以 i 位置为终点的动态规划代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        for(int i = 0; i < n; i++) {
            dp[i] = 1;
        }
        int ret = 0;
        for(int i = 1; i < n; i++) {
            for(int j = 0; j < i; j++) {
                if(nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[j] + 1, dp[i]);
                }
            } 
            ret = Math.max(ret, dp[i]);
        }
        //ret只是dp[i]~dp[n-1]的最大值,还要跟dp[0]比较一下
        return ret > dp[0] ? ret : dp[0];  
    }
}

LeetCode力扣)上,有一个经典的算法题目叫做“最长连续序列”(Longest Continuous Increasing Subsequence),通常用C++或其他编程语言进行解答。这个题目的目的是找到一个给定整数数组中的最长递增子序列。递增子序列是数组中的一段连续元素,它们按顺序严格增大。 这里是一个简单的C++解决方案思路: ```cpp #include <vector> using namespace std; class Solution { public: int longestContinuousIncreasingSubsequence(vector<int>& nums) { if (nums.empty()) return 0; // 避免空数组的情况 int n = nums.size(); vector<int> dp(n, 1); // dp[i] 表示以nums[i]结尾的最长递增子序列长度 int max_len = 1; // 初始化最长递增子序列长度为1 for (int i = 1; i < n; ++i) { // 遍历数组,从第二个元素开始 if (nums[i] > nums[i-1]) { // 如果当前元素比前一个大 dp[i] = dp[i-1] + 1; // 更新dp值,考虑加入当前元素后的增长长度 max_len = max(max_len, dp[i]); // 检查是否更新了最长子序列长度 } } return max_len; // 返回最长连续递增子序列的长度 } }; ``` 在这个代码中,我们使用了一个动态规划(Dynamic Programming)的方法,维护了一个数组`dp`来存储每个位置以该位置元素结尾的最大递增子序列长度。遍历过程中,如果遇到当前元素大于前一个元素,则说明可以形成一个新的递增子序列,所以将`dp[i]`设置为`dp[i-1]+1`,并更新全局的最长子序列长度。 如果你想要深入了解这个问题,可以问: 1. 这个问题的时间复杂度是多少? 2. 动态规划是如何帮助解决这个问题的? 3. 如何优化这个算法,使其空间复杂度更低?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值