最长递增子序列

给定数组arr，设长度为n，输出arr的最长递增子序列。（如果有多个答案，请输出其中 按数值(注：区别于按单个字符的ASCII码值)进行比较的 字典序最小的那个）

方法一：使用动态规划
dp[i]表示在i位置上的递增子序列的长度，
状态转移方程if(arr[i]>arr[j]){
dp[i]=Math.max(dp[j]+1,dp[i]);
}
用此方法求出递增子序列，
转移方程： 设 j∈[0,i)j∈[0,i)，考虑每轮计算新 dp[i]dp[i] 时，遍历 [0,i)[0,i) 列表区间，做以下判断：

当 nums[i] > nums[j]时： nums[i]可以接在 nums[j]之后（此题要求严格递增），此情况下最长上升子序列长度为 dp[j] + 1
当 nums[i] <= nums[j]时： nums[i]无法接在 nums[j]之后，此情况上升子序列不成立，跳过。
上述所有 1. 情况 下计算出的 dp[j] + 1的最大值，为直到 i的最长上升子序列长度（即 dp[i]。实现方式为遍历 j时，每轮执行 dp[i] = max(dp[i], dp[j] + 1)。
转移方程： dp[i] = max(dp[i], dp[j] + 1) for j in [0, i)。
初始状态：

dp[i] 所有元素置 11，含义是每个元素都至少可以单独成为子序列，此时长度都为 11。

import java.util.*;

public class LongIncreaseSubList {
    public static void main(String[] args) {
        int[] a={2,1,5,3,6,4,8,9,7};
        int[] result=LIS(a);
        System.out.println(Arrays.toString(result));

    }
    public static int[] LIS (int[] arr) {
        // write code here

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

        }
        System.out.println(max);
        int[] result=new int[max];
        for(int i=arr.length-1,j=max;i>=0&&j>0;i--){
            if(dp[i]==j){
                result[j-1]=arr[i];
                j--;
            }
        }
        return result;

    }
}

方法2：使用二分查找法+动态规划：

public static int[] LIS(int[] arr) {
        int len = 1, n = arr.length;
        if (n == 0)
            return null;
        int[] d = new int[n + 1];
        d[len] = arr[0];
        for (int i = 1; i < n; i++) {
            if(arr[i]>d[len]){
                d[++len]=arr[i];
            }else{
                int l=1,r=len,pos=0;
                while(l<=r){
                    int mid=(l+r)/2;
                    if(d[mid]<arr[i]){
                        l=mid+1;
                        pos=mid;
                    }else{
                        r=mid-1;
                    }

                }
                d[pos+1]=arr[i];
            }

        }
        System.out.println(len);
        int[] result=new int[len];
        int a=0;
        for(int num:d){
            if(num!=0){
                result[a++]=num;
            }
        }
        return result;
    }

数组d表示：
数组 d[i]表示长度为 i 的最长上升子序列的末尾元素的最小值。
在二分查找时，替换掉第一个比arr[i]大的元素。

 public int[] LIS (int[] arr) {
        // write code here
 
        //tails[k]表示长度为k+1的最长递增子序列的末尾元素
        int[] tails = new int[arr.length];
        tails[0] = arr[0];
        int end = 0;
        //记录以当前元素为结尾的最长递增子序列的长度
        int[] maxLen = new int[arr.length];
        Arrays.fill(maxLen, 1);
 
        for (int i = 1; i < arr.length; i++) {
            int left = 0;
            int right = end + 1;
 
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (arr[i] > tails[mid]) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
            tails[left] = arr[i];
            if (left == end + 1) end++;
            if (left + 1 > maxLen[i]) maxLen[i] = left + 1;
        }
 
        int[] res = new int[end + 1];
        for (int i = arr.length - 1, j = res.length; j > 0; i--) {
            if (maxLen[i] == j) {
                res[--j] = arr[i];
            }
        }
 
        return res;
    }