Find two non-overlapping subarrays, with total sum equal to k

Question

Given an array of N non-negative integers, and a number K, we need to find two non-overlapping contiguous subarrays that have a total sum of K. Our algorithm is supposed to find the minimum total length of the two subarrays that have total sum K.

Also, after I checked the biggest test cases that we got, N doesn't go above $10^4$ and K doesn't go above $10^6$ (but specific subarrays can have a sum way larger than that)

The algorithm implementation (using C++), must have a time complexity of at most O(logN * N^2).

The only idea I've had that is better than O(n^3) is to find all possible contiguous subarrays and their sum (O(N^2) using a prefix sum array), then sort them by sum (O(logN * N^2)), and for each subarray I do a binary search to find the subarray that has the remaining sum (which is K - (sum of first subarray)).

While this idea has better time complexity than O(n^3), its space complexity is pretty bad, because I have to save three arrays of size N(N+1)/2, and the C++ program ends up using 1-2 GB of RAM for large N (>1000).

So my question is: Is there any way to solve the problem efficiently, without the need of the longer arrays?? Or is there any other way I can implement the idea above with C++ so that I don't use up so much memory?

Thanks

Answer 1

The following algorithm works but does not achieve the required time complexity of $O(n^2 \log n)$, since I misread the time constraint as just being subcubic.

Let $a_i$ be the $i$-th element in the array and $\varepsilon > 0$ be an arbitrary small constant. Construct a prefix sum array (in time $O(n)$) and then, for each pair $i,j$ with $j-i \ge n^{1-\varepsilon}$ generate the tuple $(\sum_{h=i}^j a_h, i, j)$. This requires time $O(n^{1+\varepsilon})$.

Next, construct two sorted lists $L^+, L^-$ containing the above tuples. Both lists sort the tuples w.r.t. the first entry. Additionally, the first (resp. second) list breaks ties w.r.t. the second entry while the second list breaks ties w.r.t. the third entry. This requires time $O(n^{1+\varepsilon} \log n)$.

Next use your approach with a slight variation: guess the start position $i$ and the end position $j$ of the first subarray (there are $O(n^2)$ guesses). For each guess $(i,j)$:

• Compute the sum $S = \sum_{h=i}^j a_h$ (in constant time).
• Binary search $L^+$ and $L^-$ to decide whether there is a disjoint array of length at least $n^{1-\varepsilon}$ with sum $K - S$. If this is the case you are done.
• Otherwise exhaustively search all disjoint subarrays of length smaller than $n^{1-\varepsilon}$.

Overall this requires time $O(\log n + n^{1-\varepsilon}) = O(n^{1-\varepsilon})$ per guess and time $O(n^{3-\varepsilon})$ in total, which falls within the time requirements. The space requirement is only $O(n^{1+\epsilon})$.

Answer 2

Compute the sums of all subarrays ($O(n^2)$), sort all distinct sums ($O(n^2\log n)$), then find all pairs of sums that sum to $K$ ($O(n^2)$).

Note each sum may correspond to multiple subarrays. Given two sums that sum to $K$, you have to check for all pairs of subarrays corresponding to the two sums whether they overlap. To solve this, for each sum, pre-find the subarray with the leftmost end position and the subarray with the rightmost start position. You only need to store and check these two subarrays (also note to store a subarray, you only need to store its start position and end position).

Answer 3

Our professor gave us this solution, which has $O(N^2 + K)$ time complexity, and $O(N+K)$ space complexity (since for the biggest test cases $K$ is about $N^{1.5}$, it is as good as $O(N^2)$ for these upper bounds).

We start by initializing an array $Lengths$ of size $K$, every value set to $N+1$, and calculating a prefix-sum for the initial array. We also keep a variable $min$ for the final answer (initially set to $N+1$).

Then we iterate the initial array with an index $y$, starting from $N-1$ down to $0$. For each iteration we do the following:

1. We iterate the array with an index $z$ starting from $y+1$ up to $N$. For each subarray, we calculate its sum, and if its length is less than $Lengths[sum]$ (where sum is the one we just computed), we set $Lengths[sum]$ to $z-y$, the length of this subarray.
2. We iterate the array with an index $x$ starting from $0$ up to $y$. For each subarray, we calculate its sum, and if this subarray's length PLUS $Lengths[K-sum]$ is less than $min$, then we update $min$ with the new value.

Answer 4

Slight modification to other answers that may help:

1. Since one subarray must have a sum from 0 to K/2, and the other must have a sum from K/2 to K, only look at subarrays with a sum <= K. This may help a lot, especially if K is much smaller than the total size of all array elements.

2. If K is large, but heuristically you expect only few solutions, pick a prime p and find solutions modulo p, picking p large enough so there are still few solutions, but small enough to reduce your memory requirements. Then check whether your solution modulo p is a solution of the original problem.

3. Once you found a solution with length M, only consider subarrays with fewer than M elements.

Answer 5

The restriction to non-negative values simplifies solving the problem drastically:
Once the sum has reached $K$, adding elements increases length, if not sum.

This reduces the number of subarrays to know from $O(n^2)$ (start and end) to $O(K^2)$ (length and subtotal).

If $K$ is not greater than zero, you dont even need to inspect the array.
Check if $K$ is the value of an element of the array upfront: With $0 < K$, the combined length won't go below 1.

With a largish K and hell bent going lowest/$o(n^2)$ space, how about the following?

0. let $array$ be the input array of $n$ integral numbers no less than 0;
   $best$, $left$ and $combined$ for the best pair known
   the subtotal of the left subarray, its length and the combined length;
   $length$ and $end$ arrays of $n$ candidate subarray lengths and ends, respectively
1. for $target$ from 0 to $K-1$
   1.1. from index 0 up, for each subarray totaling $target$ of record brevity, keep length and end
   1.2. next $target$ if none found
   1.3. for each subarray $right$ with sum $K - target$ from the end of $array$
          if sum of its length and the shortest one kept "to the left of $right$" $^*$
          bests $best$, update $best$
2. re-find the rightmost subarray with sum $K - best$ and length $combined - left$

$O(n)$ storage, $O(nK)$ time: $O(n^2 \log n)$ where $K \in O(n \log n)$

Exchange the roles of subarray length and and target subtotal for
$O(K)$ storage, $O(n^2)$ time

$^*$ linear search from the end should do nicely, if the last index used is kept