Leetcode 300 Longest Increasing Subsequence

思路一： brute force + memorization。一开始没用memorization，就是单纯用recursion来把所有的lis给求了出来，这样做导致tle。后来加了一个数组来memorization就accepted了。这个思路其实也不难，这边直接上代码：

class Solution {
    public int lengthOfLIS(int[] nums) {
        int res = 0;
        int currentRes = 0;
        int[] memo = new int[nums.length]; 
        Arrays.fill(memo,-1);
        for(int i = 0; i < nums.length; i++){
            if(res >= nums.length - i) return res;
            currentRes = subLIS(nums,i+1,memo) + 1;
            res = Math.max(res,currentRes);
        }
        return res;
    }
    
    // recursive method
    private int subLIS(int[] nums, int start, int[] memo){
        int res = 0;
        int pre = nums[start-1];
        for(int i = start; i < nums.length; i++){
            if(nums[i] > pre){
                if(memo[i] != - 1){
                    res = Math.max(res,memo[i]);
                }else{
                    res = Math.max(res,subLIS(nums, i+1,memo) + 1);
                    memo[i] = res;
                }
            }
        }
        return res;
    }
}

思路二： dp。dp[i]的代表的意思是：以下标为index i的数结尾的最长subsequence的长度。这题我还没有搞清楚为什么要赋予dp这个含义，从recursion到dp到底是怎么优化过来的，我所知道的只是这个算法算出来的是对的。所以这边我没办法很好的阐述这个dp算法产生的思路，但是还是可以看这个链接：链接。这个视频将dp算法讲的还是很好的。这边我直接展示代码了：

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

总结：

1. 上面两个算法都是O(n^2)，但是题目要求nlogn，所以这边还有一个最优解，就是用binary search。但是我看了视频还是没看懂，而且我是第一轮刷题，我就不太难为自己了。这边附上nlogn讲解视频链接：链接。这个算法其实有他自己的名字，叫做patience sorting