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:
- Check if K is greater than N then return -1.
-
- Initialise following variables :
- 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++
// 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 |
chevron_right
filter_none
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)); } } |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output:
6
Time Complexity: O (N)
Auxiliary Space: O (1)
Recommended Posts:
- Count of subarrays of size K having at least one pair with absolute difference divisible by K-1
- Min difference between maximum and minimum element in all Y size subarrays
- Subsequence with maximum pairwise absolute difference and minimum size
- Maximum subarray size, such that all subarrays of that size have sum less than k
- Sliding Window Maximum (Maximum of all subarrays of size k) using stack in O(n) time
- Minimum absolute difference of XOR values of two subarrays
- Sliding Window Maximum (Maximum of all subarrays of size k)
- Maximum of all Subarrays of size k using set in C++ STL
- Maximum sum two non-overlapping subarrays of given size
- Minimum and Maximum of all subarrays of size K using Map
- Minimise the maximum element of N subarrays of size K
- Sum of minimum and maximum elements of all subarrays of size k.
- Maximum of all subarrays of size K using Segment Tree
- Maximum sum of absolute difference of any permutation
- Maximum absolute difference of value and index sums
- Maximum absolute difference between sum of two contiguous sub-arrays
- Maximum absolute difference between distinct elements in an Array
- Find maximum number of elements such that their absolute difference is less than or equal to 1
- Count maximum elements of an array whose absolute difference does not exceed K
- Minimum value of maximum absolute difference of all adjacent pairs in an Array
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
