Maximize sum of max and min of each of K Arrays obtained by dividing given Array into given sizes
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:
- Take a variable say count1 to count a number of 1s in div[].
- Sort both arrays, arr[] in descending order and div[] in ascending order.
- 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[].
- 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.
- Again iterate a loop from the Kth index to the end of the array. Add an element to ans and update the index.
- Return the ans.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximizeSum( int arr[], int divi[], int N, int K)
{
int count1 = 0;
for ( int i = 0; i < K; i++) {
if (divi[i] == 1) {
count1++;
}
}
sort(arr, arr + N, greater< int >());
sort(divi, divi + K);
int t = count1;
int ans = 0;
for ( int i = 0; i < K; i++) {
ans += arr[i];
if (count1 > 0) {
count1--;
ans += arr[i];
}
}
for ( int i = K; i < N; i++) {
i += divi[t] - 2;
ans += arr[i];
t++;
}
return ans;
}
int main()
{
int arr[] = { 3, 1, 7, 4 };
int divi[] = { 1, 3 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = sizeof (divi) / sizeof (divi[0]);
cout << maximizeSum(arr, divi, N, K);
return 0;
}
|
Java
import java.util.Arrays;
import java.util.Collections;
class GFG
{
static int maximizeSum( int arr[], int divi[], int N,
int K)
{
int count1 = 0 ;
for ( int i = 0 ; i < K; i++) {
if (divi[i] == 1 ) {
count1++;
}
}
Arrays.sort(arr);
reverse(arr);
Arrays.sort(divi);
int t = count1;
int ans = 0 ;
for ( int i = 0 ; i < K; i++) {
ans += arr[i];
if (count1 > 0 ) {
count1--;
ans += arr[i];
}
}
for ( int i = K; i < N; i++) {
i += divi[t] - 2 ;
ans += arr[i];
t++;
}
return ans;
}
public static void reverse( int [] array)
{
int n = array.length;
for ( int i = 0 ; i < n / 2 ; i++) {
int temp = array[i];
array[i] = array[n - i - 1 ];
array[n - i - 1 ] = temp;
}
}
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));
}
}
|
Python3
def maximizeSum(arr, divi, N, K):
count1 = 0
for i in range (K):
if (divi[i] = = 1 ):
count1 + = 1
arr.sort()
arr.reverse()
divi.sort()
t = count1
ans = 0
for i in range (K):
ans + = arr[i]
if (count1 > 0 ):
count1 - = 1
ans + = arr[i]
i = K
while (i < N):
i + = divi[t] - 2
ans + = arr[i]
t + = 1
i + = 1
return ans
arr = [ 3 , 1 , 7 , 4 ]
divi = [ 1 , 3 ]
N = len (arr)
K = len (divi)
print (maximizeSum(arr, divi, N, K))
|
C#
using System;
public class GFG
{
static int maximizeSum( int []arr, int []divi, int N,
int K)
{
int count1 = 0;
for ( int i = 0; i < K; i++) {
if (divi[i] == 1) {
count1++;
}
}
Array.Sort(arr);
reverse(arr);
Array.Sort(divi);
int t = count1;
int ans = 0;
for ( int i = 0; i < K; i++) {
ans += arr[i];
if (count1 > 0) {
count1--;
ans += arr[i];
}
}
for ( int i = K; i < N; i++) {
i += divi[t] - 2;
ans += arr[i];
t++;
}
return ans;
}
public static void reverse( int [] array)
{
int n = array.Length;
for ( int i = 0; i < n / 2; i++) {
int temp = array[i];
array[i] = array[n - i - 1];
array[n - i - 1] = temp;
}
}
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));
}
}
|
Javascript
<script>
const maximizeSum = (arr, divi, N, K) => {
let count1 = 0;
for (let i = 0; i < K; i++) {
if (divi[i] == 1) {
count1++;
}
}
arr.sort();
arr.reverse();
divi.sort();
let t = count1;
let ans = 0;
for (let i = 0; i < K; i++) {
ans += arr[i];
if (count1 > 0) {
count1--;
ans += arr[i];
}
}
for (let i = K; i < N; i++) {
i += divi[t] - 2;
ans += arr[i];
t++;
}
return ans;
}
let arr = [3, 1, 7, 4];
let divi = [1, 3];
let N = arr.length
let K = divi.length
document.write(maximizeSum(arr, divi, N, K));
</script>
|
Time Complexity: O(NlogN), time required for sorting
Auxiliary Space: O(1)
Last Updated :
07 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...