 Open in App
Not now

# Maximize sum of max and min of each of K Arrays obtained by dividing given Array into given sizes

• Last Updated : 07 Feb, 2023

Given two arrays, arr[] of N size and div[] of size K. Divide arr[] into K different arrays, each of div[i] size. The task is to find the total sum after maximizing the sum of maximum and minimum of each divided array.

Examples:

Input: arr[] = {3, 1, 7, 4}, div[] = {1, 3}, N = 4, K = 2
Output: 19
Explanation: Divide the array in the following way:

• {7}, sum of maximum and minimum = (7 + 7) = 14
• {1, 3, 4}, sum of maximum and minimum = (4 + 1) = 5

Total sum = 14 + 5 = 19.

Input: arr[] = {10, 12, 10, 12, 10, 12}, div[] = {3, 3}, N = 6, K = 2
Output: 44

Approach: Follow the below steps to solve the problem:

1. Take a variable say count1 to count a number of 1s in div[].
2. Sort both arrays, arr[] in descending order and div[] in ascending order.
3. Take a variable say, ans to store the answer and another variable say t which represents from which index iteration is to be started in div[].
4. Iterate the array till K, in every iteration add the elements to ans, and add that element again to ans while count1 is greater than 0 because arrays of size 1 while having the same element as maximum and minimum.
5. Again iterate a loop from the Kth index to the end of the array. Add an element to ans and update the index.
6. Return the ans.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the total sum after``// maximizing the sum of maximum and``// minimum of each divided array``int` `maximizeSum(``int` `arr[], ``int` `divi[], ``int` `N, ``int` `K)``{``    ``// Variable to count 1s in divi[]``    ``int` `count1 = 0;``    ``for` `(``int` `i = 0; i < K; i++) {``        ``if` `(divi[i] == 1) {``            ``count1++;``        ``}``    ``}` `    ``// Sort arr[] in descending order``    ``sort(arr, arr + N, greater<``int``>());` `    ``// Sort divi[] in ascending order``    ``sort(divi, divi + K);` `    ``// Temporary variable to store``    ``// the count of 1s in the divi[]` `    ``int` `t = count1;``    ``// Variable to store answer``    ``int` `ans = 0;` `    ``// Iterate over the array till K``    ``for` `(``int` `i = 0; i < K; i++) {``        ``// Add the current element to ans``        ``ans += arr[i];` `        ``// If count1 is greater than 0,``        ``// decrement it by 1 and update the``        ``// ans by again adding the same element``        ``if` `(count1 > 0) {``            ``count1--;``            ``ans += arr[i];``        ``}``    ``}` `    ``// Traverse the array from Kth index``    ``// to the end``    ``for` `(``int` `i = K; i < N; i++) {``        ``// Update the index``        ``i += divi[t] - 2;` `        ``// Add the value at that index to ans``        ``ans += arr[i];``        ``t++;``    ``}``    ``// Return ans``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 3, 1, 7, 4 };``    ``int` `divi[] = { 1, 3 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `K = ``sizeof``(divi) / ``sizeof``(divi);` `    ``cout << maximizeSum(arr, divi, N, K);` `    ``return` `0;``}`

## Java

 `// Java code for the above approach``import` `java.util.Arrays;``import` `java.util.Collections;` `class` `GFG``{``  ` `    ``// Function to find the total sum after``    ``// maximizing the sum of maximum and``    ``// minimum of each divided array``    ``static` `int` `maximizeSum(``int` `arr[], ``int` `divi[], ``int` `N,``                           ``int` `K)``    ``{``      ` `        ``// Variable to count 1s in divi[]``        ``int` `count1 = ``0``;``        ``for` `(``int` `i = ``0``; i < K; i++) {``            ``if` `(divi[i] == ``1``) {``                ``count1++;``            ``}``        ``}` `        ``// Sort arr[] in descending order``        ``Arrays.sort(arr);``        ``reverse(arr);` `        ``// Sort divi[] in ascending order``        ``Arrays.sort(divi);` `        ``// Temporary variable to store``        ``// the count of 1s in the divi[]` `        ``int` `t = count1;``        ``// Variable to store answer``        ``int` `ans = ``0``;` `        ``// Iterate over the array till K``        ``for` `(``int` `i = ``0``; i < K; i++) {``            ``// Add the current element to ans``            ``ans += arr[i];` `            ``// If count1 is greater than 0,``            ``// decrement it by 1 and update the``            ``// ans by again adding the same element``            ``if` `(count1 > ``0``) {``                ``count1--;``                ``ans += arr[i];``            ``}``        ``}` `        ``// Traverse the array from Kth index``        ``// to the end``        ``for` `(``int` `i = K; i < N; i++) {``            ``// Update the index``            ``i += divi[t] - ``2``;` `            ``// Add the value at that index to ans``            ``ans += arr[i];``            ``t++;``        ``}``        ``// Return ans``        ``return` `ans;``    ``}``    ``public` `static` `void` `reverse(``int``[] array)``    ``{` `        ``// Length of the array``        ``int` `n = array.length;` `        ``// Swapping the first half elements with last half``        ``// elements``        ``for` `(``int` `i = ``0``; i < n / ``2``; i++) {` `            ``// Storing the first half elements temporarily``            ``int` `temp = array[i];` `            ``// Assigning the first half to the last half``            ``array[i] = array[n - i - ``1``];` `            ``// Assigning the last half to the first half``            ``array[n - i - ``1``] = temp;``        ``}``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``3``, ``1``, ``7``, ``4` `};``        ``int` `divi[] = { ``1``, ``3` `};` `        ``int` `N = arr.length;``        ``int` `K = divi.length;` `        ``System.out.println(maximizeSum(arr, divi, N, K));``    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# Python program for the above approach` `# Function to find the total sum after``# maximizing the sum of maximum and``# minimum of each divided array``def` `maximizeSum(arr, divi, N, K):``  ` `    ``# Variable to count 1s in divi[]``    ``count1 ``=` `0``    ``for` `i ``in` `range``(K):``        ``if` `(divi[i] ``=``=` `1``):``            ``count1 ``+``=` `1` `    ``# Sort arr[] in descending order``    ``arr.sort()``    ``arr.reverse()` `    ``# Sort divi[] in ascending order``    ``divi.sort()` `    ``# Temporary variable to store``    ``# the count of 1s in the divi[]` `    ``t ``=` `count1``    ``# Variable to store answer``    ``ans ``=` `0` `    ``# Iterate over the array till K``    ``for` `i ``in` `range``(K):``        ``# Add the current element to ans``        ``ans ``+``=` `arr[i]` `        ``# If count1 is greater than 0,``        ``# decrement it by 1 and update the``        ``# ans by again adding the same element``        ``if` `(count1 > ``0``):``            ``count1 ``-``=` `1``            ``ans ``+``=` `arr[i]` `    ``# Traverse the array from Kth index``    ``# to the end``    ``i ``=` `K``    ``while``(i < N):``        ``# Update the index``        ``i ``+``=` `divi[t] ``-` `2` `        ``# Add the value at that index to ans``        ``ans ``+``=` `arr[i]``        ``t ``+``=` `1``        ``i ``+``=` `1`  `    ``# Return ans``    ``return` `ans` `# Driver Code``arr ``=` `[``3``, ``1``, ``7``, ``4``]``divi ``=` `[``1``, ``3``]` `N ``=` `len``(arr)``K ``=` `len``(divi)` `print``(maximizeSum(arr, divi, N, K))` `# This code is contributed by gfgking`

## C#

 `// C# code for the above approach` `using` `System;` `public` `class` `GFG``{``  ` `    ``// Function to find the total sum after``    ``// maximizing the sum of maximum and``    ``// minimum of each divided array``    ``static` `int` `maximizeSum(``int` `[]arr, ``int` `[]divi, ``int` `N,``                           ``int` `K)``    ``{``      ` `        ``// Variable to count 1s in divi[]``        ``int` `count1 = 0;``        ``for` `(``int` `i = 0; i < K; i++) {``            ``if` `(divi[i] == 1) {``                ``count1++;``            ``}``        ``}` `        ``// Sort arr[] in descending order``        ``Array.Sort(arr);``        ``reverse(arr);` `        ``// Sort divi[] in ascending order``        ``Array.Sort(divi);` `        ``// Temporary variable to store``        ``// the count of 1s in the divi[]` `        ``int` `t = count1;``        ``// Variable to store answer``        ``int` `ans = 0;` `        ``// Iterate over the array till K``        ``for` `(``int` `i = 0; i < K; i++) {``            ``// Add the current element to ans``            ``ans += arr[i];` `            ``// If count1 is greater than 0,``            ``// decrement it by 1 and update the``            ``// ans by again adding the same element``            ``if` `(count1 > 0) {``                ``count1--;``                ``ans += arr[i];``            ``}``        ``}` `        ``// Traverse the array from Kth index``        ``// to the end``        ``for` `(``int` `i = K; i < N; i++) {``            ``// Update the index``            ``i += divi[t] - 2;` `            ``// Add the value at that index to ans``            ``ans += arr[i];``            ``t++;``        ``}``        ``// Return ans``        ``return` `ans;``    ``}``    ``public` `static` `void` `reverse(``int``[] array)``    ``{` `        ``// Length of the array``        ``int` `n = array.Length;` `        ``// Swapping the first half elements with last half``        ``// elements``        ``for` `(``int` `i = 0; i < n / 2; i++) {` `            ``// Storing the first half elements temporarily``            ``int` `temp = array[i];` `            ``// Assigning the first half to the last half``            ``array[i] = array[n - i - 1];` `            ``// Assigning the last half to the first half``            ``array[n - i - 1] = temp;``        ``}``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int` `[]arr = { 3, 1, 7, 4 };``        ``int` `[]divi = { 1, 3 };` `        ``int` `N = arr.Length;``        ``int` `K = divi.Length;` `        ``Console.WriteLine(maximizeSum(arr, divi, N, K));``    ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`19`

Time Complexity: O(NlogN), time required for sorting
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up