最长子序列问题

1、最长递增子序列问题（可以不连续）

a) .使用动态规划，时间复杂度为O(n*n)解法：

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

b）.时间复杂度为O(n*log(n))

int dp[]=new int[nums.length];
		int len=0;
		for(int x:nums){
			int i=Arrays.binarySearch(dp, 0,len,x);
			if(i<0) i=-(i+1);
			dp[i]=x;
			if(i==len) len++;
		}
		return len;

2、最长递增子序列问题（连续子序列）

public static int longest_sequence(int []nums){
		int[] dp=new int[nums.length];
		dp[0]=1;
		for (int i = 1; i < dp.length; i++) {
			dp[i]=1;
			if(nums[i]>nums[i-1])
				dp[i]=dp[i-1]+1;	
		}
		int max=0;
		for(int i=0;i<dp.length;i++){
			if(dp[i]>max)
				max=dp[i];
		}
		return max;
	}

返回所有最长子串的值：

public static LinkedList<LinkedList<Integer>>  longest_sequence(int []nums){
		List<Integer>[] dp=new LinkedList[nums.length];
		dp[0]=new LinkedList<>();
		dp[0].add(nums[0]);
		for (int i = 1; i < dp.length; i++) {
			dp[i]=new LinkedList<>();
			
			if(nums[i]>nums[i-1])
				dp[i].addAll(dp[i-1]);	
			dp[i].add(nums[i]);
		}
		int max=0;
		for(int i=0;i<dp.length;i++){
			if(dp[i].size()>max){
				max=dp[i].size();
			}
		}
		LinkedList<LinkedList<Integer>>res=new LinkedList<>();
		for(int i=0;i<dp.length;i++){
			if(dp[i].size()==max){
				res.add(new LinkedList<>(dp[i]));
			}
		}
		return res;
	}