记忆化搜索系列一＞最长递增子序列

题目思路：

递归代码设计：

改为记忆化搜索：

代码呈现：

class Solution {
    public int lengthOfLIS(int[] nums) {
        //记忆化搜索：
        int ret = 0;
        n = nums.length;
        memo = new int[n];
        Arrays.fill(memo,-1);

        for(int i = 0; i < n; i++){
            ret = Math.max(dfs(i,nums),ret);
        }
        return ret;
    }
    int n;
    int[] memo;

    private int dfs(int pos, int[]nums){
        if(memo[pos] != -1){
            return memo[pos];
        }

        int ret = 1;//pos可能为最后一个位置，所以垫个1
        for(int i = pos+1; i < n; i++)
            if(nums[i] > nums[pos])
                ret = Math.max(dfs(i,nums)+1,ret);
        
        memo[pos] = ret;
        return ret;   
    }
}

记忆化搜索改动态规划版本：

class Solution {
    public int lengthOfLIS(int[] nums) {

        //记忆化搜索改动态规划：
        int n = nums.length;
        int ret = 1; 
        int[] dp = new int[n];
        Arrays.fill(dp,1);
        for(int i = n-1; i >= 0; i--)
            for(int j = i+1; j < n; j++){
                if(nums[j] > nums[i])
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                ret = Math.max(ret,dp[i]);
            }
            System.out.println("ret "+ ret);
        return ret;    

    }

}