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_ub2zcNqzXV2MZzZCn5VHhdYjVAWt98D2p5PEdbzCn-cy-ojao5bIDxenHWdf1Nl1PsX02Y0QHQ8aYabbIE-70IB5-hEUNVV5pYA7TUp0wTCjgca3x27Gs9-8A3KJtCtcu4MEU23HgEp8sYwdorzwKilz-kQ2LGVexhY2I7euxtH-zujQ=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_vyCehdhb8XH-hq1kv6uxgv4sxyw71yig-gvXnAioTdt_XfzrUWyYP9g6XEnzndgWnICtV6VKgBay4ftHmbCIY1u4-IIk-gGIjwsoO70XV4mR6cM6jBG5mXJ1mz-TYZSW2mSaLTXNdnoMZPfC4EJ774Io9Pe7cf-SZbgw=s0-d)
![M \leftarrow M \cup \{(S[i], i)\} M \leftarrow M \cup \{(S[i], i)\}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_uILKqYFu5lp6ESxOaPJFwEs-CrgHmeOaJM13xhilxvej8XFID1jWFKGRf9zCmVAYW8OQawvrTxbzsPyqRcKFU6qvVQgyT9OgyHsw4sYZ_KQaA03vYNZDCmpkujY_FbmwWCud4HOL3dYWhRJNq0GBWu7pxkGLUWqAOuWRdpZj8k4PUK8-tYT0T9M8E=s0-d)
![{\rm smallest} \leftarrow S[i] {\rm smallest} \leftarrow S[i]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_tuFerE6P0bXgcKO3vy3IT1kjLbUxnpLgCfMD8G25_yvGRSoFdK7hkocSJUcplWxLysDJarxPsuI2hKKlyfnPO5L0nlQ7yeYQ-qWUxrvMt-wj_CPVXSW1mdG1RqYCkv-A91TjyeAX7XjVoeOQdIpwGheQxu4v3JYBGzmsCEpcV14E6X=s0-d)
6.
7. for
up to 
if![S[i] > {\rm current} S[i] > {\rm current}](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_vVKY7-G_jRR5_kWqs7hWRseUFABKTrfT3eeS_7GDqG7O5q_-Ea4Wr5z-LrE_PIjFSOIK-XdB9jGvO3G15_fdSn2j5uYlpDg15EQ2Rbvi8extxB7ILpFSrWchgwTnLs-dwe7yZplGhYSGlTx62OH9HEQg58D0bMN-LO=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_tgvrhAjmq1Jr2n51m8PR8pCLzfkWwe5jVZ11rmEkIjgjxj99P6Nl4l9T5XhBw9qgKvs0wUm4MkHMnV0AtA0bMTgJTgz2Ii8Uf2WUUMND-R4v1tUVty9VZc-FPNWDV6DFm_7B53X-iIeTS27ojMngKY7QLC9NZ8V0cgh2xEV9o7SlEr=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