最长递增子序列的动态规划的求解二（二分查找优化）

1. 问题描述：求解最长递增子序列的长度

输入：第一行输入的是数组的长度 

第二行开始输入的是数组中的元素

输出：最长递增子序列的长度

输入 4 2 3 1 5 6 

输出 4 （因为 2 3 5 6组成了最长递增子序列）

2. 之前我们使用动态规划解决的思路是：dp[i]表示的是长度为i的最长递增子序列的末尾的那个数，在求解的过程中需要在dp数组中找出第一个大于arr[i]的的下标，因为dp数组的元素都是递增的，所以我们可以使用二分查找的方法来降低时间复杂度

3. 优化之后的时间复杂度为：O(nlgn)， 具体的代码如下：

import java.util.Scanner;
public class Main{
    //测试数据10 4 2 3 1 5 6 4 8 5 9
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int arr[] = new int[n];
        for(int i = 0; i < n; i++){
            arr[i] = sc.nextInt();
        }
        System.out.println(solution(arr));
        sc.close();
    }
    private static int solution(int[] arr){
        int dp[] = new int[arr.length + 1];
        dp[1] = arr[0];
        int p = 1;
        for(int i = 1; i < arr.length; i++){
            if(arr[i] > dp[p]){
                dp[++p] = arr[i];
            }else{
                //使用二分查找第一个大于arr[i]的下标
                int index = indexOfFirstBigger(0, p, dp, arr[i]);
                //进行元素的替换
                dp[index] = arr[i];
            }
        }
        return p;
    }
    //二分查找
    private static int indexOfFirstBigger(int low, int high, int dp[], int k){
        if(low >= high) return low;
        int mid = (low + high) >> 1;
        int midVal = dp[mid];
        if(low < high && midVal <= k){
            return indexOfFirstBigger(mid + 1, high, dp, k);
        }else{
            return indexOfFirstBigger(low, mid, dp, k);
        }
    }
}