Count of subarrays with sum at least K

Largest sum subarray of size at least k

Last Updated : 15 Feb, 2025

Try it on GfG Practice

Given an array and an integer k, the task is to find the sum of elements of a subarray containing at least k elements which has the largest sum.

Examples:

Input : arr[] = {-4, -2, 1, -3}, k = 2
Output : -1
Explanation : The sub array is {-2, 1}.

Input : arr[] = {1, 1, 1, 1, 1, 1} , k = 2
Output : 6
Explanation : The sub array is {1, 1, 1, 1, 1, 1}

[Naive Approach] – O(n^2) Time and O(1) Space

The idea is simple, we consider every point as starting point and all subarrays of size k or more. We keep track of the maximum sum and return it at the end.

C++

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int maxSum(vector<int> &arr, int k) {
    int n = arr.size(), res = INT_MIN;

    // Iterate over all possible starting points
    for (int i = 0; i < n; i++) {
        
        int sum = 0;
        
        for (int j = i; j < n; j++) {
            sum += arr[j];
            
            // If size of current subarray is k
            // or more
            if (j - i + 1 >= k) res = max(res, sum);
        }
    }
    return res;
}

int main() {
    vector<int> arr = {-4, -2, 1, -3};
    int k = 2;
    cout << maxSum(arr, k) << endl;
    return 0;
}

Java

import java.util.*;

public class Main {
    public static int maxSum(int[] arr, int k) {
        int n = arr.length, res = Integer.MIN_VALUE;

        // Iterate over all possible starting points
        for (int i = 0; i < n; i++) {
            int sum = 0;
            
            for (int j = i; j < n; j++) {
                sum += arr[j];
                
                // If size of current subarray is k
                // or more
                if (j - i + 1 >= k) res = Math.max(res, sum);
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int[] arr = {-4, -2, 1, -3};
        int k = 2;
        System.out.println(maxSum(arr, k));
    }
}

Python

def max_sum(arr, k):
    n = len(arr)
    res = float('-inf')

    # Iterate over all possible starting points
    for i in range(n):
        sum_ = 0
        
        for j in range(i, n):
            sum_ += arr[j]
            
            # If size of current subarray is k
            # or more
            if j - i + 1 >= k:
                res = max(res, sum_)
    return res

arr = [-4, -2, 1, -3]
k = 2
print(max_sum(arr, k))

C#

using System;
using System.Linq;

class Program {
    static int MaxSum(int[] arr, int k) {
        int n = arr.Length, res = int.MinValue;

        // Iterate over all possible starting points
        for (int i = 0; i < n; i++) {
            int sum = 0;
            
            for (int j = i; j < n; j++) {
                sum += arr[j];
                
                // If size of current subarray is k
                // or more
                if (j - i + 1 >= k) res = Math.Max(res, sum);
            }
        }
        return res;
    }

    static void Main() {
        int[] arr = {-4, -2, 1, -3};
        int k = 2;
        Console.WriteLine(MaxSum(arr, k));
    }
}

JavaScript

function maxSum(arr, k) {
    let n = arr.length, res = Number.NEGATIVE_INFINITY;

    // Iterate over all possible starting points
    for (let i = 0; i < n; i++) {
        let sum = 0;
        
        for (let j = i; j < n; j++) {
            sum += arr[j];
            
            // If size of current subarray is k
            // or more
            if (j - i + 1 >= k) res = Math.max(res, sum);
        }
    }
    return res;
}

let arr = [-4, -2, 1, -3];
let k = 2;
console.log(maxSum(arr, k));

Output

-1

[Better Approach] Kadane’s Algorithm + Window Sliding – O(n) Time and O(n) Space

The idea is to find a subarray with at least k elements having the maximum possible sum, by combining Kadane’s algorithm with a sliding window approach. We first compute the maximum sum achievable up to each index using Kadane’s algorithm, then use a sliding window of size k to find sums of consecutive k elements, and for each window we also consider including the maximum sum achievable before that window to potentially get a larger subarray sum.

Step by step approach:

Initialize maxSum[] array using Kadane’s algorithm to store maximum sum achievable up to each index.
Calculate initial sum of first k elements as starting window.
Slide the window one element at a time, updating window sum by adding new element and removing first element.
For each window position, consider two possibilities: either take just the window sum, or window sum plus maxSum up to index (i-k).
Keep track of maximum sum seen so far as the result.
Return the final maximum sum that represents the largest subarray sum with at least k elements.

Below is the implementation of above approach:

C++

// C++ program to find largest subarray sum with
// at-least k elements in it.
#include <bits/stdc++.h>
using namespace std;

int maxSumWithK(vector<int>& arr, int k) {
    int n = arr.size();
    
    // maxSum[i] stores maximum sum till index i
    vector<int> maxSum(n);
    maxSum[0] = arr[0];
    
    // Use Kadane's algorithm to fill maxSum[]
    int currMax = arr[0];
    for (int i = 1; i < n; i++) {
        currMax = max(arr[i], currMax + arr[i]);
        maxSum[i] = currMax;
    }
    
    // Sum of first k elements
    int sum = 0;
    for (int i = 0; i < k; i++) {
        sum += arr[i];
    }
    
    // Use sliding window concept
    int result = sum;
    for (int i = k; i < n; i++) {
        
        // Compute sum of k elements ending with a[i]
        sum = sum + arr[i] - arr[i-k];
        
        // Update result if required
        result = max(result, sum);
        
        // Include maximum sum till [i-k] 
        // if it increases overall max
        result = max(result, sum + maxSum[i-k]);
    }
    
    return result;
}

int main() {
    vector<int> arr = {-4, -2, 1, -3};
    int k = 2;
    cout << maxSumWithK(arr, k);
    return 0;
}

Java

// Java program to find largest subarray sum with
// at-least k elements in it.
import java.util.*;

class GfG {
    static int maxSumWithK(int[] arr, int k) {
        int n = arr.length;
        
        // maxSum[i] stores maximum sum till index i
        int[] maxSum = new int[n];
        maxSum[0] = arr[0];

        // Use Kadane's algorithm to fill maxSum[]
        int currMax = arr[0];
        for (int i = 1; i < n; i++) {
            currMax = Math.max(arr[i], currMax + arr[i]);
            maxSum[i] = currMax;
        }

        // Sum of first k elements
        int sum = 0;
        for (int i = 0; i < k; i++) {
            sum += arr[i];
        }

        // Use sliding window concept
        int result = sum;
        for (int i = k; i < n; i++) {

            // Compute sum of k elements ending with arr[i]
            sum = sum + arr[i] - arr[i - k];

            // Update result if required
            result = Math.max(result, sum);

            // Include maximum sum till [i-k] 
            // if it increases overall max
            result = Math.max(result, sum + maxSum[i - k]);
        }

        return result;
    }

    public static void main(String[] args) {
        int[] arr = {-4, -2, 1, -3};
        int k = 2;
        System.out.println(maxSumWithK(arr, k));
    }
}

Python

# Python program to find largest subarray sum with
# at-least k elements in it.

def maxSumWithK(arr, k):
    n = len(arr)

    # maxSum[i] stores maximum sum till index i
    maxSum = [0] * n
    maxSum[0] = arr[0]

    # Use Kadane's algorithm to fill maxSum[]
    currMax = arr[0]
    for i in range(1, n):
        currMax = max(arr[i], currMax + arr[i])
        maxSum[i] = currMax

    # Sum of first k elements
    sum = 0
    for i in range(k):
        sum += arr[i]

    # Use sliding window concept
    result = sum
    for i in range(k, n):

        # Compute sum of k elements ending with arr[i]
        sum = sum + arr[i] - arr[i - k]

        # Update result if required
        result = max(result, sum)

        # Include maximum sum till [i-k] 
        # if it increases overall max
        result = max(result, sum + maxSum[i - k])

    return result

if __name__ == "__main__":
    arr = [-4, -2, 1, -3]
    k = 2
    print(maxSumWithK(arr, k))

C#

// C# program to find largest subarray sum with
// at-least k elements in it.
using System;

class GfG {
    static int maxSumWithK(int[] arr, int k) {
        int n = arr.Length;
        
        // maxSum[i] stores maximum sum till index i
        int[] maxSum = new int[n];
        maxSum[0] = arr[0];

        // Use Kadane's algorithm to fill maxSum[]
        int currMax = arr[0];
        for (int i = 1; i < n; i++) {
            currMax = Math.Max(arr[i], currMax + arr[i]);
            maxSum[i] = currMax;
        }

        // Sum of first k elements
        int sum = 0;
        for (int i = 0; i < k; i++) {
            sum += arr[i];
        }

        // Use sliding window concept
        int result = sum;
        for (int i = k; i < n; i++) {

            // Compute sum of k elements ending with arr[i]
            sum = sum + arr[i] - arr[i - k];

            // Update result if required
            result = Math.Max(result, sum);

            // Include maximum sum till [i-k] 
            // if it increases overall max
            result = Math.Max(result, sum + maxSum[i - k]);
        }

        return result;
    }

    static void Main() {
        int[] arr = {-4, -2, 1, -3};
        int k = 2;
        Console.WriteLine(maxSumWithK(arr, k));
    }
}

JavaScript

// JavaScript program to find largest subarray sum with
// at-least k elements in it.

function maxSumWithK(arr, k) {
    let n = arr.length;

    // maxSum[i] stores maximum sum till index i
    let maxSum = new Array(n);
    maxSum[0] = arr[0];

    // Use Kadane's algorithm to fill maxSum[]
    let currMax = arr[0];
    for (let i = 1; i < n; i++) {
        currMax = Math.max(arr[i], currMax + arr[i]);
        maxSum[i] = currMax;
    }

    // Sum of first k elements
    let sum = 0;
    for (let i = 0; i < k; i++) {
        sum += arr[i];
    }

    // Use sliding window concept
    let result = sum;
    for (let i = k; i < n; i++) {

        // Compute sum of k elements ending with arr[i]
        sum = sum + arr[i] - arr[i - k];

        // Update result if required
        result = Math.max(result, sum);

        // Include maximum sum till [i-k] 
        // if it increases overall max
        result = Math.max(result, sum + maxSum[i - k]);
    }

    return result;
}

let arr = [-4, -2, 1, -3];
let k = 2;
console.log(maxSumWithK(arr, k));

Output

-1

Time Complexity: O(n)
Auxiliary Space: O(n)

[Optimized and Expected] – O(n) Time and O(1) Space

The idea is to maintain two sliding counters – one for calculating the sum of the current k-sized window, and another for tracking the sum of elements before the window (like Kadane’s algorithm). As we slide through the array, we update both sums, and whenever the sum of elements before the window becomes negative, we discard it since it won’t contribute positively to our overall sum. The maximum sum with at least k elements will either be just the k-sized window sum or the window sum plus some positive sum of elements before it.

C++

// C++ program to find largest subarray sum with
// at-least k elements in it.
#include <bits/stdc++.h>
using namespace std;

int maxSumWithK(vector<int>& arr, int k) {
    
    // Calculate initial sum of 
    // first k elements (first window)
    int sum = 0;
    for (int i = 0; i < k; i++) {
        sum += arr[i];
    }
    
    int last = 0;
    int j = 0;
    int ans = INT_MIN;
    ans = max(ans, sum);
    
    // Process rest of the array after first k elements
    for (int i = k; i < arr.size(); i++) {
        
        // Add current element to window sum
        sum = sum + arr[i];
        
        // Add element at j to 'last' and increment j
        last = last + arr[j++];
        
        // Update answer if current window sum is greater
        ans = max(ans, sum);
        
        // If sum of elements before window becomes negative
        if (last < 0) {
            sum = sum - last;
            ans = max(ans, sum);
            last = 0;
        }
    }
    return ans;
}

int main() {
    vector<int> arr = {-4, -2, 1, -3};
    int k = 2;
    cout << maxSumWithK(arr, k);
    return 0;
}

Java

// Java program to find largest subarray sum with
// at-least k elements in it.
import java.util.*;

class GfG {
    static int maxSumWithK(int[] arr, int k) {
        
        // Calculate initial sum of 
        // first k elements (first window)
        int sum = 0;
        for (int i = 0; i < k; i++) {
            sum += arr[i];
        }
        
        int last = 0;
        int j = 0;
        int ans = Integer.MIN_VALUE;
        ans = Math.max(ans, sum);
        
        // Process rest of the array after first k elements
        for (int i = k; i < arr.length; i++) {
            
            // Add current element to window sum
            sum = sum + arr[i];
            
            // Add element at j to 'last' and increment j
            last = last + arr[j++];
            
            // Update answer if current window sum is greater
            ans = Math.max(ans, sum);
            
            // If sum of elements before window becomes negative
            if (last < 0) {
                sum = sum - last;
                ans = Math.max(ans, sum);
                last = 0;
            }
        }
        return ans;
    }

    public static void main(String[] args) {
        int[] arr = {-4, -2, 1, -3};
        int k = 2;
        System.out.println(maxSumWithK(arr, k));
    }
}

Python

# Python program to find largest subarray sum with
# at-least k elements in it.

def maxSumWithK(arr, k):
    
    # Calculate initial sum of 
    # first k elements (first window)
    sum = 0
    for i in range(k):
        sum += arr[i]

    last = 0
    j = 0
    ans = float('-inf')
    ans = max(ans, sum)

    # Process rest of the array after first k elements
    for i in range(k, len(arr)):

        # Add current element to window sum
        sum = sum + arr[i]

        # Add element at j to 'last' and increment j
        last = last + arr[j]
        j += 1

        # Update answer if current window sum is greater
        ans = max(ans, sum)

        # If sum of elements before window becomes negative
        if last < 0:
            sum = sum - last
            ans = max(ans, sum)
            last = 0

    return ans

if __name__ == "__main__":
    arr = [-4, -2, 1, -3]
    k = 2
    print(maxSumWithK(arr, k))

C#

// C# program to find largest subarray sum with
// at-least k elements in it.
using System;

class GfG {
    static int maxSumWithK(int[] arr, int k) {
        
        // Calculate initial sum of 
        // first k elements (first window)
        int sum = 0;
        for (int i = 0; i < k; i++) {
            sum += arr[i];
        }

        int last = 0;
        int j = 0;
        int ans = int.MinValue;
        ans = Math.Max(ans, sum);

        // Process rest of the array after first k elements
        for (int i = k; i < arr.Length; i++) {

            // Add current element to window sum
            sum = sum + arr[i];

            // Add element at j to 'last' and increment j
            last = last + arr[j++];
            
            // Update answer if current window sum is greater
            ans = Math.Max(ans, sum);

            // If sum of elements before window becomes negative
            if (last < 0) {
                sum = sum - last;
                ans = Math.Max(ans, sum);
                last = 0;
            }
        }
        return ans;
    }

    static void Main() {
        int[] arr = {-4, -2, 1, -3};
        int k = 2;
        Console.WriteLine(maxSumWithK(arr, k));
    }
}

JavaScript

// JavaScript program to find largest subarray sum with
// at-least k elements in it.

function maxSumWithK(arr, k) {

    // Calculate initial sum of 
    // first k elements (first window)
    let sum = 0;
    for (let i = 0; i < k; i++) {
        sum += arr[i];
    }

    let last = 0;
    let j = 0;
    let ans = Number.NEGATIVE_INFINITY;
    ans = Math.max(ans, sum);

    // Process rest of the array after first k elements
    for (let i = k; i < arr.length; i++) {

        // Add current element to window sum
        sum = sum + arr[i];

        // Add element at j to 'last' and increment j
        last = last + arr[j++];
        
        // Update answer if current window sum is greater
        ans = Math.max(ans, sum);

        // If sum of elements before window becomes negative
        if (last < 0) {
            sum = sum - last;
            ans = Math.max(ans, sum);
            last = 0;
        }
    }
    return ans;
}

let arr = [-4, -2, 1, -3];
let k = 2;
console.log(maxSumWithK(arr, k));

Output

-1

Time Complexity: O(n)
Auxiliary Space: O(1)

Count of subarrays with sum at least K

R

Rakesh Kumar

Improve

Article Tags :

Practice Tags :

Similar Reads

Largest product of a subarray of size k

Given an array consisting of n positive integers, and an integer k. Find the largest product subarray of size k, i.e., find the maximum produce of k contiguous elements in the array where k <= n.Examples : Input: arr[] = {1, 5, 9, 8, 2, 4, 1, 8, 1, 2} k = 6Output: 4608 The subarray is {9, 8, 2, 4

Longest subarray having sum K | Set 2

Given an array arr[] of size N containing integers. The task is to find the length of the longest sub-array having sum equal to the given value K. Examples: Input: arr[] = {2, 3, 4, 2, 1, 1}, K = 10 Output: 4 Explanation: The subarray {3, 4, 2, 1} gives summation as 10. Input: arr[] = {6, 8, 14, 9,

Count of subarrays with sum at least K

Given an array arr[] of size N and an integer K > 0. The task is to find the number of subarrays with sum at least K.Examples: Input: arr[] = {6, 1, 2, 7}, K = 10 Output: 2 {6, 1, 2, 7} and {1, 2, 7} are the only valid subarrays.Input: arr[] = {3, 3, 3}, K = 5 Output: 3 Approach: For a fixed left

Maximum circular subarray sum of size K

Given an array arr of size N and an integer K, the task is to find the maximum sum subarray of size k among all contiguous sub-array (considering circular subarray also). Examples: Input: arr = {18, 4, 3, 4, 5, 6, 7, 8, 2, 10}, k = 3 Output: max circular sum = 32 start index = 9 end index = 1 Explan

Largest sum subarray of size K containing consecutive elements

Given an array arr[] consisting of N positive integers and a positive integer K, the task is to find the maximum sum of the subarray of size K such that it contains K consecutive elements in any combination. Examples: Input: arr[] = {10, 12, 9, 8, 10, 15, 1, 3, 2}, K = 3Output: 27Explanation:The sub

K-th Largest Sum Contiguous Subarray

Given an array arr[] of size n, the task is to find the kth largest sum of contiguous subarray within the array of numbers that has both negative and positive numbers. Examples: Input: arr[] = [20, -5, -1], k = 3Output: 14Explanation: All sum of contiguous subarrays are (20, 15, 14, -5, -6, -1), so

Maximize the sum of maximum elements of at least K-sized subarrays

Given an integer array arr[] of length N and an integer K, partition the array in some non-overlapping subarrays such that each subarray has size at least K and each element of the array should be part of a subarray. The task is to maximize the sum of maximum elements across all the subarrays. Examp

Largest subarray having sum greater than k

Given an array of integers and a value k, the task is to find the length of the largest subarray having a sum greater than k. Examples: Input: arr[] = [-2, 1, 6, -3], k = 5Output: 2Explanation: The largest subarray with a sum greater than 5 is {1, 6}. Input: arr[] = [2, -3, 3, 2, 0, -1], k = 3Output

Longest subarray having sum of elements atmost K

Given an array arr[] of size N and an integer K, the task is to find the length of the largest subarray having the sum of its elements at most K, where K > 0. Examples: Input: arr[] = {1, 2, 1, 0, 1, 1, 0}, k = 4Output: 5Explanation: {1, 2, 1} => sum = 4, length = 3 {1, 2, 1, 0}, {2, 1, 0, 1}

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