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 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. 

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find maximum
// subarray size, such that all
// subarrays of that size have
// sum less than K.
#include<bits/stdc++.h>
using namespace std;
 
// Search for the maximum length of
// required subarray.
int bsearch(int prefixsum[], int n,
                             int k)
{
    // Initialize result
    int ans = -1;
 
    // Do Binary Search for largest
    // subarray size
    int left = 1, right = n;
    while (left <= right)
    {
        int mid = (left + right) / 2;
 
        // Check for all subarrays after mid
        int i;
        for (i = mid; i <= n; i++)
        {
            // Checking if all the subarrays
            //  of a size less than k.
            if (prefixsum[i] - prefixsum[i - mid] > k)
                break;
        }
 
        // All subarrays of size mid have
        // sum less than or equal to k
        if (i == n + 1)
        {
            left = mid + 1;
            ans = mid;
        }
 
        // We found a subrray of size mid
        // with sum greater than k
        else
            right = mid - 1;
    }
    return ans;
}
 
// Return the maximum subarray size,
// such that all subarray of that size
// have sum less than K.
int maxSize(int arr[], int n, int k)
{
    // Initialize prefix sum array as 0.
    int prefixsum[n + 1];
    memset(prefixsum, 0, sizeof(prefixsum));
 
    // Finding prefix sum of the array.
    for (int i = 0; i < n; i++)
        prefixsum[i + 1] = prefixsum[i] +
                           arr[i];
 
    return bsearch(prefixsum, n, k);
}
 
// Driver code
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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find maximum
// subarray size, such that all
// subarrays of that size have
// sum less than K.
import java.util.Arrays;
 
class GFG
{
     
    // Search for the maximum length
    // of required subarray.
    static int bsearch(int prefixsum[],
                       int n, int k)
    {
        // Initialize result
        int ans = -1;
 
        // Do Binary Search for largest
        // subarray size
        int left = 1, right = n;
         
        while (left <= right)
        {
            int mid = (left + right) / 2;
 
            // Check for all subarrays after mid
            int i;
            for (i = mid; i <= n; i++)
            {
                 
                // Checking if all the subarrays
                // of a size is less than k.
                if (prefixsum[i] - prefixsum[i - mid] > k)
                    break;
            }
 
            // All subarrays of size mid have
            // sum less than or equal to k
            if (i == n + 1)
            {
                left = mid + 1;
                ans = mid;
            }
 
            // We found a subrray of size mid
            // with sum greater than k
            else
                right = mid - 1;
        }
 
        return ans;
    }
 
    // Return the maximum subarray size, such
    // that all subarray of that size have
    // sum less than K.
    static int maxSize(int arr[], int n, int k)
    {
         
        // Initialize prefix sum array as 0.
        int prefixsum[] = new int[n + 1];
        Arrays.fill(prefixsum, 0);
 
        // Finding prefix sum of the array.
        for (int i = 0; i < n; i++)
            prefixsum[i + 1] = prefixsum[i] + arr[i];
 
        return bsearch(prefixsum, n, k);
    }
     
    // Driver code
    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));
    }
}
 
// This code is contributed by Anant Agarwal.
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find maximum
# subarray size, such that all
# subarrays of that size have
# sum less than K.
 
# Search for the maximum length of
# required subarray.
def bsearch(prefixsum, n, k):
 
    # Initialize result
    # Do Binary Search for largest
    # subarray size
    ans, left, right = -1, 1, n
 
    while (left <= right):
 
        # Check for all subarrays after mid
        mid = (left + right)//2
 
        for i in range(mid, n + 1):
 
            # Checking if all the subarray of
            # a size is less than k.
            if (prefixsum[i] - prefixsum[i - mid] > k):
                i = i - 1
                break
        i = i + 1
        if (i == n + 1):
            left = mid + 1
            ans = mid
        # We found a subrray of size mid with sum
        # greater than k
        else:
            right = mid - 1
 
    return ans;
 
# Return the maximum subarray size, such
# that all subarray of that size have
# sum less than K.
def maxSize(arr, n, k):
    prefixsum = [0 for x in range(n + 1)]
     
    # Finding prefix sum of the array.
    for i in range(n):
        prefixsum[i + 1] = prefixsum[i] + arr[i]
 
    return bsearch(prefixsum, n, k);
 
# Driver Code
arr = [ 1, 2, 10, 4 ]
n = len(arr)
k = 14
print (maxSize(arr, n, k))
 
# This code is contributed by Afzal
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find maximum
// subarray size, such that all
// subarrays of that size have
// sum less than K.
using System;
 
class GFG {
     
    // Search for the maximum length
    // of required subarray.
    static int bsearch(int []prefixsum,
                          int n, int k)
    {
         
        // Initialize result
        int ans = -1;
 
        // Do Binary Search for
        // largest subarray size
        int left = 1, right = n;
         
        while (left <= right)
        {
            int mid = (left + right) / 2;
 
            // Check for all subarrays
            // after mid
            int i;
            for (i = mid; i <= n; i++)
            {
                 
                // Checking if all the
                // subarrays of a size is
                // less than k.
                if (prefixsum[i] -
                     prefixsum[i - mid] > k)
                    break;
            }
 
            // All subarrays of size mid have
            // sum less than or equal to k
            if (i == n + 1)
            {
                left = mid + 1;
                ans = mid;
            }
 
            // We found a subrray of size mid
            // with sum greater than k
            else
                right = mid - 1;
        }
 
        return ans;
    }
 
    // Return the maximum subarray size, such
    // that all subarray of that size have
    // sum less than K.
    static int maxSize(int []arr, int n, int k)
    {
         
        // Initialize prefix sum array as 0.
        int []prefixsum = new int[n + 1];
        for(int i=0;i<n+1;i++)
        prefixsum[i]=0;
         
 
        // Finding prefix sum of the array.
        for (int i = 0; i < n; i++)
            prefixsum[i + 1] = prefixsum[i]
                                     + arr[i];
 
        return bsearch(prefixsum, n, k);
    }
     
    // Driver code
    public static void Main()
    {
        int []arr = { 1, 2, 10, 4 };
        int n = arr.Length;
        int k = 14;
         
        Console.Write(maxSize(arr, n, k));
    }
}
 
// This code is contributed by nitin mittal.
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find maximum subarray
// size, such that all subarrays of that
// size have sum less than K.
 
// Search for the maximum length of
// required subarray.
function bsearch(&$prefixsum, $n, $k)
{
    // Initialize result
    $ans = -1;
 
    // Do Binary Search for largest
    // subarray size
    $left = 1;
    $right = $n;
    while ($left <= $right)
    {
        $mid = intval(($left + $right) / 2);
 
        // Check for all subarrays after mid
        for ($i = $mid; $i <= $n; $i++)
        {
            // Checking if all the subarrays
            // of a size less than k.
            if ($prefixsum[$i] - $prefixsum[$i -
                                 $mid] > $k)
                break;
        }
 
        // All subarrays of size mid have
        // sum less than or equal to k
        if ($i == $n + 1)
        {
            $left = $mid + 1;
            $ans = $mid;
        }
 
        // We found a subrray of size mid
        // with sum greater than k
        else
            $right = $mid - 1;
    }
    return $ans;
}
 
// Return the maximum subarray size,
// such that all subarray of that size
// have sum less than K.
function maxSize(&$arr, $n, $k)
{
    // Initialize prefix sum array as 0.
    $prefixsum = array_fill(0, $n + 1, NULL);
 
    // Finding prefix sum of the array.
    for ($i = 0; $i < $n; $i++)
        $prefixsum[$i + 1] = $prefixsum[$i] +
                             $arr[$i];
 
    return bsearch($prefixsum, $n, $k);
}
 
// Driver code
$arr = array(1, 2, 10, 4);
$n = sizeof($arr);
$k = 14;
echo maxSize($arr, $n, $k) . "\n";
 
// This code is contributed
// by ChitraNayal
?>
chevron_right

Output

2

Time Complexity: O(n log n)

Efficient Approach: This method uses the Sliding Window Technique to solve the given problem. 

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the
// largest size subarray
void func(vector<int> arr,
          int k, int n)
{
    // Variable declaration
    int ans = n;
    int sum = 0;
    int start = 0;
 
    // Loop till N
    for (int end = 0; end < n; end++)
    {
        // Sliding window from left
        sum += arr[end];
 
        while (sum > k) {
            // Sliding window from right
            sum -= arr[start];
            start++;
 
            // Storing sub-array size - 1
            // for which sum was greater than k
            ans = min(ans, end - start + 1);
 
            // Sum will be 0 if start>end
            // because all elements are positive
            // start>end only when arr[end]>k i.e,
            // there is an array element with
            // value greater than k, so sub-array
            // sum cannot be less than k.
            if (sum == 0)
                break;
        }
        if (sum == 0) {
            ans = -1;
            break;
        }
    }
 
    // Print the answer
    cout << ans;
}
 
// Driver code
int main()
{
    vector<int> arr{ 1, 2, 3, 4 };
    int k = 8;
    int n = arr.size();
 
    // Function call
    func(arr, k, n);
 
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections;
 
class GFG{
      
// Function to find the
// largest size subarray
static void func(ArrayList arr,
                 int k, int n)
{
     
    // Variable declaration
    int ans = n;
    int sum = 0;
    int start = 0;
  
    // Loop till N
    for(int end = 0; end < n; end++)
    {
         
        // Sliding window from left
        sum += (int)arr[end];
  
        while (sum > k)
        {
             
            // Sliding window from right
            sum -= (int)arr[start];
            start++;
  
            // Storing sub-array size - 1
            // for which sum was greater than k
            ans = Math.Min(ans, end - start + 1);
  
            // Sum will be 0 if start>end
            // because all elements are positive
            // start>end only when arr[end]>k i.e,
            // there is an array element with
            // value greater than k, so sub-array
            // sum cannot be less than k.
            if (sum == 0)
                break;
        }
        if (sum == 0)
        {
            ans = -1;
            break;
        }
    }
     
    // Print the answer
    Console.Write(ans);
}
  
// Driver code
public static void Main(string[] args)
{
    ArrayList arr = new ArrayList(){ 1, 2, 3, 4 };
    int k = 8;
    int n = arr.Count;
  
    // Function call
    func(arr, k, n);
}
}
 
// This code is contributed by rutvik_56
chevron_right

Output
2

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




Recommended Posts:


Article Tags :