力扣35周双周赛5504使数组和能被 P 整除

使数组和能被 P 整除

题目连接

一、题目描述

给你一个正整数数组 nums，请你移除 最短 子数组（可以为 空），使得剩余元素的 和 能被 p 整除。 不允许 将整个数组都移除。
请你返回你需要移除的最短子数组，如果无法满足题目要求，返回 -1 。
子数组 定义为原数组中连续的一组元素。

示例 1：
输入：nums = [3,1,4,2], p = 6
输出：1
解释：nums 中元素和为 10，不能被 p 整除。我们可以移除子数组 [4] ，剩余元素的和为 6 。

示例 2：
输入：nums = [6,3,5,2], p = 9
输出：2
解释：我们无法移除任何一个元素使得和被 9 整除，最优方案是移除子数组 [5,2] ，剩余元素为 [6,3]，和为 9 。

示例 3：
输入：nums = [1,2,3], p = 3
输出：0
解释：和恰好为 6 ，已经能被 3 整除了。所以我们不需要移除任何元素。

示例 4：
输入：nums = [1,2,3], p = 7
输出：-1
解释：没有任何方案使得移除子数组后剩余元素的和被 7 整除。

二、解法

1. 暴力解法

先计算出数组的总和，若和模p为0，则返回0，然后利用三层循环遍历所有的子数组，将数组总和减去子数组的和，模p如果等于0，则找到对应的数组长度，返回当前遍历的数组长度。如果遍历完之后没有发现，则返回 -1；

public int minSubarray(int[] nums, int p) {
    int sum = 0;
    for (int i = 0; i < nums.length; i++) {
        sum += nums[i] % p;
    }
    if (sum % p ==0)
        return 0;
    for (int i = 1; i < nums.length; i++) {
        for (int j = 0; j < nums.length - i + 1; j++) {
            int inSum = 0;
            for (int k = j; k < j + i; k++) {
                inSum += nums[k] % p;
            }
            if ((sum - inSum) % p == 0)
                return i;
        }
    }

    return -1;
}

运行结果

超出时间限制
127 / 142 个通过测试用例

时间复杂度：$O(n^3)$

空间复杂度：$O(1)$

2. 前缀和加哈希解法

该算法参考了力扣liuyubobobo的解题过程

一般与子数组的和相关的题目都可以利用前缀和来进行求解。

首先我们仍然求出整个数组的和记为 sum，如果数组的和模p，记为mod，为0，那么就可以直接返回0

如果mod不为零，那么我们只需找出和模p后为mod的子数组中最短的那个即可。

我们标记P[i]为数组索引为 i 的前缀和。

在计算索引 i 到 j 的子数组和时，利用前缀和，我们知道

sum(i, j) = P[j] - P[i - 1]

而我们所求的为和模p为mod的子数组，则假设 P[j] 模 p 为 x, P[i-1]模 p 为 y，则需要满足的是 |x - y| 模 p 等于 mod;

因此，当遍历到索引 j 时，我们首先求出前缀为 preSum，模p后值为 preMod，则我们需要找到 i < j，P[i-1] 模 p =targetMod，其中targetMod = preMod - mod，当 preMod 比 mod 小时，可以再加上 p，调整为正数。

因此，我们可以利用哈希表记录每个前缀和，其中key为模p的余数，而value值为索引，随着遍历的进行，后面的索引将覆盖前面的索引，进而保证了我们所求得的数组长度为最小值。

具体代码

public static int minSubarray(int[] nums, int p) {
    long sum = 0;
    for (int i = 0; i < nums.length; i++) {
        sum += nums[i];
    }
    int mod = (int) (sum % p);
    if (mod == 0)
        return 0;
    Map<Integer, Integer> map = new HashMap<>();
    map.put(0,-1);
    long preSum = 0;
    int ans = nums.length;
    for (int i = 0; i < nums.length; i++) {
        preSum += nums[i];
        int preMod = (int) (preSum % p);
        map.put(preMod, i);
        int targetMod = preMod - mod >= 0 ? (preMod - mod) : (preMod - mod + p);
        if (map.containsKey(targetMod))
            ans = Math.min(i - map.get(targetMod), ans);
    }
    return ans == nums.length ? -1 : ans;
}

运行结果

执行用时：35 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：54.7 MB, 在所有 Java 提交中击败了100.00%的用户

时间复杂度：$O(n)$

空间复杂度：$O(p)$