Maximum absolute difference between sum of subarrays of size K
Last Updated :
07 Aug, 2023
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
Brute Force Approach:
- Initialize a variable max_diff to zero.
- Loop through all pairs of starting indices i and j, where i ranges from 0 to N-K and j ranges from i+1 to N-K.
- For each pair of starting indices i and j, compute the sum of the subarray of size K starting at i, and the sum of the subarray of size K starting at j. To do this, we use a loop that adds up the K elements starting at i and j, respectively.
- Compute the absolute difference between the two sums computed in the previous step, and update the max_diff variable if this absolute difference is greater than the current value of max_diff.
- Return the value of max_diff.
Below is the implementation of the above approach :
C++
#include <bits/stdc++.h>
using namespace std;
int MaxAbsSumOfKsubArray( int arr[], int K, int N)
{
int max_diff = 0;
for ( int i = 0; i <= N-K; i++) {
for ( int j = i+1; j <= N-K; j++) {
int sum1 = 0, sum2 = 0;
for ( int k = 0; k < K; k++) {
sum1 += arr[i+k];
sum2 += arr[j+k];
}
max_diff = max(max_diff, abs (sum1 - sum2));
}
}
return max_diff;
}
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;
}
|
Java
import java.util.*;
public class Main {
static int MaxAbsSumOfKsubArray( int [] arr, int K, int N) {
int max_diff = 0 ;
for ( int i = 0 ; i <= N - K; i++) {
for ( int j = i + 1 ; j <= N - K; j++) {
int sum1 = 0 , sum2 = 0 ;
for ( int k = 0 ; k < K; k++) {
sum1 += arr[i + k];
sum2 += arr[j + k];
}
max_diff = Math.max(max_diff, Math.abs(sum1 - sum2));
}
}
return max_diff;
}
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
def max_abs_sum_of_k_subarray(arr, K, N):
max_diff = 0
for i in range (N - K + 1 ):
for j in range (i + 1 , N - K + 1 ):
sum1 = 0
sum2 = 0
for k in range (K):
sum1 + = arr[i + k]
for k in range (K):
sum2 + = arr[j + k]
max_diff = max (max_diff, abs (sum1 - sum2))
return max_diff
arr = [ - 2 , - 3 , 4 , - 1 , - 2 , 1 , 5 , - 3 ]
K = 3
N = len (arr)
print (max_abs_sum_of_k_subarray(arr, K, N))
|
C#
using System;
public static class GFG {
static int MaxAbsSumOfKsubArray( int [] arr, int K, int N) {
int max_diff = 0;
for ( int i = 0; i <= N - K; i++) {
for ( int j = i + 1; j <= N - K; j++) {
int sum1 = 0, sum2 = 0;
for ( int k = 0; k < K; k++) {
sum1 += arr[i + k];
sum2 += arr[j + k];
}
max_diff = Math.Max(max_diff, Math.Abs(sum1 - sum2));
}
}
return max_diff;
}
public static void Main() {
int [] arr = { -2, -3, 4, -1, -2, 1, 5, -3 };
int K = 3;
int N = arr.Length;
Console.WriteLine(MaxAbsSumOfKsubArray(arr, K, N));
}
}
|
Javascript
function maxAbsSumOfKsubArray(arr, K, N) {
let maxDiff = 0;
for (let i = 0; i <= N - K; i++) {
for (let j = i + 1; j <= N - K; j++) {
let sum1 = 0, sum2 = 0;
for (let k = 0; k < K; k++) {
sum1 += arr[i + k];
sum2 += arr[j + k];
}
maxDiff = Math.max(maxDiff, Math.abs(sum1 - sum2));
}
}
return maxDiff;
}
const arr = [-2, -3, 4, -1, -2, 1, 5, -3];
const K = 3;
const N = arr.length;
console.log(maxAbsSumOfKsubArray(arr, K, N));
|
Time Complexity: O(N^3)
Auxiliary Space: O(1)
Efficient Approach
The idea is to use Sliding Window Technique. Follow the steps below to solve the problem:
- Check if K is greater than N then return -1.
-
- 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.
- Calculate the sum of first K size subarray and update maxSum and minSum, decrement sum by arr[start] and increment start by 1.
- 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.
- Return absolute difference between maxSum and minSum.
Below is the implementation of the above approach :
C++
#include <bits/stdc++.h>
using namespace std;
int MaxAbsSumOfKsubArray( int arr[],
int K, int N)
{
int maxSum = INT_MIN;
int minSum = INT_MAX;
int sum = 0;
int start = 0;
int i = 0;
if (N < K)
return -1;
while (i < K)
{
sum += arr[i];
i++;
}
maxSum = max(maxSum, sum);
minSum = min(minSum, sum);
sum -= arr[start++];
while (i < N)
{
sum += arr[i];
i++;
maxSum = max(maxSum, sum);
minSum = min(minSum, sum);
sum -= arr[start++];
}
return abs (maxSum - minSum);
}
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;
}
|
Java
import java.util.*;
class GFG {
static int MaxAbsSumOfKsubArray(
int [] arr,
int K, int N)
{
int maxSum = Integer.MIN_VALUE;
int minSum = Integer.MAX_VALUE;
int sum = 0 ;
int start = 0 ;
int i = 0 ;
if (N < K)
return - 1 ;
while (i < K) {
sum += arr[i];
i++;
}
maxSum = Math.max(maxSum, sum);
minSum = Math.min(minSum, sum);
sum -= arr[start++];
while (i < N) {
sum += arr[i];
i++;
maxSum = Math.max(maxSum, sum);
minSum = Math.min(minSum, sum);
sum -= arr[start++];
}
return Math.abs(maxSum - minSum);
}
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
import sys
def MaxAbsSumOfKsubArray(arr, K, N):
maxSum = - sys.maxsize - 1
minSum = sys.maxsize
sum = 0
start = 0
i = 0
if (N < K):
return - 1
while (i < K):
sum + = arr[i]
i + = 1
maxSum = max (maxSum, sum )
minSum = min (minSum, sum )
sum - = arr[start]
start + = 1
while (i < N):
sum + = arr[i]
i + = 1
maxSum = max (maxSum, sum )
minSum = min (minSum, sum )
sum - = arr[start]
start + = 1
return abs (maxSum - minSum)
arr = [ - 2 , - 3 , 4 , - 1 ,
- 2 , 1 , 5 , - 3 ]
K = 3
N = len (arr)
print (MaxAbsSumOfKsubArray(arr, K, N))
|
C#
using System;
class GFG{
static int MaxAbsSumOfKsubArray(
int [] arr,
int K, int N)
{
int MaxSum = Int32.MinValue;
int MinSum = Int32.MaxValue;
int sum = 0;
int start = 0;
int i = 0;
if (N < K)
return -1;
while (i < K)
{
sum += arr[i];
i++;
}
MaxSum = Math.Max(MaxSum, sum);
MinSum = Math.Min(MinSum, sum);
sum -= arr[start++];
while (i < N)
{
sum += arr[i];
i++;
MaxSum = Math.Max(MaxSum, sum);
MinSum = Math.Min(MinSum, sum);
sum -= arr[start++];
}
return Math.Abs(MaxSum - MinSum);
}
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));
}
}
|
Javascript
<script>
function MaxAbsSumOfKsubArray(arr, K, N)
{
let maxSum = Number.MIN_VALUE;
let minSum = Number.MAX_VALUE;
let sum = 0;
let start = 0;
let i = 0;
if (N < K)
return -1;
while (i < K)
{
sum += arr[i];
i++;
}
maxSum = Math.max(maxSum, sum);
minSum = Math.min(minSum, sum);
sum -= arr[start++];
while (i < N)
{
sum += arr[i];
i++;
maxSum = Math.max(maxSum, sum);
minSum = Math.min(minSum, sum);
sum -= arr[start++];
}
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>
|
Time Complexity: O (N)
Auxiliary Space: O (1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...