程序员代码面试指南刷题--第四章.最长递增子序列

题目描述
给定数组arr，设长度为n，输出arr的最长递增子序列。（如果有多个答案，请输出其中字典序最小的）
输入描述:

输出两行，第一行包括一个正整数n（n<=100000），代表数组长度。第二行包括n个整数，代表数组arr

输出描述:

输出一行。代表你求出的最长的递增子序列。

示例1

输入

9
2 1 5 3 6 4 8 9 7

输出

1 3 4 8 9

示例2

输入

5
1 2 8 6 4

输出

1 2 4

说明

其最长递增子序列有3个，（1，2，8）、（1，2，6）、（1，2，4）
其中第三个字典序最小，故答案为（1，2，4）

解法一：动态规划

import java.io.*;
import java.util.*;
public class Main{
     
    public static void main(String[] args) throws Exception{
     
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int len = Integer.parseInt(br.readLine());
        String[] ss = br.readLine().trim().split(" ");
        int[] arr = new int[len];
        for(int i=0;i<len;i++){
     
            arr[i] = Integer.parseInt(ss[i]);
        }
        int[] dp = getdp(arr);
        int[] res = getRes(arr,dp);
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<res.length;i++){
     
            sb.append(res[i]+" ");
        }
        System.out.println(sb.toString().trim());
    }
    public static int[] getRes(int[] arr,int[] dp){
     
        if(arr==null||arr.length==0) return null;
        if(arr.length==1) return new int[]{
     arr[0]};
        int max = 0;
        for(int i=1;i<dp.length;i++){
     
            if(dp[i]>dp[max]){
     
                //找到第一个max
                max = i;
            }
        }
        int[] res = null;
        for(int i=max;i<dp.length;i++){
     
            if(dp[i]==dp[max]){
     
                int[] tmp = getOneRes(arr,dp,i); 
                if(res==null){
     
                    res = tmp;
                }else{
     
                    //字典序
                    for(int j=0;j<res.length;j++){
     
                        if(res[j]>tmp[j]){
     
                            res = tmp;
                        }
                    }
                }
            }
        }
        
       return res;
    }
    public static int[] getOneRes(int[] arr,int[] dp,int max){
     
        int len = dp[max];
        int[] res = new int[len];
        res[--len] = arr[max];
        for(int i=max-1;i>=0;i--){
     
            if(arr[i]<arr[max]&&dp[i]==dp[max]-1){
     
                max = i;
                res[--len] = arr[max];
            }
        }
        return res;
    }
    public static int[] getdp(int[] arr){
     
        int[] dp = new int[arr.length];
        int[] ends = new int[arr.length];
        ends[0] = arr[0];
        dp[0] = 1;
        int right = 0;
        int l = 0;
        int r = 0;
        int m = 0;
        for(int i=1;i<arr.length;i++){
     
            l=0;
            r=right;
            while(l<=r){
     
                m = (l+r)/2;
                if(arr[i]>ends[m]){
     
                    l = m+1;
                }else{
     
                    r = m-1;
                }
            }
            right = Math.max(right,l);
            ends[l] = arr[i];
            dp[i] = l+1;
        }
        return dp;
    }
    //会超时
    public static int[] getdp1(int[] arr){
     
        if(arr==null||arr.length==0) return null;
        int[] dp = new int[arr.length];
        for(int i=0;i<arr.length;i++){
     
            dp[i] = 1;
            for(int j=0;j<i;j++){
     
                if(arr[i]>arr[j]){
     
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
        }
        return dp;
    }
}