Maximum subarray size having all subarrays sums less than k
Last Updated : 07 Mar, 2025
Given an array of positive integers arr[] of size n, and an integer k. The task is to find the maximum subarray size such that all subarrays of that size have sum less than or equals to k.
Examples :
Input : arr[] = [1, 2, 3, 4], k = 8.
Output : 2
Explanation: Following are the sum of subarray of size 1 to 4.
- 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], k = 8.
Output : -1
Explanation: There is an array element (10) with value greater than k, so subarray sum cannot be less than k.
Input : arr[] = [1, 2, 10, 4], k = 14
Output : 2
[Naive Approach] - Using Nested Loops - O(n ^ 3) Time and O(1) Space
The idea is to generate all possible subarrays of all sizes and find sum of their elements. To do so, use three nested loops, where the outer most loops marks the size of the subarray, the middle loop marks the starting index of the subarray, and the inner loops marks the last index of the subarray.
For any integer x in range [1, n], if all the subarrays of array arr[] of size x, has sum of there elements less than or equals to k, store the value x in answer and move to x + 1. At last print the result.
C++ #include <bits/stdc++.h> using namespace std; // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. int maxSubarraySize(vector<int> &arr, int k) { int n = arr.size(); // to store the answer int ans = -1; // generate all possible subarrays for(int i = 1; i <= n; i++) { // to store the max sum of all // possible subarrays of size i int maxSum = INT_MIN; for(int j = 0; j < n - i + 1; j++) { // calculate the sum of the subarray int sum = 0; for(int l = j; l < j + i; l++) { sum += arr[l]; } // update the max sum maxSum = max(maxSum, sum); } // if the maxSum is less than or equals to k if(maxSum <= k) { ans = max(ans, i); } } return ans; } int main() { vector<int> arr = {1, 2, 3, 4}; int k = 8; cout << maxSubarraySize(arr, k) << endl; return 0; } // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. import java.util.*; class GfG { // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. static int maxSubarraySize(int[] arr, int k) { int n = arr.length; // to store the answer int ans = -1; // generate all possible subarrays for (int i = 1; i <= n; i++) { // to store the max sum of all // possible subarrays of size i int maxSum = Integer.MIN_VALUE; for (int j = 0; j < n - i + 1; j++) { // calculate the sum of the subarray int sum = 0; for (int l = j; l < j + i; l++) { sum += arr[l]; } // update the max sum maxSum = Math.max(maxSum, sum); } // if the maxSum is less than or equals to k if (maxSum <= k) { ans = Math.max(ans, i); } } return ans; } public static void main(String[] args) { int[] arr = {1, 2, 3, 4}; int k = 8; System.out.println(maxSubarraySize(arr, k)); } } # Function to find the maximum subarray # size such that all subarrays of that # size have sum less than or equals to k. def maxSubarraySize(arr, k): n = len(arr) # to store the answer ans = -1 # generate all possible subarrays for i in range(1, n + 1): # to store the max sum of all # possible subarrays of size i maxSum = float('-inf') for j in range(0, n - i + 1): # calculate the sum of the subarray sum = 0 for l in range(j, j + i): sum += arr[l] # update the max sum maxSum = max(maxSum, sum) # if the maxSum is less than or equals to k if maxSum <= k: ans = max(ans, i) return ans if __name__ == "__main__": arr = [1, 2, 3, 4] k = 8 print(maxSubarraySize(arr, k)) // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. using System; using System.Collections.Generic; class GfG { // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. static int maxSubarraySize(int[] arr, int k) { int n = arr.Length; // to store the answer int ans = -1; // generate all possible subarrays for (int i = 1; i <= n; i++) { // to store the max sum of all // possible subarrays of size i int maxSum = int.MinValue; for (int j = 0; j < n - i + 1; j++) { // calculate the sum of the subarray int sum = 0; for (int l = j; l < j + i; l++) { sum += arr[l]; } // update the max sum maxSum = Math.Max(maxSum, sum); } // if the maxSum is less than or equals to k if (maxSum <= k) { ans = Math.Max(ans, i); } } return ans; } static void Main() { int[] arr = {1, 2, 3, 4}; int k = 8; Console.WriteLine(maxSubarraySize(arr, k)); } } // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. function maxSubarraySize(arr, k) { let n = arr.length; // to store the answer let ans = -1; // generate all possible subarrays for (let i = 1; i <= n; i++) { // to store the max sum of all // possible subarrays of size i let maxSum = -Infinity; for (let j = 0; j < n - i + 1; j++) { // calculate the sum of the subarray let sum = 0; for (let l = j; l < j + i; l++) { sum += arr[l]; } // update the max sum maxSum = Math.max(maxSum, sum); } // if the maxSum is less than or equals to k if (maxSum <= k) ans = Math.max(ans, i); } return ans; } let arr = [1, 2, 3, 4]; let k = 8; console.log(maxSubarraySize(arr, k)); [Better Approach] - Using Binary Search and Sliding Window - O(n * log n) Time and O(1) Space
It can be observed that if for any integer x, all subarrays of size x have the sum of there elements less than or equals to k, then x - 1 will also satisfy the condition. Similarly, if x does not satisfy the condition then x + 1 will also not work. Thus we can apply binary search in range 1 to n, to find the max integer x that satisfies the required condition.
Follow the below given steps to solve the problem:
- Create two counters, low and high, and set their values to 1 and n respectively.
- Now run a loop until low <= high
- In each iteration, find the mid of low and high, i.e. (low + high) / 2.
- Now using sliding window approach, find the maximum possible sum of a subarray of size mid.
- If maxSum <= k, then set low = mid + 1, as we can increase the size of subarray.
- Else, if maxSum > k, then set high = mid - 1, as we need to reduce the size of subarray.
- The loop breaks when low > high, and high stores the final result.
C++ #include <bits/stdc++.h> using namespace std; // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. int maxSubarraySize(vector<int> &arr, int k) { int n = arr.size(); // initialize the low and high pointers int low = 1, high = n; // perform binary search while(low <= high) { int mid = low + (high - low) / 2; // to store the sum of the subarray int sum = 0; // to store the max sum of all // possible subarrays of size mid int maxSum = INT_MIN; for(int i = 0; i < n; i++) { sum += arr[i]; if(i >= mid) { sum -= arr[i - mid]; } if(i >= mid - 1) { maxSum = max(maxSum, sum); } } if(maxSum <= k) low = mid + 1; else high = mid - 1; } if(high == 0) return -1; return high; } int main() { vector<int> arr = {1, 2, 3, 4}; int k = 8; cout << maxSubarraySize(arr, k) << endl; return 0; } // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. import java.util.*; class GfG { // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. static int maxSubarraySize(int[] arr, int k) { int n = arr.length; // initialize the low and high pointers int low = 1, high = n; // perform binary search while(low <= high) { int mid = low + (high - low) / 2; // to store the sum of the subarray int sum = 0; // to store the max sum of all // possible subarrays of size mid int maxSum = Integer.MIN_VALUE; for(int i = 0; i < n; i++) { sum += arr[i]; if(i >= mid) { sum -= arr[i - mid]; } if(i >= mid - 1) { maxSum = Math.max(maxSum, sum); } } if(maxSum <= k) low = mid + 1; else high = mid - 1; } if(high == 0) return -1; return high; } public static void main(String[] args) { int[] arr = {1, 2, 3, 4}; int k = 8; System.out.println(maxSubarraySize(arr, k)); } } # Function to find the maximum subarray # size such that all subarrays of that # size have sum less than or equals to k. def maxSubarraySize(arr, k): n = len(arr) # initialize the low and high pointers low = 1 high = n # perform binary search while low <= high: mid = low + (high - low) // 2 # to store the sum of the subarray sum_val = 0 # to store the max sum of all # possible subarrays of size mid maxSum = -float('inf') for i in range(n): sum_val += arr[i] if i >= mid: sum_val -= arr[i - mid] if i >= mid - 1: maxSum = max(maxSum, sum_val) if maxSum <= k: low = mid + 1 else: high = mid - 1 if high == 0: return -1 return high if __name__ == "__main__": arr = [1, 2, 3, 4] k = 8 print(maxSubarraySize(arr, k)) // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. using System; using System.Collections.Generic; class GfG { // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. static int maxSubarraySize(int[] arr, int k) { int n = arr.Length; // initialize the low and high pointers int low = 1, high = n; // perform binary search while (low <= high) { int mid = low + (high - low) / 2; // to store the sum of the subarray int sum = 0; // to store the max sum of all // possible subarrays of size mid int maxSum = int.MinValue; for (int i = 0; i < n; i++) { sum += arr[i]; if (i >= mid) { sum -= arr[i - mid]; } if (i >= mid - 1) { maxSum = Math.Max(maxSum, sum); } } if (maxSum <= k) low = mid + 1; else high = mid - 1; } if (high == 0) return -1; return high; } static void Main() { int[] arr = {1, 2, 3, 4}; int k = 8; Console.WriteLine(maxSubarraySize(arr, k)); } } // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. function maxSubarraySize(arr, k) { let n = arr.length; // initialize the low and high pointers let low = 1, high = n; // perform binary search while (low <= high) { let mid = low + Math.floor((high - low) / 2); // to store the sum of the subarray let sum = 0; // to store the max sum of all // possible subarrays of size mid let maxSum = -Infinity; for (let i = 0; i < n; i++) { sum += arr[i]; if (i >= mid) { sum -= arr[i - mid]; } if (i >= mid - 1) { maxSum = Math.max(maxSum, sum); } } if (maxSum <= k) low = mid + 1; else high = mid - 1; } if (high === 0) return -1; return high; } let arr = [1, 2, 3, 4]; let k = 8; console.log(maxSubarraySize(arr, k)); [Expected Approach] - Using Sliding Window - O(n) Time and O(1) Space
The approach is to find the minimum subarray size whose sum is greater than integer k. Out result will be this window size - 1.
- Create two counters, start and end, to store the starting and ending point of the current subarray.
- Also create two variables, sum and minLen, to store the sum of current subarray and the minimum length of subarray with sum of its elements greater than k respectively.
- Initialize start and end with 0
- Now, run a loop until end < n, and in each iteration add arr[end] to sum and increment end by 1.
- While sum > k, store the minimum of minLen and end - start, subtract arr[start] from sum, and increment start by 1.
- The loop breaks when end >= n, and minLen - 1 is the final answer.
C++ #include <bits/stdc++.h> using namespace std; // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. int maxSubarraySize(vector<int> &arr, int k) { int n = arr.size(); // to store the start and end // point of the subarray int start = 0, end = 0; // to store the sum of subarray int sum = 0; // to store the minimum size of // subarray with sum greater than k int minLen = n + 1; // using sliding window technique // to find the subarray while(end < n) { // add the current element to the sum // and increase the end pointer sum += arr[end]; end++; // if the sum is greater than k while(sum > k) { minLen = min(minLen, end - start); sum -= arr[start]; start++; } } int ans = minLen - 1; if(ans == 0) return -1; return ans; } int main() { vector<int> arr = {1, 2, 3, 4}; int k = 8; cout << maxSubarraySize(arr, k) << endl; return 0; } // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. import java.util.*; class GfG { // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. static int maxSubarraySize(int[] arr, int k) { int n = arr.length; // to store the start and end // point of the subarray int start = 0, end = 0; // to store the sum of subarray int sum = 0; // to store the minimum size of // subarray with sum greater than k int minLen = n + 1; // using sliding window technique // to find the subarray while(end < n) { // add the current element to the sum // and increase the end pointer sum += arr[end]; end++; // if the sum is greater than k while(sum > k) { minLen = Math.min(minLen, end - start); sum -= arr[start]; start++; } } int ans = minLen - 1; if(ans == 0) return -1; return ans; } public static void main(String[] args) { int[] arr = {1, 2, 3, 4}; int k = 8; System.out.println(maxSubarraySize(arr, k)); } } # Function to find the maximum subarray # size such that all subarrays of that # size have sum less than or equals to k. def maxSubarraySize(arr, k): n = len(arr) # to store the start and end # point of the subarray start = 0 end = 0 # to store the sum of subarray sum_val = 0 # to store the minimum size of # subarray with sum greater than k minLen = n + 1 # using sliding window technique # to find the subarray while end < n: # add the current element to the sum # and increase the end pointer sum_val += arr[end] end += 1 # if the sum is greater than k while sum_val > k: minLen = min(minLen, end - start) sum_val -= arr[start] start += 1 ans = minLen - 1 if ans == 0: return -1 return ans if __name__ == "__main__": arr = [1, 2, 3, 4] k = 8 print(maxSubarraySize(arr, k))
// Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. using System; using System.Collections.Generic; class GfG { // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. static int maxSubarraySize(int[] arr, int k) { int n = arr.Length; // to store the start and end // point of the subarray int start = 0, end = 0; // to store the sum of subarray int sum = 0; // to store the minimum size of // subarray with sum greater than k int minLen = n + 1; // using sliding window technique // to find the subarray while (end < n) { // add the current element to the sum // and increase the end pointer sum += arr[end]; end++; // if the sum is greater than k while (sum > k) { minLen = Math.Min(minLen, end - start); sum -= arr[start]; start++; } } int ans = minLen - 1; if (ans == 0) return -1; return ans; } static void Main() { int[] arr = {1, 2, 3, 4}; int k = 8; Console.WriteLine(maxSubarraySize(arr, k)); } } // Function to find the maximum subarray // size such that all subarrays of that // size have sum less than or equals to k. function maxSubarraySize(arr, k) { let n = arr.length; // to store the start and end // point of the subarray let start = 0, end = 0; // to store the sum of subarray let sum = 0; // to store the minimum size of // subarray with sum greater than k let minLen = n + 1; // using sliding window technique // to find the subarray while (end < n) { // add the current element to the sum // and increase the end pointer sum += arr[end]; end++; // if the sum is greater than k while (sum > k) { minLen = Math.min(minLen, end - start); sum -= arr[start]; start++; } } let ans = minLen - 1; if (ans === 0) return -1; return ans; } let arr = [1, 2, 3, 4]; let k = 8; console.log(maxSubarraySize(arr, k)); Similar Reads
First subarray having sum at least half the maximum sum of any subarray of size K Given an array arr[] and an integer K, the task is to find the first subarray which has a sum greater than or equal to half of the maximum possible sum from any subarray of size K. Examples: Input: arr[] = {2, 4, 5, 1, 4, 6, 6, 2, 1, 0}, K = 3 Output: 6 2 1 Explanation: The given array has a maximum
9 min read
Maximize the subarray sum by choosing M subarrays of size K Given an array arr containing N positive integers, and two integers K and M, the task is to calculate the maximum sum of M subarrays of size K. Example: Input: arr[] = {1, 2, 1, 2, 6, 7, 5, 1}, M = 3, K = 2Output: 33Explanation: The three chosen subarrays are [2, 6], [6, 7] and [7, 5] respectively.
6 min read
Maximum sum subarray having sum less than given sum using Set Given an array arr[] of length N and an integer K, the task is the find the maximum sum subarray with a sum less than K.Note: If K is less than the minimum element, then return INT_MIN. Examples: Input: arr[] = {-1, 2, 2}, K = 4 Output: 3 Explanation: The subarray with maximum sum which is less than
7 min read
Maximum sum subarray having sum less than or equal to given sum You are given an array of non-negative integers and a target sum. Your task is to find a contiguous subarray whose sum is the maximum possible, while ensuring that it does not exceed the given target sum.Note: The given array contains only non-negative integers.Examples: Input: arr[] = [1, 2, 3, 4,
6 min read
Maximum sum subarray of size K with sum less than X Given an array arr[] and two integers K and X, the task is to find the maximum sum among all subarrays of size K with the sum less than X. Examples: Input: arr[] = {20, 2, 3, 10, 5}, K = 3, X = 20Output: 18Explanation: Subarray of size 3 having maximum sum less than 20 is {3, 10, 5}. Therefore, requ
7 min read