Leetcode 3040. 相同分数的最大操作数目 II（记忆化搜索）

Leetcode 3040. 相同分数的最大操作数目 II

每次操作给出三种选择，根据三种选择分别进行dfs
超时

class Solution {
    int dfs(int[] nums, int l, int r, int sum){
        if(l >= r)
            return 0;
        int res = 0;
        // 删最前面两个
        if(sum == -1 || nums[l] + nums[l + 1] == sum){
            res = Math.max(res, dfs(nums, l + 2, r, nums[l] + nums[l + 1]) + 1);
        }
        // 删最后面两个
        if(sum == -1 || nums[r - 1] + nums[r] == sum){
            res = Math.max(res, dfs(nums, l, r - 2, nums[r - 1] + nums[r]) + 1);
        }
        // 删前后各一个
        if(sum == -1 || nums[l] + nums[r] == sum){
            res = Math.max(res, dfs(nums, l + 1, r - 1, nums[l] + nums[r]) + 1);
        }
        return res;
    }
    public int maxOperations(int[] nums) {
        int n = nums.length;
        //sum初始化为-1以表示第一次删除
        int res = dfs(nums, 0, n-1, -1);
        return res;
    }
}

---

优化

dfs中有大量重复操作
（如操作删除0、1删除n-1、n-2和操作删除0、n-1删除1、n-2，这两种操作后的剩余区间是相同的）

使用memo[ n ][ n ]数组记录已经进行过的计算，memo[ l ][ r ]表示 l 和 r 区间的最大操作数，若这个区间的最大操作数已经存在，则无需再次dfs下去，直接获取memo值即可
若该区间memo不存在，则dfs后将值存入memo[ l ][ r ]

class Solution {
    int[][] memo; // 记忆化数组

    int dfs(int[] nums, int l, int r, int sum) {
        if(l >= r)
            return 0;
        if(memo[l][r] != -1) // lr区间已经计算过
            return memo[l][r];
        int res = 0;
        // 删最前面两个
        if(nums[l] + nums[l + 1] == sum){
            res = Math.max(res, dfs(nums, l+2, r, sum) + 1);
        }
        // 删最后面两个
        if(nums[r - 1] + nums[r] == sum){ 
            res = Math.max(res, dfs(nums, l, r-2, sum) + 1);
        }
        // 删前后各一个
        if(nums[l] + nums[r] == sum){
            res = Math.max(res, dfs(nums, l+1, r-1, sum) + 1);
        }
        // 更新memo
        memo[l][r] = res;
        return res;
    }

    public int maxOperations(int[] nums) {
        int n = nums.length;
        memo = new int[n][n];
        int res = 0;
        // memo初始化-1表示未计算
        for (int i = 0; i < n; i++) {
            Arrays.fill(memo[i], -1);
        }
        res = Math.max(res, dfs(nums, 2, n - 1, nums[0] + nums[1]));
		// 起始的三种选择sum可能不同，将memo重置
        for (int i = 0; i < n; i++) {
            Arrays.fill(memo[i], -1);
        }
        res = Math.max(res, dfs(nums, 0, n - 3, nums[n - 2] + nums[n - 1]));

        for (int i = 0; i < n; i++) {
            Arrays.fill(memo[i], -1);
        }
        res = Math.max(res, dfs(nums, 1, n - 2, nums[0] + nums[n - 1]));

		// res为三种选择之后的操作数，返回值应为第一次操作+1
        return res+1;
    }
}