Longest subarray whose sum <= k
Longest subarray whose sum
Given an array
of
numbers and a key
, find the longest subarray of
for which the subarray sum is less than or equal to
.
In the following we describe an algorithm with time complexity
.
Algorithm LONGESTSUBARRAY(
,
)
Longest_subarray_k_improved.cpp LongestSubarrayK.java
Longest subarray whose sum
Given an array
In the following we describe an algorithm with time complexity
Algorithm LONGESTSUBARRAY(
Input: An array
and a real number 
Output: A pair of indices
, maximizing
, subject to ![\sum_{t = i}^j A[t] \leq k \sum_{t = i}^j A[t] \leq k](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_sswxWeuAcnL94NamyBqVqENR8Pnx5gCfQRXj1urY2kIc4ks9-URrR3hFIBxJW3PMHdbuLof9gL_Z7dWMx4fa7XEMOVjmkqRBCqPR8Pv0necaEoNCD34mG-n7GL46VTNehRKNWSBoIZ7HfyyLiktE_BMsM4TpdzSPX-V0gFE3H0wJFlKQ=s0-d)
1. Compute the array
of partial sums, where
is the prefix sum of the first
numbers in
.
.
2.
3.
4.
5. for
down to 0
if![S[i] < {\rm smallest} S[i] < {\rm smallest}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_s5xP05FqN3l8bQdQg7749f4WysPcoMjYlTcSq0zcjrT5Qx_usPpp_rBHMmYnWWPgBLcwOCHSG4dzOG1i3UtNlxjPmWMm3ZoFsaJ5opn9Rp8s1d6t2Djntdfbceu65R-Qn43TqQC2QzTKwDHitqtSF8vhjevNuEayPWKA=s0-d)
![M \leftarrow M \cup \{(S[i], i)\} M \leftarrow M \cup \{(S[i], i)\}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_szTnuZtvjxLsHCqP2K6DbD2sEmsIMXW9646zDsv7nCR2kExs96Mz2qWbO72iccKC7a5EEck6AsqLzIfahpbhHDeUuMYyPgBEixrjw9Q0DE7OXx1Wg7WBEcx2vp9NLsayETvcP4jd3lp4FrF8DogsZ0GUw4gcj_vOGtV9J2S9_0EaLw8wBj0_OIP1I=s0-d)
![{\rm smallest} \leftarrow S[i] {\rm smallest} \leftarrow S[i]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_syLcRFo3-uZg-qngOvwTlNnITR2U_7fVpoeOBiayZz92Krj0a9twgC1-jUkQ3gMF4TtGG1NVMIreUh4KIkEIHyx3xsQmPnLmyQOng7rJoPzKLsztynBJxe-BFa1nzO5W-woTELqQdUVJw-O2BOKfFFpJutYsw0FXmbs2iyEBhwBlkr=s0-d)
6.
7. for
up to 
if![S[i] > {\rm current} S[i] > {\rm current}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_u9nuoQ2TktxLnM0-bTheL3AAKXiAkgXoedkpITNRGuo773ryt23zwF755QjbHWZq3JP_sFQDBhVEC3c-2bdy4hO-SsFF5qeLf3iBx3L6aK_1a0o7LjqW4h4QXcTD9bTuAZsdWOvTNkigRSGsvPGp2Wo0fVWawfi8Bw=s0-d)
Use binary search to look for the rightmost element
in
such that
. If such an element exists, update
to
if 
![{\rm current} \leftarrow S[i] {\rm current} \leftarrow S[i]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_tf8Xw5e4hxYpTi7-Lz5kGTt2gW7I-SSOlJo5zxjPEyh6f9Ip_H0WmxYL4Q18miR2iK-0vXJBskHu8G-musjes7KIVEDeEuNXkj9EOW-nq1XUtvefxh8qs2JhwM_wfD1ruPokXMA7c1i8KQCua6hxS4LjY6yXHN6rXOTcNJ-q4A9dVZ=s0-d)
8. return
Find the longest subarray whose sum <= kOutput: A pair of indices
1. Compute the array
2.
3.
4.
5. for
if
6.
7. for
if
Use binary search to look for the rightmost element
8. return
Longest_subarray_k_improved.cpp LongestSubarrayK.java
public static Pair<Integer, Integer> findLongestSubarrayLessEqualK(
List<Integer> A, int k) {
// Build the prefix sum according to A.
List<Integer> prefixSum = new ArrayList<>();
int sum = 0;
for (int a : A) {
sum += a;
prefixSum.add(sum);
}
List<Integer> minPrefixSum = new ArrayList<>(prefixSum);
for (int i = minPrefixSum.size() - 2; i >= 0; --i) {
minPrefixSum.set(i,
Math.min(minPrefixSum.get(i), minPrefixSum.get(i + 1)));
}
Pair<Integer, Integer> arrIdx = new Pair<>(0,
upperBound2(minPrefixSum, k) - 1);
for (int i = 0; i < prefixSum.size(); ++i) {
int idx = upperBound2(minPrefixSum, k + prefixSum.get(i)) - 1;
if (idx - i - 1 > arrIdx.getSecond() - arrIdx.getFirst()) {
arrIdx = new Pair<>(i + 1, idx);
}
}
return arrIdx;
}
Correctness of the Algorithm
The key is to observe the following two facts.
Claim: (1) If two indices
satisfies that
, then
cannot appear in an optimum solution; (2) If two indices
satisfies that
, then
cannot appear in an optimum solution.
Proof: For any index
,
, note that the subarray sum of
is less than the subarray sum of
, and the length of the subarray $A[i..r']$ is greater than the length of the subarray
(although both length might be negative, but the statement still holds). Therefore,
is preferable over
. This is also the reason why we compute the strictly increasing sequence of
.
The second statement follows a similar reasoning.
Claim: (1) If two indices
Proof: For any index
The second statement follows a similar reasoning.
Time Complexity and Space Complexity
Step 1, computing the prefix sums, takes
time. Step 4, computing the array
, takes
time. Step 7 takes
time as each iteration takes
time.
Please read full article from Longest subarray whose sum <= kStep 1, computing the prefix sums, takes