 GeeksforGeeks App
Open App Browser
Continue

# Minimize cost by splitting given Array into subsets of size K and adding highest K/2 elements of each subset into cost

Given an array arr[] of N integers and an integer K, the task is to calculate the minimum cost by spilling the array elements into subsets of size K and adding the maximum ⌈K/2⌉ elements into the cost.

Note: ⌈K/2⌉ means ceiling value of K/2.

Examples:

Input: arr[] = {1, 1, 2, 2}, K = 2
Output: 3
Explanation: The given array elements can be divided into subsets {2, 2} and {1, 1}.
Hence, the cost will be 2 + 1 = 3, which is the minimum possible.

Input: arr[] = {1, 2, 3, 4, 5, 6}, K = 3
Output: 16
Explanation: The array can be split like {1, 2, 3} and {4, 5, 6}.
Now ceil(3/2) = ceil(1.5) = 2.
So take 2 highest elements from each set.
The sum becomes 2 + 3 + 5 + 6 = 16

Approach: The given problem can be solved by using a greedy approach. The idea is to sort the elements in decreasing order and start forming the groups of K elements consecutively and maintain the sum of the highest ⌈K/2⌉ elements of each group in a variable. This will ensure that the elements whose cost is not considered are the maximum possible and therefore minimize the overall cost of the selected elements.

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach``#include ``using` `namespace` `std;` `// Function to find minimum cost by splitting``// the array into subsets of size at most K``// and adding maximum K/2 elements into cost``int` `minimizeCost(vector<``int``> arr, ``int` `K)``{``    ``// Stores the final cost``    ``int` `ans = 0;` `    ``// Sort the array arr[]``    ``sort(arr.begin(), arr.end(),``         ``greater<``int``>());` `    ``// Loop to iterate over each``    ``// group of K elements``    ``for` `(``int` `i = 0; i < arr.size();``         ``i += K) {` `        ``// Loop to iterate over``        ``// maximum K/2 elements``        ``for` `(``int` `j = i; j < i + ``ceil``(K / 2.0)``                        ``&& j < arr.size();``             ``j++) {``            ``ans += arr[j];``        ``}``    ``}` `    ``// Return Answer``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``vector<``int``> arr = { 1, 2, 3, 4, 5, 6 };``    ``int` `K = 3;` `    ``cout << minimizeCost(arr, K);``    ``return` `0;``}`

## Java

 `// JAVA program of the above approach``import` `java.util.*;``class` `GFG``{``  ` `    ``// Function to find minimum cost by splitting``    ``// the array into subsets of size at most K``    ``// and adding maximum K/2 elements into cost``    ``public` `static` `int` `minimizeCost(ArrayList arr,``                                   ``int` `K)``    ``{``        ``// Stores the final cost``        ``int` `ans = ``0``;` `        ``// Sort the array arr[]``        ``Collections.sort(arr, Collections.reverseOrder());` `        ``// Loop to iterate over each``        ``// group of K elements``        ``for` `(``int` `i = ``0``; i < arr.size(); i += K) {` `            ``// Loop to iterate over``            ``// maximum K/2 elements``            ``for` `(``int` `j = i; j < i + Math.ceil(K / ``2.0``)``                            ``&& j < arr.size();``                 ``j++) {``                ``ans += arr.get(j);``            ``}``        ``}` `        ``// Return Answer``        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``ArrayList arr = ``new` `ArrayList<>(``            ``Arrays.asList(``1``, ``2``, ``3``, ``4``, ``5``, ``6``));``        ``int` `K = ``3``;``        ``System.out.print(minimizeCost(arr, K));``    ``}``}` `// This code is contributed by Taranpreet`

## Python

 `# Python program of the above approach``import` `math` `#  Function to find minimum cost by splitting``#  the array into subsets of size at most K``#  and adding maximum K/2 elements into cost``def` `minimizeCost(arr, K):``    ` `    ``# Stores the final cost``    ``ans ``=` `0` `    ``# Sort the array arr[]``    ``arr.sort(reverse ``=` `True``)` `    ``# Loop to iterate over each``    ``# group of K elements``    ``i ``=` `0``    ``while``(i < ``len``(arr)):` `        ``# Loop to iterate over``        ``# maximum K/2 elements``        ``j ``=` `i``        ``while``(j < i ``+` `math.ceil(K ``/` `2.0``) ``and` `j < ``len``(arr)):``            ` `            ``ans ``+``=` `arr[j]``            ``j ``+``=` `1``            ` `        ``i ``+``=` `K` `    ``# Return Answer``    ``return` `ans` `# Driver code``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `]``K ``=` `3` `print``(minimizeCost(arr, K))` `# This code is contributed by samim2000.`

## C#

 `// C# implementation of the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `  ``// Function to find minimum cost by splitting``  ``// the array into subsets of size at most K``  ``// and adding maximum K/2 elements into cost``  ``static` `int` `minimizeCost(List<``int``> arr, ``int` `K)``  ``{``    ``// Stores the final cost``    ``int` `ans = 0;` `    ``// Sort the array arr[]``    ``arr.Sort((a, b) => b - a);` `    ``// Loop to iterate over each``    ``// group of K elements``    ``for` `(``int` `i = 0; i < arr.Count;``         ``i += K) {` `      ``// Loop to iterate over``      ``// maximum K/2 elements``      ``for` `(``int` `j = i; j < i + Math.Ceiling(K / 2.0)``           ``&& j < arr.Count;``           ``j++) {``        ``ans += arr[j];``      ``}``    ``}` `    ``// Return Answer``    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``List<``int``> arr = ``new` `List<``int``>{ 1, 2, 3, 4, 5, 6 };``    ``int` `K = 3;` `    ``Console.Write(minimizeCost(arr, K));``  ``}``}` `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output

`16`

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up