算法-动态规划-最长上升子序列

算法-动态规划-最长上升子序列

1 题目概述

1.1 题目出处

https://leetcode-cn.com/problems/longest-increasing-subsequence/

1.2 题目描述

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。

进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

2 动态规划

2.1 思路

如果设dp[i]表示前i个的最长上升子序列长度，那么很难找到他和dp[i-1]等的关系。

而考虑设dp[i]表示以下标i的数字结尾的上升子序列最大长度， 则:

dp[i] = max(dp[0],dp[1],dp[2],...dp[j]...,dp[i-1]) + 1
且 nums[j] < nums[i]

2.2 代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        // 全局最长上升子序列长度
        int result = 0;
        if(null == nums || nums.length == 0){
            return 0;
        }

        // 如果设dp[i]表示前i个的最长上升子序列长度
        // 那么很难找到他和dp[i-1]等的关系
        
        // 考虑设dp[i]表示以下标i的数字结尾的上升子序列最大长度
        // 则dp[i] = max(dp[0],dp[1],dp[2],...dp[j]...,dp[i-1]) + 1，且 nums[j] < nums[i]
        int[] dp = new int[nums.length];
        
        for(int i = 0; i < nums.length; i++){
            // 以nums[i]结尾的最长上升子序列长度
            int tmpMax = 0;
            for(int j = i - 1; j >= 0; j--){
                if(nums[j] < nums[i]){
                    tmpMax = Math.max(tmpMax, dp[j]);
                }
            }
            // 最小长度是1，也就是说前面的数都不小于nums[i]，则nums[i]本身组成一个长度为1的子序列
            dp[i] = tmpMax + 1;
            // 如果比全局更长就更新
            result = Math.max(result, dp[i]);
        }
        return result;
    }
}

2.3 时间复杂度

O(N^2)

2.4 空间复杂度

O(N)

3 有序数组+二分查找

3.1 思路

目标将算法的时间复杂度降低到 O(n log n) ，那么能想到的是二分或者归并之类的。

但是数组本身无需，要找最长上升子序列，不可能先排序再找吧？

而dp[i]也是无序的，也无法使用二分查找。

有一种思路，使用一个有序数组。当遍历到一个元素大于该数组的尾元素（最大的），就放置在末尾；否则就使用二分查找，如果找到就不动，找不到就替换比目标元素大的右边那个元素。这样替换的依据是，已经用末尾最大元素限制了长度，更小的元素只能替换而不能增加该序列长度！

这样的好处是，该有序数组长度就表示了最长上升子序列长度，而且复杂度优化到O(NlogN)！

3.2 代码

3.2.1 递归版本

class Solution {
    private List<Integer> resultList = new ArrayList<>();
    public int lengthOfLIS(int[] nums) {
        // 全局最长上升子序列长度
        int result = 0;
        if(null == nums || nums.length == 0){
            return 0;
        }

        
        resultList.add(nums[0]);
        for(int i = 1; i < nums.length; i++){
            if(nums[i] > resultList.get(resultList.size() - 1)){
                resultList.add(nums[i]);
            }else{
                binaryInsert(nums[i], 0, resultList.size() - 1);
            }
        }
        return resultList.size();
    }

    private void binaryInsert(int target, int start, int end){
        int mid = (start + end) / 2;
        if(resultList.get(mid) == target){
            return;
        } else if(resultList.get(mid) < target){
            if(mid == end){
                // 因为我们已经提前判断过target大于数组尾元素情况，
                // 所以这里不会出现end+1不存在的情况
                resultList.set(end + 1, target);
            }else{
                binaryInsert(target, mid + 1, end);
            }
        }else{
            // resultList.get(mid) > target
            if(mid == start){
                resultList.set(mid, target);
            }else{
                binaryInsert(target, start, mid - 1);
            }
        }
    }
}

3.2.2 循环版本

class Solution {
    private List<Integer> resultList = new ArrayList<>();
    public int lengthOfLIS(int[] nums) {
        // 全局最长上升子序列长度
        int result = 0;
        if(null == nums || nums.length == 0){
            return 0;
        }

        resultList.add(nums[0]);
        for(int i = 1; i < nums.length; i++){
            if(nums[i] > resultList.get(resultList.size() - 1)){
                resultList.add(nums[i]);
            }else{
                int left = 0;
                int right = resultList.size() - 1;
                while(left <= right){
                    int mid = left + (right - left) / 2;
                    if(resultList.get(mid) == nums[i]){
                        // 相同值的忽略
                        break;
                    } else if (resultList.get(mid) < nums[i]){
                        left = mid + 1;
                    } else if (resultList.get(mid) > nums[i]){
                        right = mid - 1;
                    }
                }
                // right == left时，resultList.get(mid) > nums[i]
                // 不可能resultList.get(mid) < nums[i]
                // 因为我们提前判断了nums[i] > resultList.get(resultList.size() - 1)
                // 所以这里我们将目标数字放在left位置即可
                if(right < left){
                    resultList.set(left, nums[i]);
                }
            }
        }
        return resultList.size();
    }
}

3.3 时间复杂度

3.3.1 递归版本

O(NlogN)

3.3.2 循环版本

O(NlogN)

3.4 空间复杂度

O(K)

• 取决于最长子序列长度K