动态规划最长递增子序列

最长递增子序列的动态规划与贪心解法

原创于 2025-07-02 10:13:39 发布 · 447 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #算法

算法专栏收录该内容

385 篇文章

订阅专栏

300. 最长递增子序列

问题描述

给定一个整数数组 nums，找到其中最长严格递增子序列的长度。子序列不要求连续。

示例：

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

算法思路

方法一：动态规划（O(n²)）

状态定义：
- dp[i]：以 nums[i] 结尾的最长递增子序列长度
状态转移：
- 对于每个 i，遍历 j 从 0 到 i-1：
  - 若 nums[j] < nums[i]，则 dp[i] = max(dp[i], dp[j] + 1)
初始化：
- 所有 dp[i] = 1（至少包含自身）
结果：
- dp 数组的最大值

方法二：贪心 + 二分查找（O(n log n)）

维护数组：
- tail[k]：长度为 k+1 的递增子序列的最小末尾值
遍历规则：
- 若 nums[i] > tail 末尾元素：追加到 tail
- 否则：二分查找第一个 ≥ nums[i] 的位置并替换
结果：
- tail 数组的长度即为答案

代码实现

方法一：动态规划（DP 数组）

class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        
        int n = nums.length;
        int[] dp = new int[n];  // dp[i] 表示以 nums[i] 结尾的最长递增子序列长度
        int maxLen = 1;         // 至少有一个元素
        
        // 初始化：每个元素自身构成长度为1的子序列
        for (int i = 0; i < n; i++) {
            dp[i] = 1;
        }
        
        // 动态规划
        for (int i = 1; i < n; i++) {
            // 检查 i 之前的所有元素
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    // 如果 nums[j] < nums[i]，则可以接在 nums[j] 后面形成更长的子序列
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            // 更新全局最大值
            maxLen = Math.max(maxLen, dp[i]);
        }
        
        return maxLen;
    }
}

方法二：贪心 + 二分查找

class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        
        // tail[k] 表示长度为 k+1 的递增子序列的最小末尾值
        int[] tail = new int[nums.length];
        int len = 0;  // 当前最长递增子序列长度
        
        for (int num : nums) {
            // 二分查找：在 tail[0..len-1] 中找到第一个 ≥ num 的位置
            int left = 0, right = len;
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (tail[mid] < num) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
            
            // 如果找到位置 left，替换该位置的值
            tail[left] = num;
            
            // 如果替换位置是末尾，则序列长度增加
            if (left == len) {
                len++;
            }
        }
        
        return len;
    }
}

算法分析

方法	时间复杂度	空间复杂度	特点
DP	O(n²)	O(n)	适合小规模数据
贪心	O(n log n)	O(n)	适合大规模数据

算法过程

输入：nums = [10,9,2,5,3,7,101,18]
方法二执行过程：

num=10: tail=[10]           len=1
num=9:  tail=[9]            len=1 (替换10)
num=2:  tail=[2]            len=1 (替换9)
num=5:  tail=[2,5]          len=2 (追加)
num=3:  tail=[2,3]          len=2 (替换5)
num=7:  tail=[2,3,7]        len=3 (追加)
num=101: tail=[2,3,7,101]   len=4 (追加)
num=18:  tail=[2,3,7,18]    len=4 (替换101)
结果：4

测试用例

public static void main(String[] args) {
    Solution solution = new Solution();
    
    // 测试用例1: 标准示例
    int[] nums1 = {10,9,2,5,3,7,101,18};
    System.out.println("Test 1: " + solution.lengthOfLIS(nums1)); // 4
    
    // 测试用例2: 完全逆序
    int[] nums2 = {5,4,3,2,1};
    System.out.println("Test 2: " + solution.lengthOfLIS(nums2)); // 1
    
    // 测试用例3: 完全升序
    int[] nums3 = {1,2,3,4,5};
    System.out.println("Test 3: " + solution.lengthOfLIS(nums3)); // 5
    
    // 测试用例4: 单个元素
    int[] nums4 = {5};
    System.out.println("Test 4: " + solution.lengthOfLIS(nums4)); // 1
    
    // 测试用例5: 空数组
    int[] nums5 = {};
    System.out.println("Test 5: " + solution.lengthOfLIS(nums5)); // 0
    
    // 测试用例6: 存在多个LIS
    int[] nums6 = {1,3,5,4,7};
    System.out.println("Test 6: " + solution.lengthOfLIS(nums6)); // 4
}