Maximum length L such that the sum of all subarrays of length L is less than K
Last Updated :
22 Jun, 2022
Given an array of length N and an integer K. The task is to find the maximum length L such that all the subarrays of length L have sum of its elements less than K.
Examples:
Input: arr[] = {1, 2, 3, 4, 5}, K = 20
Output: 5
The only subarray of length 5 is the complete
array and (1 + 2 + 3 + 4 + 5) = 15 < 20.
Input: arr[] = {1, 2, 3, 4, 5}, K = 10
Output: 2
Approach: For the maximum sum of a subarray of length K, go through the approach discussed in this article. Now, a binary search can be performed to find the maximum length. As the array elements are positive then increasing the subarray length will increase the maximum sum of the subarray elements for that length.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxSum( int arr[], int n, int k)
{
if (n < k) {
return -1;
}
int res = 0;
for ( int i = 0; i < k; i++)
res += arr[i];
int curr_sum = res;
for ( int i = k; i < n; i++) {
curr_sum += arr[i] - arr[i - k];
res = max(res, curr_sum);
}
return res;
}
int solve( int arr[], int n, int k)
{
int max_len = 0, l = 0, r = n, m;
while (l <= r) {
m = (l + r) / 2;
if (maxSum(arr, n, m) > k)
r = m - 1;
else {
l = m + 1;
max_len = m;
}
}
return max_len;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int n = sizeof (arr) / sizeof ( int );
int k = 10;
cout << solve(arr, n, k);
return 0;
}
|
Java
class GFG
{
static int maxSum( int arr[], int n, int k)
{
if (n < k)
{
return - 1 ;
}
int res = 0 ;
for ( int i = 0 ; i < k; i++)
res += arr[i];
int curr_sum = res;
for ( int i = k; i < n; i++)
{
curr_sum += arr[i] - arr[i - k];
res = Math.max(res, curr_sum);
}
return res;
}
static int solve( int arr[], int n, int k)
{
int max_len = 0 , l = 0 , r = n, m;
while (l <= r)
{
m = (l + r) / 2 ;
if (maxSum(arr, n, m) > k)
r = m - 1 ;
else
{
l = m + 1 ;
max_len = m;
}
}
return max_len;
}
public static void main (String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 };
int n = arr.length;
int k = 10 ;
System.out.println(solve(arr, n, k));
}
}
|
Python3
def maxSum(arr, n, k) :
if (n < k) :
return - 1 ;
res = 0 ;
for i in range (k) :
res + = arr[i];
curr_sum = res;
for i in range (k, n) :
curr_sum + = arr[i] - arr[i - k];
res = max (res, curr_sum);
return res;
def solve(arr, n, k) :
max_len = 0 ; l = 0 ; r = n;
while (l < = r) :
m = (l + r) / / 2 ;
if (maxSum(arr, n, m) > k) :
r = m - 1 ;
else :
l = m + 1 ;
max_len = m;
return max_len;
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ];
n = len (arr);
k = 10 ;
print (solve(arr, n, k));
|
C#
using System;
class GFG
{
static int maxSum( int []arr, int n, int k)
{
if (n < k)
{
return -1;
}
int res = 0;
for ( int i = 0; i < k; i++)
res += arr[i];
int curr_sum = res;
for ( int i = k; i < n; i++)
{
curr_sum += arr[i] - arr[i - k];
res = Math.Max(res, curr_sum);
}
return res;
}
static int solve( int []arr, int n, int k)
{
int max_len = 0, l = 0, r = n, m;
while (l <= r)
{
m = (l + r) / 2;
if (maxSum(arr, n, m) > k)
r = m - 1;
else
{
l = m + 1;
max_len = m;
}
}
return max_len;
}
public static void Main ()
{
int []arr = { 1, 2, 3, 4, 5 };
int n = arr.Length;
int k = 10;
Console.WriteLine(solve(arr, n, k));
}
}
|
Javascript
<script>
function maxSum(arr , n , k) {
if (n < k) {
return -1;
}
var res = 0;
for (i = 0; i < k; i++)
res += arr[i];
var curr_sum = res;
for (i = k; i < n; i++) {
curr_sum += arr[i] - arr[i - k];
res = Math.max(res, curr_sum);
}
return res;
}
function solve(arr , n , k) {
var max_len = 0, l = 0, r = n, m;
while (l <= r) {
m = parseInt((l + r) / 2);
if (maxSum(arr, n, m) > k)
r = m - 1;
else {
l = m + 1;
max_len = m;
}
}
return max_len;
}
var arr = [ 1, 2, 3, 4, 5 ];
var n = arr.length;
var k = 10;
document.write(solve(arr, n, k));
</script>
|
Time Complexity: O(N*logN), as we are using binary search which will cost logN and in each traversal, we are calling the function maxSum which will cost O(N) time. Where N is the number of elements in the array.
Auxiliary Space: O(1), as we are not using any extra space.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...