目标
给你一个整数数组 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
思路
比 相同分数的最大操作数目I 增加了两种操作，可以删除最后两个元素或者一前一后两个元素。
我的思路是使用回溯算法，为了防止环的形成，使用自定义hash函数 (long) start << 16 | end; 记录已经搜索过的区间，并存入哈希表。
勉强通过了，看了官网题解，说是要用记忆搜索。网友还给出了递推的解法。//todo
代码
/**
* @date 2024-06-08 20:03
*/
public class MaxOperations3040 {
private Set<Long> set;
public int maxOperations(int[] nums) {
int res = 0;
int n = nums.length;
set = new HashSet<>();
set.add(n - 1L);
res = dfs(nums, 2, n - 1, nums[0] + nums[1], 1);
res = Math.max(res, dfs(nums, 0, n - 3, nums[n - 2] + nums[n - 1], 1));
res = Math.max(res, dfs(nums, 1, n - 2, nums[0] + nums[n - 1], 1));
return res;
}
public int dfs(int[] nums, int start, int end, int target, int ops) {
int res = ops;
long key = (long) start << 16 | end;
if (set.contains(key) || start >= end || res == nums.length / 2) {
return res;
}
set.add(key);
if (start < nums.length - 1 && nums[start] + nums[start + 1] == target) {
res = dfs(nums, start + 2, end, target, ops + 1);
}
if (end >= 1 && nums[end] + nums[end - 1] == target) {
res = Math.max(res, dfs(nums, start, end - 2, target, ops + 1));
}
if (end >= 0 && start < nums.length && nums[start] + nums[end] == target) {
res = Math.max(res, dfs(nums, start + 1, end - 1, target, ops + 1));
}
return res;
}
}
性能
