Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum absolute difference between sum of subarrays of size K

  • Difficulty Level : Easy
  • Last Updated : 24 Mar, 2021

Given an array arr[] of size N and an integer K, the task is to find maximum absolute difference between the sum of subarrays of size K.
Examples : 
 

Input: arr[] = {-2, -3, 4, -1, -2, 1, 5, -3}, K = 3 
Output: 6 
Explanation:: 
Sum of subarray (-2, -3, 4) = -1 
Sum of subarray (-3, 4, -1) = 0 
Sum of subarray (4, -1, -2) = 1 
Sum of subarray (-1, -2, 1) = -2 
Sum of subarray (-2, 1, 5) = 4 
Sum of subarray (1, 5, -3) = 3 
So maximum absolute difference between sum of subarray of size 3 is is (4 – (-2)) = 6.
Input: arr [ ] = {2, 5, -1, 7, -3, -1, -2}, K = 4 
Output: 12 
 

 

Naive Approach 
The simplest approach is to generate all subarrays of size K and find the minimum sum and maximum sum among them. Finally, return the absolute difference between the maximum and minimum sums. 
Time Complexity: O( N2) 
Auxiliary Space: O (1)
Efficient Approach 
The idea is to use Sliding Window Technique. Follow the steps below to solve the problem:
 

  1. Check if K is greater than N then return -1.
  2.  
    • maxSum : Store maximum sum of K size subarray.
    • minSum : Store minimum sum of K size subarray.
    • sum : Store current sum of K size subarray.
    • start : Remove left most element which is no longer part of K size subarray.
  3. Calculate the sum of first K size subarray and update maxSum and minSum, decrement sum by arr[start] and  increment start by 1.
  4. Traverse arr from K to N and do the following operations: 
    • Increment sum by arr[i].
    • Update maxSum and minSum.
    • Decrement sum by arr[start].
    • Increment start by 1.
  5. Return absolute difference between maxSum and minSum.

Below is the implementation of the above approach :
 

C++




// C++ program to find the
// maximum absolute difference
// between the sum of all
// subarrays of size K
#include <bits/stdc++.h>
using namespace std;
 
// Return absolute difference
// between sum of all subarrays
// of size k
int MaxAbsSumOfKsubArray(int arr[],
                         int K, int N)
{
     
    // Stores maximum sum of
    // all K size subarrays
    int maxSum = INT_MIN;
 
    // Stores minimum sum of
    // all K size subarray
    int minSum = INT_MAX;
 
    // Stores the sum of current
    // subarray of size K
    int sum = 0;
 
    // Starting index of the
    // current subarray
    int start = 0;
 
    int i = 0;
 
    if (N < K)
        return -1;
 
    // Calculate the sum of
    // first K elements
    while (i < K)
    {
        sum += arr[i];
        i++;
    }
 
    // Update maxSum and minSum
    maxSum = max(maxSum, sum);
    minSum = min(minSum, sum);
 
    // Decrement sum by arr[start]
    // and increment start by 1
    sum -= arr[start++];
 
    // Traverse arr for the
    // remaining subarrays
    while (i < N)
    {
 
        // Increment sum by arr[i]
        sum += arr[i];
 
        // Increment i
        i++;
 
        // Update maxSum and minSum
        maxSum = max(maxSum, sum);
        minSum = min(minSum, sum);
 
        // Decrement sum by arr[start]
        // and increment start by 1
        sum -= arr[start++];
    }
 
    // Return absolute difference
    // between maxSum and minSum
    return abs(maxSum - minSum);
}
 
// Driver code
int main()
{
    int arr[] = { -2, -3, 4, -1,
                  -2, 1, 5, -3 };
    int K = 3;
    int N = sizeof(arr) / sizeof(arr[0]);
     
    cout << MaxAbsSumOfKsubArray(arr, K, N)
         << endl;
          
    return 0;
}
 
// This code is contributed by divyeshrabadiya07
Java



// Java program to find the
// maximum absolute difference
// between the sum of all
// subarrays of size K
 
import java.util.*;
 
class GFG {
 
    // Return absolute difference
    // between sum of all subarrays
    // of size k
    static int MaxAbsSumOfKsubArray(
        int[] arr,
        int K, int N)
    {
        // Stores maximum sum of
        // all K size subarrays
        int maxSum = Integer.MIN_VALUE;
 
        // Stores minimum sum of
        // all K size subarray
        int minSum = Integer.MAX_VALUE;
 
        // Stores the sum of current
        // subarray of size K
        int sum = 0;
 
        // Starting index of the
        // current subarray
        int start = 0;
 
        int i = 0;
 
        if (N < K)
            return -1;
 
        // Calculate the sum of
        // first K elements
        while (i < K) {
            sum += arr[i];
            i++;
        }
 
        // Update maxSum and minSum
        maxSum = Math.max(maxSum, sum);
        minSum = Math.min(minSum, sum);
 
        // Decrement sum by arr[start]
        // and increment start by 1
        sum -= arr[start++];
 
        // Traverse arr for the
        // remaining subarrays
        while (i < N) {
 
            // Increment sum by arr[i]
            sum += arr[i];
 
            // Increment i
            i++;
 
            // Update maxSum and minSum
            maxSum = Math.max(maxSum, sum);
            minSum = Math.min(minSum, sum);
 
            // Decrement sum by arr[start]
            // and increment start by 1
            sum -= arr[start++];
        }
 
        // Return absolute difference
        // between maxSum and minSum
        return Math.abs(maxSum - minSum);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int[] arr = { -2, -3, 4, -1,
                      -2, 1, 5, -3 };
        int K = 3;
        int N = arr.length;
        System.out.println(
            MaxAbsSumOfKsubArray(
                arr, K, N));
    }
}
Python3



# Python3 program to find the
# maximum absolute difference
# between the sum of all
# subarrays of size K
import sys
 
# Return absolute difference
# between sum of all subarrays
# of size k
def MaxAbsSumOfKsubArray(arr, K, N):
     
    # Stores maximum sum of
    # all K size subarrays
    maxSum = - sys.maxsize - 1
 
    # Stores minimum sum of
    # all K size subarray
    minSum = sys.maxsize
 
    # Stores the sum of current
    # subarray of size K
    sum = 0
 
    # Starting index of the
    # current subarray
    start = 0
 
    i = 0
 
    if (N < K):
        return -1
 
    # Calculate the sum of
    # first K elements
    while (i < K):
        sum += arr[i]
        i += 1
     
    # Update maxSum and minSum
    maxSum = max(maxSum, sum)
    minSum = min(minSum, sum)
 
    # Decrement sum by arr[start]
    # and increment start by 1
    sum -= arr[start]
    start += 1
 
    # Traverse arr for the
    # remaining subarrays
    while (i < N):
 
        # Increment sum by arr[i]
        sum += arr[i]
 
        # Increment i
        i += 1
 
        # Update maxSum and minSum
        maxSum = max(maxSum, sum)
        minSum = min(minSum, sum)
 
        # Decrement sum by arr[start]
        # and increment start by 1
        sum -= arr[start]
        start += 1
 
    # Return absolute difference
    # between maxSum and minSum
    return abs(maxSum - minSum)
 
# Driver code
arr = [ -2, -3, 4, -1,
        -2, 1, 5, -3 ]
K = 3
N = len(arr)
     
print(MaxAbsSumOfKsubArray(arr, K, N))
 
# This code is contributed by sanjoy_62
C#



// C# program to find the
// maximum absolute difference
// between the sum of all
// subarrays of size K
using System;
class GFG{
 
// Return absolute difference
// between sum of all subarrays
// of size k
static int MaxAbsSumOfKsubArray(
       int[] arr,
       int K, int N)
{
    // Stores maximum sum of
    // all K size subarrays
    int MaxSum = Int32.MinValue;
 
    // Stores minimum sum of
    // all K size subarray
    int MinSum = Int32.MaxValue;
 
    // Stores the sum of current
    // subarray of size K
    int sum = 0;
 
    // Starting index of the
    // current subarray
    int start = 0;
 
    int i = 0;
 
    if (N < K)
        return -1;
 
    // Calculate the sum of
    // first K elements
    while (i < K)
    {
        sum += arr[i];
        i++;
    }
 
    // Update maxSum and minSum
    MaxSum = Math.Max(MaxSum, sum);
    MinSum = Math.Min(MinSum, sum);
 
    // Decrement sum by arr[start]
    // and increment start by 1
    sum -= arr[start++];
 
    // Traverse arr for the
    // remaining subarrays
    while (i < N)
    {
 
        // Increment sum by arr[i]
        sum += arr[i];
 
        // Increment i
        i++;
 
        // Update maxSum and minSum
        MaxSum = Math.Max(MaxSum, sum);
        MinSum = Math.Min(MinSum, sum);
 
        // Decrement sum by arr[start]
        // and increment start by 1
        sum -= arr[start++];
    }
 
    // Return absolute difference
    // between maxSum and minSum
    return Math.Abs(MaxSum - MinSum);
}
 
// Driver code
public static void Main(String[] args)
{
    int[] arr = { -2, -3, 4, -1,
                  -2, 1, 5, -3 };
    int K = 3;
    int N = arr.Length;
    Console.Write(MaxAbsSumOfKsubArray(arr, K, N));
}
}
 
// This code is contributed
// by shivanisinghss2110
Javascript



<script>
 
    // Javascript program to find the 
    // maximum absolute difference 
    // between the sum of all 
    // subarrays of size K 
      
    // Return absolute difference 
    // between sum of all subarrays 
    // of size k 
    function MaxAbsSumOfKsubArray(arr, K, N) 
    { 
 
        // Stores maximum sum of 
        // all K size subarrays 
        let maxSum = Number.MIN_VALUE;
 
        // Stores minimum sum of 
        // all K size subarray 
        let minSum = Number.MAX_VALUE; 
 
        // Stores the sum of current 
        // subarray of size K 
        let sum = 0; 
 
        // Starting index of the 
        // current subarray 
        let start = 0; 
 
        let i = 0; 
 
        if (N < K) 
            return -1; 
 
        // Calculate the sum of 
        // first K elements 
        while (i < K)
        { 
            sum += arr[i]; 
            i++; 
        } 
 
        // Update maxSum and minSum 
        maxSum = Math.max(maxSum, sum); 
        minSum = Math.min(minSum, sum); 
 
        // Decrement sum by arr[start] 
        // and increment start by 1 
        sum -= arr[start++]; 
 
        // Traverse arr for the 
        // remaining subarrays 
        while (i < N) 
        { 
 
            // Increment sum by arr[i] 
            sum += arr[i]; 
 
            // Increment i 
            i++; 
 
            // Update maxSum and minSum 
            maxSum = Math.max(maxSum, sum); 
            minSum = Math.min(minSum, sum); 
 
            // Decrement sum by arr[start] 
            // and increment start by 1 
            sum -= arr[start++]; 
        } 
 
        // Return absolute difference 
        // between maxSum and minSum 
        return Math.abs(maxSum - minSum); 
    } 
     
    let arr = [ -2, -3, 4, -1, -2, 1, 5, -3 ]; 
    let K = 3; 
    let N = arr.length; 
     
    document.write(MaxAbsSumOfKsubArray(arr, K, N));
     
</script>
Output: 
6
 
Time Complexity: O (N) 
Auxiliary Space: O (1)
 

My Personal Notes
arrow_drop_up
Previous
Smallest number greater than or equal to N using only digits 1 to K
Next

Find the largest contiguous pair sum in given Array
Recommended Articles
Page :
Count of subarrays of size K having at least one pair with absolute difference divisible by K-1
30, Jun 20
Maximum subarray size, such that all subarrays of that size have sum less than k
30, Dec 16
Sum of absolute difference of maximum and minimum of all subarrays
22, Dec 21
Split array into K subarrays with minimum sum of absolute difference between adjacent elements
21, Dec 20
Min difference between maximum and minimum element in all Y size subarrays
13, Jul 20
Subsequence with maximum pairwise absolute difference and minimum size
18, Jun 20
Split array into K subarrays such that sum of maximum of all subarrays is maximized
11, Jun 21
Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays
27, Sep 21
Count of Arrays of size N having absolute difference between adjacent elements at most 1
08, Sep 21
Sliding Window Maximum (Maximum of all subarrays of size k) using stack in O(n) time
25, Apr 19
Sliding Window Maximum (Maximum of all subarrays of size k)
27, May 11
Calculate absolute difference between minimum and maximum sum of pairs in an array
10, Mar 21
Maximum absolute difference between sum of two contiguous sub-arrays
14, Jun 16
Minimum absolute difference of XOR values of two subarrays
06, Sep 17
Sum of minimum and maximum elements of all subarrays of size k.
04, Jan 17
Maximum sum two non-overlapping subarrays of given size
14, May 17
Number of subarrays having absolute sum greater than K | Set-2
03, Jul 19
Maximize sum of absolute difference between adjacent elements in Array with sum K
20, Jun 20
Split array into subarrays such that sum of difference between their maximums and minimums is maximum
19, Apr 21
Differences between number of increasing subarrays and decreasing subarrays in k sized windows
16, Nov 17
Maximum distance between two elements whose absolute difference is K
15, Aug 20
Smallest number that can replace all -1s in an array such that maximum absolute difference between any pair of adjacent elements is minimum
28, Jun 21
Maximum absolute difference between distinct elements in an Array
02, Jul 20
Maximum size of square such that all submatrices of that size have sum less than K
08, Apr 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
offbeat
@offbeat
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!