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_uAdlEGl3opFN_Kzkd7-eBPFCZeDdu20S20iPCWm0atF0ppJaJi_GYg3kPinWQsa1k6cbCqLEOdwb6Oycdx_n1iUs14q1AxInSu9s1rUQMtRCTiXCn3aOx-IhxvK04yx0ThDWSYMDkZr-AlKEiOdmN9PBm6-zDgKXyNtSloYV-f7qq3zg=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_txC-P33nGzBUgWZ0GJnpFXKYaJGDW03YwAH2FBaiNBzt9mQpkNdGrxUnZ6otSfrL9QJBznz9hY5mwXMo9wKZZHKYEXRbHnOEYAmukAR89CEu0lq0nEmV6hB6TzetNPcqoEiX0sSEL5gGRwxGe9zP86PF2qTapwzJE0fg=s0-d)
![M \leftarrow M \cup \{(S[i], i)\} M \leftarrow M \cup \{(S[i], i)\}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_tHzExwbVRDieXbeAtrzBH8z4vP6GRe5cFVH4-2kdfclCmZ9eBtWBhqdd0Jo5kXrgC8AZk3AqZT6UUMLIEzYXce4p9rotLWOCWkneTTCRmYFUVWep9lZ6bzBim5N8jOO5xHyRyQK8mJqIr30jjQEqRurWHIMo8JTQXN8PjsF0ywn0c0o2LwVIWBYuY=s0-d)
![{\rm smallest} \leftarrow S[i] {\rm smallest} \leftarrow S[i]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_tZ8LE7cZ4GYnEfuMsQUMUgRgmvoFKo-qd0zSiL8tJEkAMlhW7Pw-_yg6JkDZnJGF2ujqIP_OtXy2t_1eSTrIfT3jlB_UDacaogOGtOQ8SfMh7OK9viPE91QzXMJ0omD4uzf99kaDGejU8fDt8oes0AgljYLq2vVenNR5e-3FLV9Z5J=s0-d)
6.
7. for
up to 
if![S[i] > {\rm current} S[i] > {\rm current}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_stEgQGhzgYP88T7tJ_IJzwjPe08JmX5mmT-6AxD0p4oyL202vyVfXq-YO1wWQvmIX-k-Uf3LuHGmevUbi5G-eN4UGhn3yQlhEDIflfupZvR6bZ2Af8iM6XPKF6gR3MF_T4GY7l131zxEKwWf7XFuGI9CrUTyMPV8rY=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_sjoFNvJmhinXB1Po7ZsvfNumMerx_8xLi8uFIYwLSiptHLY35gKgnGST0-lcHkxYI61aqrdC4IUs5xKrvCcFrMB7oXmKXh1rYTQ0A2c5hQA1VUexPSOevnq5UKpPPCzUegqrb7ozFC6UaznooUFatsvAb953dl2Vteo5ByZ4UBmN73=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