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_su34gaW9PvF9IIv2AB_ottrbmsd23etH8y-hzSm4CPWtw-NnWAb3oY7m4gu0I_zKFMVRo78XYJHZkLI1AYxq6BVk-b0SA2S0q2QwSlGAT610FMKHeaowrHxuohoprhfFOpATq7adnIqvv-AqFuWqZ_H15f7EIgvmi65ndZujhgxDy4uA=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_unmAGV8Bf8AB6-8r6gk5kx4egHnkTzt2ovpuzROnWnaeIT-RmSjRxWLfF2jMXfFmBlCFIA4sFPQ4xchgvObYBzXsbZxn4jQ3_sWuwjDFPjLvI_cBTwLMWXP8VZcy5L2sCHL_VnI3W9YCYp575Qh9E92kzwbGXhoyDsUg=s0-d)
![M \leftarrow M \cup \{(S[i], i)\} M \leftarrow M \cup \{(S[i], i)\}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_sIgY7zwhgMH8D5Aai2R6nKgCSDfKtDfxRQeU_gccteHtg_DqejpB1AbSSqq5dwp6QaSaVusj5FKLfViVC1y1GRSxV-vEtVHa0aKUIGDFJhrjW5XVuGqUhHfxmjhXIFsMqUyWKugmOmYiAqcWFV671DxpcHcFYC5ywtUAUW_OxtAwAjJeveZ7guj04=s0-d)
![{\rm smallest} \leftarrow S[i] {\rm smallest} \leftarrow S[i]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_tVfOdrOCwh8m9XB0dsWycrbiJLz8ui6U_BZh9zUB-wkDKUL-VwEUL5WEjENWEKjdde9DVaKFYvMQiijO34u5zogkNrm28sHQy4J0wjRZ8e4cPgnvvz8snKoiI-rbuVWN0BNA9jtZ9D29nRg62QoZCaXxi5gfASc54-23qoMHS9PKnL=s0-d)
6.
7. for
up to 
if![S[i] > {\rm current} S[i] > {\rm current}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_vZ1jzx2s_Nvjb0QtwIswAJU02r2Wc1oOoEo-Mfe9UfnpHmw-hV_Tb26x9GpkkdxaSBC8rfTVVS6stmeYwbrjrhfd9FGvARaZf1fJeukdF3Wy-MtqHSQ8lmaeqLKMGSEk9CKdoXW4NhSBAhgRUAgdxevWIJQcqPPRoz=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_u260FEiw_EoZdp28-5MRJ2-NfUs5ZIMFkr3bE3X5BqtRQ5_4zqAWnPq8D9F9Wp7DG_XV3pUzwSCkAO8uAoQufUceBqlwOE12tnlc5bD_8PGQ3I7k51F68-PjvYB_R6lcovwY_ql0GCGNSw6T7T2hhWRHU3bAoNuRAojbs7rOqZDOJj=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