分析记忆化搜索和回溯的代码实现特点

下面是最长递增子序列的记忆化搜索代码实现

class Solution {
    public int[] memo;   //在此处定义memo数组，可以实现全局化


    public int lengthOfLIS(int[] nums) {
        memo = new int[nums.length];
        int max = 0;

        
        for (int i = 0; i < nums.length; i++) {
            max = Math.max(max, dfs(i, nums));     
        }

        for (int i = 0; i < memo.length; i++) {
            System.out.print(memo[i]);
        }

        return max;
    }

    public int dfs(int index, int[] nums) {      //代码随想录中一般使用void即可回溯，但是记 
                                                 //忆化搜索似乎需要返回值
        if (index == nums.length) {
            return 1;
        }

        if (memo[index] != 0) {
            return memo[index];
        }

        int temp = 1;               //个人感觉，回溯和记忆化搜索这里是挺不一样的。
                                    //在回溯中，我们不需要对每次dfs重新进行一次temp初始赋值
        for (int i = index + 1; i < nums.length; i++) {    //不管是回溯还是记忆化搜索都需要 
                                                           //注意i的起始索引，以及每次重新 
                                                           //dfs中的index值的选择
            if (nums[i] > nums[index]) {
                 temp = Math.max(temp, 1 + dfs(i, nums));    
               //temp =  1 + dfs(i, nums);    该句是没办法AC的，按理来说，应该是可以的才对?
            }
        }
        
        memo[index] = temp;
        //System.out.print(temp);
        return temp;
    }
}