【LeetCode：3117】划分数组得到最小的值之和（Java）

题目链接

• 3117. 划分数组得到最小的值之和

题目描述

给你两个数组 nums 和 andValues，长度分别为 n 和 m。

数组的 值 等于该数组的 最后一个 元素。

你需要将 nums 划分为 m 个 不相交的连续
子数组
，对于第 ith 个子数组 [li, ri]，子数组元素的按位 AND 运算结果等于 andValues[i]，换句话说，对所有的 1 <= i <= m，nums[li] & nums[li + 1] & … & nums[ri] == andValues[i] ，其中 & 表示按位 AND 运算符。

返回将 nums 划分为 m 个子数组所能得到的可能的 最小 子数组 值 之和。如果无法完成这样的划分，则返回 -1 。

示例 1：

输入： nums = [1,4,3,3,2], andValues = [0,3,3,2]

输出： 12

解释：

唯一可能的划分方法为：

[1,4] 因为 1 & 4 == 0
[3] 因为单元素子数组的按位 AND 结果就是该元素本身
[3] 因为单元素子数组的按位 AND 结果就是该元素本身
[2] 因为单元素子数组的按位 AND 结果就是该元素本身
这些子数组的值之和为 4 + 3 + 3 + 2 = 12

示例 2：

输入： nums = [2,3,5,7,7,7,5], andValues = [0,7,5]

输出： 17

解释：

划分 nums 的三种方式为：

[[2,3,5],[7,7,7],[5]] 其中子数组的值之和为 5 + 7 + 5 = 17
[[2,3,5,7],[7,7],[5]] 其中子数组的值之和为 7 + 7 + 5 = 19
[[2,3,5,7,7],[7],[5]] 其中子数组的值之和为 7 + 7 + 5 = 19
子数组值之和的最小可能值为 17

示例 3：

输入： nums = [1,2,3,4], andValues = [2]

输出： -1

解释：

整个数组 nums 的按位 AND 结果为 0。由于无法将 nums 划分为单个子数组使得元素的按位 AND 结果为 2，因此返回 -1。

提示：

1 <= n = nums.length <= 10⁴
1 <= m = andValues.length <= min(n, 10)
1 <= nums[i] < 10⁵
0 <= andValues[j] < 10⁵

求解思路

• 通过深搜求解：res记录每次匹配得到的结果，dfs()方法中，i表示nums中下一个元素的下标，j表示andValues数组中下一个匹配元素下标，cur表示当前子数组进行与运算得到的结果。
• 设置递归的边界：
  1. 如果i和j同时走到尽头，则直接返回。
  2. 如果i或j其中一个走到尽头，说明匹配失败，返回INF。
  3. 如果当前的键key存在，则返回键映射的结果。
  4. 对当前结果进行下一次的与运算之后，如果得到的值小于andValues的对应值，后面再如何做与运算也不会变大，所以直接返回INF。
  5. 如果得到的值不小于andValues的对应值，可以尝试做下一步的匹配。
  6. 如果当前结果与andValues的对应结果相等，则选择较小的结果进行存储。

实现代码

class Solution {
    private static final int INF = (1 << 30) - 1;
    private HashMap<Integer, Integer>[] res;

    public int minimumValueSum(int[] nums, int[] andValues) {
        int n = nums.length, m = andValues.length;
        res = new HashMap[n * m];
        for (int i = 0; i < m * n; i ++) {
            res[i] = new HashMap<Integer, Integer>();
        }
        int ans = dfs(0, 0, INF, nums, andValues);
        return ans < INF ? ans : -1;
    }

    //i表示nums中下一个元素，j表示andValues中下一个匹配元素，cur表示当前子数组运算结果
    public int dfs(int i, int j, int cur, int[] nums, int[] andValues) {
        int n = nums.length, m = andValues.length, key = i * m + j;
        if (i == nums.length && j == andValues.length) {
            return 0;
        }
        if (i == nums.length || j == andValues.length) {
            return INF;
        }
        if (res[key].containsKey(cur)) {
            return res[key].get(cur);
        }
        cur &= nums[i];
        if ((cur & andValues[j]) < andValues[j]) {
            return INF;
        }
        int ans = dfs(i + 1, j, cur, nums, andValues);
        if (cur == andValues[j]) {
            ans = Math.min(ans, dfs(i + 1, j + 1, INF, nums, andValues) + nums[i]);
        }
        res[key].put(cur, ans);
        return ans;
    }
}