Maximum subarray size, such that all subarrays of that size have sum less than k
Given an array of n positive integers and a positive integer k, the task is to find the maximum subarray size such that all subarrays of that size have the sum of elements less than or equals to k.
Examples :
Input : arr[] = {1, 2, 3, 4} and k = 8.
Output : 2
Sum of subarrays of size 1: 1, 2, 3, 4.
Sum of subarrays of size 2: 3, 5, 7.
Sum of subarrays of size 3: 6, 9.
Sum of subarrays of size 4: 10.
So, maximum subarray size such that all subarrays of that size have the sum of elements less than 8 is 2.
Input : arr[] = {1, 2, 10, 4} and k = 8.
Output : -1
There is an array element with value greater than k, so subarray sum cannot be less than k.
Input : arr[] = {1, 2, 10, 4} and K = 14
Output : 2
Naive Approach: Firstly, the required subarray size must lie between 1 to n. Now, since all the array elements are positive integers, we can say that the prefix sum of any subarray shall be strictly increasing. Thus, we can say that
if arr[i] + arr[i + 1] + ..... + arr[j - 1] + arr[j] <= K
then arr[i] + arr[i + 1] + ..... + arr[j - 1] <= K, as arr[j] is a positive integer.
- Perform Binary Search over the range 1 to n and find the highest subarray size such that all the subarrays of that size have the sum of elements less than or equals to k.
Implementation:
C++
#include<bits/stdc++.h>
using namespace std;
int bsearch ( int prefixsum[], int n,
int k)
{
int ans = -1;
int left = 1, right = n;
while (left <= right)
{
int mid = (left + right) / 2;
int i;
for (i = mid; i <= n; i++)
{
if (prefixsum[i] - prefixsum[i - mid] > k)
break ;
}
if (i == n + 1)
{
left = mid + 1;
ans = mid;
}
else
right = mid - 1;
}
return ans;
}
int maxSize( int arr[], int n, int k)
{
int prefixsum[n + 1];
memset (prefixsum, 0, sizeof (prefixsum));
for ( int i = 0; i < n; i++)
prefixsum[i + 1] = prefixsum[i] +
arr[i];
return bsearch (prefixsum, n, k);
}
int main()
{
int arr[] = {1, 2, 10, 4};
int n = sizeof (arr) / sizeof (arr[0]);
int k = 14;
cout << maxSize(arr, n, k) << endl;
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
static int bsearch( int prefixsum[],
int n, int k)
{
int ans = - 1 ;
int left = 1 , right = n;
while (left <= right)
{
int mid = (left + right) / 2 ;
int i;
for (i = mid; i <= n; i++)
{
if (prefixsum[i] - prefixsum[i - mid] > k)
break ;
}
if (i == n + 1 )
{
left = mid + 1 ;
ans = mid;
}
else
right = mid - 1 ;
}
return ans;
}
static int maxSize( int arr[], int n, int k)
{
int prefixsum[] = new int [n + 1 ];
Arrays.fill(prefixsum, 0 );
for ( int i = 0 ; i < n; i++)
prefixsum[i + 1 ] = prefixsum[i] + arr[i];
return bsearch(prefixsum, n, k);
}
public static void main(String arg[])
{
int arr[] = { 1 , 2 , 10 , 4 };
int n = arr.length;
int k = 14 ;
System.out.println(maxSize(arr, n, k));
}
}
|
Python3
def bsearch(prefixsum, n, k):
ans, left, right = - 1 , 1 , n
while (left < = right):
mid = (left + right) / / 2
for i in range (mid, n + 1 ):
if (prefixsum[i] - prefixsum[i - mid] > k):
i = i - 1
break
i = i + 1
if (i = = n + 1 ):
left = mid + 1
ans = mid
else :
right = mid - 1
return ans;
def maxSize(arr, n, k):
prefixsum = [ 0 for x in range (n + 1 )]
for i in range (n):
prefixsum[i + 1 ] = prefixsum[i] + arr[i]
return bsearch(prefixsum, n, k);
arr = [ 1 , 2 , 10 , 4 ]
n = len (arr)
k = 14
print (maxSize(arr, n, k))
|
C#
using System;
class GFG {
static int bsearch( int []prefixsum,
int n, int k)
{
int ans = -1;
int left = 1, right = n;
while (left <= right)
{
int mid = (left + right) / 2;
int i;
for (i = mid; i <= n; i++)
{
if (prefixsum[i] -
prefixsum[i - mid] > k)
break ;
}
if (i == n + 1)
{
left = mid + 1;
ans = mid;
}
else
right = mid - 1;
}
return ans;
}
static int maxSize( int []arr, int n, int k)
{
int []prefixsum = new int [n + 1];
for ( int i=0;i<n+1;i++)
prefixsum[i]=0;
for ( int i = 0; i < n; i++)
prefixsum[i + 1] = prefixsum[i]
+ arr[i];
return bsearch(prefixsum, n, k);
}
public static void Main()
{
int []arr = { 1, 2, 10, 4 };
int n = arr.Length;
int k = 14;
Console.Write(maxSize(arr, n, k));
}
}
|
PHP
<?php
function bsearch(& $prefixsum , $n , $k )
{
$ans = -1;
$left = 1;
$right = $n ;
while ( $left <= $right )
{
$mid = intval (( $left + $right ) / 2);
for ( $i = $mid ; $i <= $n ; $i ++)
{
if ( $prefixsum [ $i ] - $prefixsum [ $i -
$mid ] > $k )
break ;
}
if ( $i == $n + 1)
{
$left = $mid + 1;
$ans = $mid ;
}
else
$right = $mid - 1;
}
return $ans ;
}
function maxSize(& $arr , $n , $k )
{
$prefixsum = array_fill (0, $n + 1, NULL);
for ( $i = 0; $i < $n ; $i ++)
$prefixsum [ $i + 1] = $prefixsum [ $i ] +
$arr [ $i ];
return bsearch( $prefixsum , $n , $k );
}
$arr = array (1, 2, 10, 4);
$n = sizeof( $arr );
$k = 14;
echo maxSize( $arr , $n , $k ) . "\n" ;
?>
|
Javascript
<script>
function bsearch(prefixsum , n , k)
{
var ans = -1;
var left = 1, right = n;
while (left <= right) {
var mid = parseInt((left + right) / 2);
var i;
for (i = mid; i <= n; i++) {
if (prefixsum[i] - prefixsum[i - mid] > k)
break ;
}
if (i == n + 1) {
left = mid + 1;
ans = mid;
}
else
right = mid - 1;
}
return ans;
}
function maxSize(arr , n , k) {
var prefixsum = Array(n + 1).fill(0);
for (i = 0; i < n; i++)
prefixsum[i + 1] = prefixsum[i] + arr[i];
return bsearch(prefixsum, n, k);
}
var arr = [ 1, 2, 10, 4 ];
var n = arr.length;
var k = 14;
document.write(maxSize(arr, n, k));
</script>
|
Time Complexity: O(n log n), where N represents the size of the given array.
Auxiliary Space: O(n), where N represents the size of the given array.
Efficient Approach: This method uses the Sliding Window Technique to solve the given problem.
- The approach is to find the minimum subarray size whose sum is greater than integer k.
- Increase the window size from the end up to which the sum of that window is greater than k.
- Now, store that subarray size if it is smaller than the already stored subarray size (in variable ans).
- Now, decrement the subarray size from the beginning. The variable ans will store the minimum subarray size whose sum is greater than k.
- At last, (ans-1) is the actual answer. Then, that subarray size – 1 is the maximum subarray size, such that all subarray of that size will have sum less than or equal to k.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void func(vector< int > arr,
int k, int n)
{
int ans = n;
int sum = 0;
int start = 0;
for ( int end = 0; end < n; end++)
{
sum += arr[end];
while (sum > k) {
sum -= arr[start];
start++;
ans = min(ans, end - start + 1);
if (sum == 0)
break ;
}
if (sum == 0) {
ans = -1;
break ;
}
}
cout << ans;
}
int main()
{
vector< int > arr{ 1, 2, 3, 4 };
int k = 8;
int n = arr.size();
func(arr, k, n);
return 0;
}
|
Java
import java.io.*;
class GFG{
public static void func( int arr[],
int k, int n)
{
int ans = n;
int sum = 0 ;
int start = 0 ;
for ( int end = 0 ; end < n; end++)
{
sum += ( int )arr[end];
while (sum > k)
{
sum -= ( int )arr[start];
start++;
ans = Math.min(ans, end - start + 1 );
if (sum == 0 )
break ;
}
if (sum == 0 )
{
ans = - 1 ;
break ;
}
}
System.out.println(ans);
}
public static void main (String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 };
int k = 8 ;
int n = arr.length;
func(arr, k, n);
}
}
|
Python3
def func(arr, k, n):
ans = n
Sum = 0
start = 0
for end in range (n):
Sum + = arr[end]
while ( Sum > k):
Sum - = arr[start]
start + = 1
ans = min (ans, end - start + 1 )
if ( Sum = = 0 ):
break
if ( Sum = = 0 ):
ans = - 1
break
print (ans)
arr = [ 1 , 2 , 3 , 4 ]
k = 8
n = len (arr)
func(arr, k, n)
|
C#
using System;
using System.Collections;
class GFG{
static void func(ArrayList arr,
int k, int n)
{
int ans = n;
int sum = 0;
int start = 0;
for ( int end = 0; end < n; end++)
{
sum += ( int )arr[end];
while (sum > k)
{
sum -= ( int )arr[start];
start++;
ans = Math.Min(ans, end - start + 1);
if (sum == 0)
break ;
}
if (sum == 0)
{
ans = -1;
break ;
}
}
Console.Write(ans);
}
public static void Main( string [] args)
{
ArrayList arr = new ArrayList(){ 1, 2, 3, 4 };
int k = 8;
int n = arr.Count;
func(arr, k, n);
}
}
|
Javascript
<script>
function func(arr, k, n)
{
let ans = n;
let sum = 0;
let start = 0;
for (let end = 0; end < n; end++)
{
sum += arr[end];
while (sum > k) {
sum -= arr[start];
start++;
ans = Math.min(ans, end - start + 1);
if (sum == 0)
break ;
}
if (sum == 0) {
ans = -1;
break ;
}
}
document.write(ans);
}
let arr = [ 1, 2, 3, 4 ];
let k = 8;
let n = arr.length;
func(arr, k, n);
</script>
|
Time Complexity: O(N), where N represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.
Last Updated :
06 Jul, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...