Maximum subarray size, such that all subarrays of that size have sum less than k - GeeksforGeeks

07 Sep, 2021
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.
Below is the implementation of the above approach:
C++
Java
Python3
C#
PHP
Javascript
// 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 subarray 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 codeint 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 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 subarray 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.
# Python3 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 subarray 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 Codearr = [ 1, 2, 10, 4 ]n = len(arr)k = 14print (maxSize(arr, n, k)) # This code is contributed by Afzal
// 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 subarray 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.
<?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 subarray 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?>
<script> // javascript 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        var ans = -1;         // Do Binary Search for largest        // subarray size        var left = 1, right = n;         while (left <= right) {            var mid = parseInt((left + right) / 2);             // Check for all subarrays after mid            var 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 subarray 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.        var prefixsum = Array(n + 1).fill(0);             // 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        var arr = [ 1, 2, 10, 4 ];        var n = arr.length;        var k = 14;        document.write(maxSize(arr, n, k)); // This code contributed by Rajput-Ji </script>
2
Time Complexity: O(n log n)
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.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to find the// largest size subarrayvoid 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 codeint main(){    vector<int> arr{ 1, 2, 3, 4 };    int k = 8;    int n = arr.size();     // Function call    func(arr, k, n);     return 0;}
// Java program for the above approachimport java.io.*; class GFG{     // Function to find the// largest size subarraypublic static void func(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 += (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    System.out.println(ans);} // Driver codepublic static void main (String[] args){    int arr[] = { 1, 2, 3, 4 };    int k = 8;    int n = arr.length;         // Function call    func(arr, k, n);}} // This code is contributed by rag2127
# Python3 program for the above approach # Function to find the# largest size subarraydef func(arr, k, n):         # Variable declaration    ans = n    Sum = 0    start = 0     # Loop till N    for end in range(n):         # Sliding window from left        Sum += arr[end]         while (Sum > k):                         # Sliding window from right            Sum -= arr[start]            start += 1             # 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    print(ans) # Driver codearr = [ 1, 2, 3, 4 ]k = 8n = len(arr) # Function callfunc(arr, k, n) # This code is contributed by avanitrachhadiya2155
// C# program for the above approachusing System;using System.Collections; class GFG{      // Function to find the// largest size subarraystatic 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 codepublic 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
<script>// Javascript program for the above approach // Function to find the// largest size subarrayfunction func(arr, k, n){    // Variable declaration    let ans = n;    let sum = 0;    let start = 0;     // Loop till N    for (let 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 = 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    document.write(ans);} // Driver code    let arr = [ 1, 2, 3, 4 ];    let k = 8;    let n = arr.length;     // Function call    func(arr, k, n);     </script>
2
Time Complexity: O(N)
Guibao Wang
nitin mittal
ukasp
avinashraghuthu
ishanagarwal5
rutvik_56
avanitrachhadiya2155
rag2127
Rajput-Ji
subhammahato348
kk773572498
Binary Search
prefix-sum
subarray
subarray-sum
Arrays
prefix-sum
Arrays
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Arrays
Multidimensional Arrays in Java
Linear Search
Linked List vs Array
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Python | Using 2D arrays/lists the right way
Search an element in a sorted and rotated array
Array of Strings in C++ (5 Different Ways to Create)
Queue | Set 1 (Introduction and Array Implementation)
Find the Missing Number