【1590. 使数组和能被 P 整除】

来源：力扣（LeetCode）

描述：

给你一个正整数数组 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 整除。

示例 5：

输入：nums = [1000000000,1000000000,1000000000], p = 3
输出：0

提示：

• 1 <= nums.length <= 10⁵
• 1 <= nums[i] <= 10⁹
• 1 <= p <= 10⁹

方法：前缀和

定理一：给定正整数 x、y、z、p，如果 y mod p = x，那么 (y − z) mod p = 0 等价于 z mod p = x。

证明：y mod p = x 等价于 y = k₁ × p + x，(y − z) mod p = 0 等价于 y − z = k₂ × p，z mod p = x 等价于 z = k₃ × p + x，其中 k₁ 、k₂ 、k₃ 都是整数，那么给定 y = k₁ × p + x，有 y − z = k₂ × p ↔ z = (k₁ − k₂) × p + x ↔ z = k₃ × p + x。

定理二：给定正整数 x，y，z，p，那么 (y − z) mod p = x 等价于 z mod p =(y − x) mod p。

证明：(y − z) mod p = x 等价于 y − z = k₁ × p + x，其中 k₁ 是整数，经过变换有 z = y − k₁ × p − x = k₂ × p + (y − x) mod p − k₁ × p = (k ₂ −ck₁) × p +(y − x) mod p，等价于 z mod p = (y − x) mod p。

记数组和除以 p 的余数为 x，如果 x = 0 成立，那么需要移除的最短子数组长度为 0。

记前 i 个元素（不包括第 i 个元素）的和为 f_i ​，我们考虑最右元素为 nums[i] 的所有子数组，假设最左元素为 nums[j] (0 ≤ j ≤ i)，那么对应的子数组和为 f_i+1 − f_j ，对应的长度为 i − j + 1。由定理一可知，如果剩余子数组和能被 p 整除，那么 ( f_i+1 − f_j ) mod p = x。同时由定理二可知，f_j mod p = (f_i+1 − x) mod p。因此当 f_i+1 已知时，我们需要找到所有满足 f_j mod p = (f_i+1 − x) mod p 的
f_j（0 ≤ j ≤ i），从中找到最短子数组。

由于需要移除最短子数组，因此对于所有 f_j（0 ≤ j ≤ i），只需要保存 f_j mod p 对应的最大下标。

有些编程语言对负数进行取余时，余数为负数，因此计算 f_i+1 − x 除以 p 的余数时，使用 f_i+1− x + p 替代。

代码：

class Solution {
public:
    int minSubarray(vector<int>& nums, int p) {
        int x = 0;
        for (auto num : nums) {
            x = (x + num) % p;
        }
        if (x == 0) {
            return 0;
        }
        unordered_map<int, int> index;
        int y = 0, res = nums.size();
        for (int i = 0; i < nums.size(); i++) {
            index[y] = i; // f[i] mod p = y，因此哈希表记录 y 对应的下标为 i
            y = (y + nums[i]) % p;
            if (index.count((y - x + p) % p) > 0) {
                res = min(res, i - index[(y - x + p) % p] + 1);
            }
        }
        return res == nums.size() ? -1 : res;
    }
};

执行用时：148 ms, 在所有 C++ 提交中击败了82.80%的用户
内存消耗：64.8 MB,在所有 C++ 提交中击败了94.27%的用户
复杂度分析
时间复杂度：O(n)，其中 n 是数组 nums 的长度。遍历数组 nums 需要 O(n) 的时间。
空间复杂度：O(n)。保存哈希表需要 O(n) 的空间。
author：LeetCode-Solution