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

给你一个整数数组 nums ，如果 nums 至少 包含 2 个元素，你可以执行以下操作中的 任意 一个：

选择 nums 中最前面两个元素并且删除它们。

 ·选择 nums 中最后两个元素并且删除它们。

 ·选择 nums 中第一个和最后一个元素并且删除它们。

一次操作的 分数 是被删除元素的和。

在确保 所有操作分数相同 的前提下，请你求出 最多 能进行多少次操作。

请你返回按照上述要求 最多 可以进行的操作次数。

示例 1：

输入：nums = [3,2,1,2,3,4]
输出：3
解释：我们执行以下操作：
- 删除前两个元素，分数为 3 + 2 = 5 ，nums = [1,2,3,4] 。
- 删除第一个元素和最后一个元素，分数为 1 + 4 = 5 ，nums = [2,3] 。
- 删除第一个元素和最后一个元素，分数为 2 + 3 = 5 ，nums = [] 。
由于 nums 为空，我们无法继续进行任何操作。

示例 2：

输入：nums = [3,2,6,1,4]
输出：2
解释：我们执行以下操作：
- 删除前两个元素，分数为 3 + 2 = 5 ，nums = [6,1,4] 。
- 删除最后两个元素，分数为 1 + 4 = 5 ，nums = [6] 。
至多进行 2 次操作。

提示：

 ·2 <= nums.length <= 2000

 ·1 <= nums[i] <= 1000

题目大意：在规定可执行三种操作且每次操作结果相同的情况下计算最多可操作的次数。

分析：

（1）假设当操作的结果只能为k时，设dp[i][j]为数组arr[i:j]最多可执行结果为k的操作的次数。则当arr[i]+arr[i+1]=k时，dp[i][j]=max(dp[i][j],dp[i+2][j]+1)；当arr[j]+arr[j-1]==k时，dp[i][j]=max(dp[i][j],dp[i][j-2]+1)；当arr[i]+arr[j]=k时，dp[i][j]=max(dp[i][j],dp[i+1][j-1]+1)；

（2）由（1）可知，可枚举k=nums[0]+nums[1]、k=nums[N-1]+nums[N-2]、k=nums[0]+nums[N-1]三种情况，并计算每种情况下dp[i][j-1]的值，最终结果即为dp[i][j-1]在三种情况下的最大值；

（3）由dp数组的定义可知，dp[i][j]=dp[j][i]，因此可将二维数组dp压缩成长度为(1+N)*N/2的一维数组dp，节省一半的存储空间，其中二维数组下标i、j在一维数组中的下标为(1+j)*j/2+i。

class Solution {
public:
    vector<int> dp;
    int tar;
    bool finish;
    int dfs(int i,int j,vector<int>& nums){
        if(finish) return 0;
        if(i>=j){
            finish=true;
            return 0;
        }
        int id=(1+j)*j/2+i,ans=0;
        if(dp[id]>=0) return dp[id];
        if(nums[i]+nums[i+1]==tar) ans=max(ans,dfs(i+2,j,nums)+1);
        if(nums[j]+nums[j-1]==tar) ans=max(ans,dfs(i,j-2,nums)+1);
        if(nums[i]+nums[j]==tar) ans=max(ans,dfs(i+1,j-1,nums)+1);
        dp[id]=ans;
        return ans;
    }
    int maxOperations(vector<int>& nums) {
        int N=nums.size(),L=(1+N)*N/2;
        
        dp=vector<int>(L,-1);tar=nums[0]+nums[1];finish=false;
        int ans1=dfs(2,N-1,nums);
        
        dp=vector<int>(L,-1);tar=nums[0]+nums[N-1];finish=false;
        int ans2=dfs(1,N-2,nums);
        
        dp=vector<int>(L,-1);tar=nums[N-2]+nums[N-1];finish=false;
        int ans3=dfs(0,N-3,nums);
        
        return max({ans1,ans2,ans3})+1;
    }
};