# Leetcode Subarray-Sum-Equals-K

2022-09-05 15:22

> ##### Algorithms:
>
> #algorithm #sliding_window #hash_table 
>
> ##### Data structures:
>
> #DS
>
> ##### Difficulty:
>
> #coding_problem #difficulty-medium
>
> ##### Additional tags:
>
> #leetcode 
>
> ##### Revisions:
>
> N/A

##### Links:

- [Link to problem](https://leetcode.com/problems/subarray-sum-equals-k/)

---

### Problem

Given an array of integers `nums` and an integer `k`, return _the total number of subarrays whose sum equals to_ `k`.

A subarray is a contiguous **non-empty** sequence of elements within an array.

#### Examples

**Example 1:**

**Input:** nums = [1,1,1], k = 2
**Output:** 2

**Example 2:**

**Input:** nums = [1,2,3], k = 3
**Output:** 2

#### Constraints

-   `1 <= nums.length <= 2 * 104`
-   `-1000 <= nums[i] <= 1000`
-   `-107 <= k <= 107`

### Thoughts

> [!summary]
> This can be solved using #sliding_window 

> I over-complicated the solution by adding stuff like 
> sorting, but it turn out to be not so difficult.

Since the subsets are **contiguous**, we can use sliding 
window here.

### Solution


TLE, brute force
```cpp
class Solution {
public:
  int subarraySum(vector<int> &nums, int k) {
    // O(N^2 / 2)

    int n = nums.size();

    if (n == 1) {
      return (k == nums[0]);
    }

    vector<int> prefix(n + 1, 0);
    int prefixSum = 0;

    for (int i = 0; i < n; i++) {
      prefixSum += nums[i];
      prefix[i + 1] = prefixSum;
    }

    int count = 0;

    for (int i = 0; i < n + 1; i++) {
      for (int j = i + 1; j < n + 1; j++) {
        if (prefix[j] - prefix[i] == k) {
          count++;
        }
      }
    }

    return count;
  }
};
```