523. Continuous Subarray Sum

1. Description

Given an integer array nums and an integer k, return true if nums has a good subarray or false otherwise.
A good subarray is a subarray where:

• its length is at least two, and
• the sum of the elements of the subarray is a multiple of k.

Note that:

• A subarray is a contiguous part of the array.
• An integer x is a multiple of k if there exists an integer n such that x = n * k. 0 is always a multiple of k.

2. Example

Example 1

Input: nums = [23,2,4,6,7], k = 6
Output: true
Explanation: [2, 4] is a continuous subarray of size 2 whose elements sum up to 6.

Example 2

Input: nums = [23,2,6,4,7], k = 6
Output: true
Explanation: [23, 2, 6, 4, 7] is an continuous subarray of size 5 whose elements sum up to 42.
42 is a multiple of 6 because 42 = 7 * 6 and 7 is an integer.

Example 3

Input: nums = [23,2,6,4,7], k = 13
Output: false

3. Constraints

• 1 <= nums.length <= 10$^{5}$
• 0 <= nums[i] <= 10$^{9}$
• 0 <= sum(nums[i]) <= 2$^{31}$ - 1
• 1 <= k <= 2$^{31}$ - 1

4. Solutions

Prefix Sum & Hash Table

n = nums.size()
Time complexity: O(n)
Space complexity: O(min(n, k))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// if a % k == b % k, then a - b % k == 0
class Solution {
public:
    bool checkSubarraySum(const vector<int> &nums, int k) {
        map<int, int> reminder_index;
        reminder_index[0] = -1; // to calculate the subarray length when the index is 0
        for (int i = 0, reminder = 0; i < nums.size(); ++i) {
            reminder = (reminder + nums[i]) % k;
            if (reminder_index.count(reminder)) {
                if (i - reminder_index[reminder] > 1) {
                    return true;
                }
            } else {
                reminder_index[reminder] = i;
            }
        }

        return false;
    }
};