leetcode解题300.最长递增序列长度

题目连接

题目描述

Given an unsorted array of integers, find the length of longest increasing subsequence.

Example:

Input: [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
要求：严格单调递增,只有这种情况才进行增加元素的情况
子序列：可以不连续，结果序列中两个元素中间可以有空格
视频讲解

解题思路

解法1.一维动态规划，两次循环，逐步记录最大值

• dp[i] = max{ dp[j] +1 } if ( n[j] < n[i]) )
• dp[i] = 1, if all n[j]>=n[i], 表示i 之前的元素均大于或者等于 i，增长序列为n[i] 单独一个元素作为一个增长序列。
• dp[i]表示以下表i为尾的最长的递增序列,还需要一个max记录所有的dp[i]中的最大值，处理完第i个数字后，如果 dp[i]>max, 则需要更新最大值，否则max还是保持原来的最大值。

代码（Java版本）

import java.util.Arrays;
public class LongestIncreasingSubsequence {
    public int solution(int [] nums)
    {
        int n = nums.length;
        if(n==0) return 0;
        if(n==1) return 1;
        int max = 1;
        int [] dp =new int[n];
        Arrays.fill(dp,1);
        dp[0] =1;
        for(int i=1;i<n;++i){
            for(int j=i-1;j>=0;--j)
            {
                if(nums[j]<nums[i])
                {
                    //因为要求一个增长序列，u=
                   // 状态转移方程dp[i]在前面选择一个num[j]<nums[i],总多条件中选择一个·满足题意的max 的j,然后加i
                    dp[i] = Math.max(dp[j]+1,dp[i]);
                }
                //如果一个元素找不到一个比他任何一个比他小的元素，那么以这个元素为nums[i] 为尾巴的增长序列只能为1，自己本身
                
                }

            max = Math.max(max,dp[i]);

        }
        return max;
    }

    public static void main(String[] args) {
        LongestIncreasingSubsequence test = new LongestIncreasingSubsequence();
        int [] array = {10,9,2,5,3,7,101,18};
        System.out.println(test.solution(array));
    }
}

性能分析

时间复杂度为o(n^2),两次循环，外部循环为顺序处理每一个元素，第二次循环为逆序前向查找满足题意的曾长序列；空间复杂度为o(n),一个状态方程记录数组。

解法二：二分查找

思路

设置一个数组dp[]，用于二分查找，逐步遍历原数组n[i]，对于每一个遍历到的原数组元素，我们采用二分查找方法查找他在dp有序数组中的位置，在dp数组中采用二分查找一个不小于n[i]的数，如果这个数字不存在，那么直接在dp数组后面加上遍历到的数字，如果存在，则将这个数字更新为当前遍历到的数字，最后返回

代码

 int[] dp = new int[n.length];
    int size = 0;
    for (int x : n) {
        int i = 0, j = size;
        while (i != j) {
            int m = (i + j) / 2;
            if (dp[m] < x)
                i = m + 1;
            else
                j = m;
        }
        dp[i] = x;
        if (i == size) ++size;
    }
    return size;
}

代码解析：刚开始dp数组为空，size为数组dp的长度，将x加入到dp数组中，

性能分析

每一个元素均需要进行一个二分查找，二分查找每一趟是Olog(n),共有n次，所以总的时间复杂度为o(nlog(n)),空间复杂度为o(n)

二分查找的分析理解

B [size]数组当中的元素长度优势有序的情况

可以利用O(N),记录当前最长的数组序列即可，B[size],记录处理到A[i]处元素的最长递增序列， 如果A[i]>B[size] 说明可以直接添加即可 B[size] = A[i]是该种情况， 如果A[i]<B[size]， 我们就要在B[size] 数组当中查找一个位置直接将A[i] 插入该节点，进行一个替

B[j] 记录到底代表什么意思呢，我们可以这样理解， 主要是用来记录， 序列长度最长为j的最末尾元素为B[j]

最长递增子序列__牛客网

代码

class Solution {
    public int lengthOfLIS(int[] A) {
        if(A==null||A.length==0)
            return 0;
        int length = A.length;
        int[] B = new int[length];
        B[0] = A[0];
        int end = 0;
        for (int i = 1; i < length; ++i) {
            // 如果当前数比B中最后一个数还大，直接添加
            if (A[i] > B[end]) { B[++end] = A[i]; continue;
            }
            // 否则，需要先找到替换位置
        int pos = findInsertPos(B, A[i], 0, end);
        B[pos] = A[i];
        }
        /
        return end+ 1;
    }

    private int findInsertPos(int[] B, int n, int start, int end) {
        while (start < end) {
            int mid = start + (end - start) / 2;// 直接使用(high + low) / 2 可能导致溢出
            if (B[mid] < n) {
                start = mid + 1;
            } else if (B[mid] > n) {
                end = mid ;
            } else {
                return mid;
            }
        }
        return start;
    }
}