Partition into two subarrays of lengths k and (N – k) such that the difference of sums is maximum
Given an array of non-negative integers of length N and an integer k. Partition the given array into two subarrays of length K and N – k so that the difference between the sum of both subarray is maximum.
Examples :
Input : arr[] = {8, 4, 5, 2, 10}
k = 2
Output : 17
Explanation :
Here, we can make first subarray of length k = {4, 2}
and second subarray of length N - k = {8, 5, 10}. Then,
the max_difference = (8 + 5 + 10) - (4 + 2) = 17.
Input : arr[] = {1, 1, 1, 1, 1, 1, 1, 1}
k = 3
Output : 2
Explanation :
Here, subarrays would be {1, 1, 1, 1, 1} and {1, 1, 1}.
So, max_difference would be 2.
Choose k numbers with largest possible sum. Then the solution obviously is k largest numbers. So that here greedy algorithm works – at each step we choose the largest possible number until we get all K numbers.
In this problem we should divide the array of N numbers into two subarrays of k and N – k numbers respectively. Consider two cases –
- The subarray with largest sum, among these two subarrays, is subarray of K numbers. Then we want to maximize the sum in it, since the sum in the second subarray will only decrease if the sum in the first subarray will increase. So we are now in sub-problem considered above and should choose k largest numbers.
- The subarray with largest sum, among these two subarray, is subarray of N – k numbers. Similarly to the previous case we then have to choose N – k largest numbers among all numbers.
Now, Let’s think which of the two above cases actually gives the answer. We can easily see that larger difference would be when more numbers are included to the group of largest numbers. Hence we could set M = max(k, N – k), find the sum of M largest numbers (let it be S1) and then the answer is S1 – (S – S1), where S is the sum of all numbers.
Below is the implementation of the above approach :
C++
// CPP program to calculate max_difference between // the sum of two subarrays of length k and N - k #include <bits/stdc++.h> using namespace std; // Function to calculate max_difference int maxDifference(int arr[], int N, int k) { int M, S = 0, S1 = 0, max_difference = 0; // Sum of the array for (int i = 0; i < N; i++) S += arr[i]; // Sort the array in descending order sort(arr, arr + N, greater<int>()); M = max(k, N - k); for (int i = 0; i < M; i++) S1 += arr[i]; // Calculating max_difference max_difference = S1 - (S - S1); return max_difference; } // Driver function int main() { int arr[] = { 8, 4, 5, 2, 10 }; int N = sizeof(arr) / sizeof(arr[0]); int k = 2; cout << maxDifference(arr, N, k) << endl; return 0; } |
chevron_right
filter_none
Java
// Java program to calculate max_difference between // the sum of two subarrays of length k and N - k import java.util.*; class GFG { // Function to calculate max_difference static int maxDifference(int arr[], int N, int k) { int M, S = 0, S1 = 0, max_difference = 0; // Sum of the array for (int i = 0; i < N; i++) S += arr[i]; int temp; // Sort the array in descending order for (int i = 0; i < N; i++) { for (int j = i + 1; j < N; j++) { if (arr[i] < arr[j]) { temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } M = Math.max(k, N - k); for (int i = 0; i < M; i++) S1 += arr[i]; // Calculating max_difference max_difference = S1 - (S - S1); return max_difference; } // Driver Code public static void main(String args[]) { int arr[] = { 8, 4, 5, 2, 10 }; int N = arr.length; int k = 2; System.out.println(maxDifference(arr, N, k)); } } // This code is contributed by // Surendra_Gangwar |
chevron_right
filter_none
Python3
# Python3 code to calculate max_difference # between the sum of two subarrays of # length k and N - k # Function to calculate max_difference def maxDifference(arr, N, k ): S = 0 S1 = 0 max_difference = 0 # Sum of the array for i in range(N): S += arr[i] # Sort the array in descending order arr.sort(reverse=True) M = max(k, N - k) for i in range( M): S1 += arr[i] # Calculating max_difference max_difference = S1 - (S - S1) return max_difference # Driver Code arr = [ 8, 4, 5, 2, 10 ] N = len(arr) k = 2print(maxDifference(arr, N, k)) # This code is contributed by "Sharad_Bhardwaj". |
chevron_right
filter_none
C#
// C# program to calculate max_difference between // the sum of two subarrays of length k and N - k using System; class GFG { // Function to calculate max_difference static int maxDifference(int []arr, int N, int k) { int M, S = 0, S1 = 0, max_difference = 0; // Sum of the array for (int i = 0; i < N; i++) S += arr[i]; int temp; // Sort the array in descending order for (int i = 0; i < N; i++) { for (int j = i + 1; j < N; j++) { if (arr[i] < arr[j]) { temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } M = Math.Max(k, N - k); for (int i = 0; i < M; i++) S1 += arr[i]; // Calculating max_difference max_difference = S1 - (S - S1); return max_difference; } // Driver Code public static void Main() { int []arr = { 8, 4, 5, 2, 10 }; int N = arr.Length; int k = 2; Console.Write(maxDifference(arr, N, k)); } } // This code is contributed by mohit kumar 29 |
chevron_right
filter_none
PHP
<?php // PHP program to calculate // max_difference between // the sum of two subarrays // of length k and N - k // Function to calculate // max_difference function maxDifference($arr, $N, $k) { $M; $S = 0; $S1 = 0; $max_difference = 0; // Sum of the array for ($i = 0; $i < $N; $i++) $S += $arr[$i]; // Sort the array in // descending order rsort($arr); $M = max($k, $N - $k); for ($i = 0; $i < $M; $i++) $S1 += $arr[$i]; // Calculating // max_difference $max_difference = $S1 - ($S - $S1); return $max_difference; } // Driver Code $arr = array(8, 4, 5, 2, 10); $N = count($arr); $k = 2; echo maxDifference($arr, $N, $k); // This code is contributed // by anuj_67. ?> |
chevron_right
filter_none
Output :
17
Further Optimizations : We can use Heap (or priority queue) to find M largest elements efficiently. Refer k largest(or smallest) elements in an array for details.
Recommended Posts:
- Maximum sum of lengths of non-overlapping subarrays with k as the max element.
- Maximum absolute difference of value and index sums
- Check if it possible to partition in k subarrays with equal sum
- Partitioning into two contiguous element subarrays with equal sums
- Sliding Window Maximum (Maximum of all subarrays of size k) using stack in O(n) time
- Sliding Window Maximum (Maximum of all subarrays of size k)
- Possible two sets from first N natural numbers difference of sums as D
- Maximum String Partition
- Replace all elements by difference of sums of positive and negative numbers after that element
- Maximum average sum partition of an array
- K maximum sums of overlapping contiguous sub-arrays
- K maximum sums of non-overlapping contiguous sub-arrays
- Partition an array such into maximum increasing segments
- Minimum absolute difference of XOR values of two subarrays
- Maximum of all Subarrays of size k using set in C++ STL
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.
