# Minimum cost of choosing the array element

Given an array arr[] of N integers and an integer M and the cost of selecting any array element(say x) at any day(say d), is x*d. The task is to minimize the cost of selecting 1, 2, 3, …, N array where each day at most M elements is allowed to select.

Examples:

Input: arr[] = {6, 19, 3, 4, 4, 2, 6, 7, 8}, M = 2
Output: 2 5 11 18 30 43 62 83 121
Explanation:
For selecting 1, 2, 3, .. , N elements when at most 2 elements are allowed to select each day:

The Cost of selecting 1 element:
select one smallest element on day 1, then cost is 2*1 = 2

The Cost of selecting 2 elements:
select two smallest elements on day 1, then cost is (2+3)*1 = 5

The Cost of selecting 3 elements:
select 2nd and 3rd smallest elements on day 1, then cost is (3+4)*1 = 7
select 1st smallest element on day 2, then cost is 2*2 = 4
So, the total cost is 7 + 4 = 11

Similarly, we can find the cost for selecting 4, 5, 6, 7, 8 and 9 elements is 18, 30, 43, 62, 83 and 121 respectively.

Input: arr[] = {6, 19, 12, 6, 7, 9}, M = 3
Output: 6 12 19 34 52 78

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to use Prefix Sum Array.

1. Sort the given array in increasing order.
2. Store the prefix sum of the sorted array in pref[]. This prefix sum gives the minimum cost of selecting the 1, 2, 3, … N array elements when atmost one element is allowed to select each day.
3. To find the minimum cost when atmost M element is allowed to select each day, update the prefix array pref[] from index M to N as:
```pref[i] = pref[i] + pref[i-M]
```

For Example:

```arr[] = {6, 9, 3, 4, 4, 2, 6, 7, 8}
After sorting arr[]:
arr[] = {2, 3, 4, 4, 6, 6, 7, 8, 9}

Prefix array is:
pref[] = {2, 5, 9, 13, 19, 25, 32, 40, 49}
Now at every index i, pref[i] gives the cost
of selecting i array element when atmost one
element is allowed to select each day.
```
```Now for M = 3, when at most 3 elements
are allowed to select each day, then
by update every index(from M to N)
of pref[] as:
pref[i] = pref[i] + pref[i-M]

the cost of selecting elements
from (i-M+1)th to ith index on day 1,
the cost of selecting elements
from (i-M)th to (i-2*M)th index on day 2
...
...
...
the cost of selecting elements
from (i-n*M)th to 0th index on day N.
```
4. After the above step, every index(say i) of prefix array pref[] stores the cost selecting i elements when atmost M elements are allowed to select each day.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function that find the minimum cost of  ` `// selecting array element ` `void` `minimumCost(``int` `arr[], ``int` `N, ``int` `M) { ` `     `  `    ``// Sorting the given array in  ` `    ``// increasing order ` `    ``sort(arr, arr + N); ` `     `  `    ``// To store the prefix sum of arr[]  ` `    ``int` `pref[N]; ` `     `  `    ``pref = arr; ` `     `  `    ``for``(``int` `i = 1; i < N; i++) { ` `        ``pref[i] = arr[i] + pref[i-1]; ` `    ``} ` `     `  `    ``// Update the pref[] to find the cost ` `    ``// selecting array element by selecting ` `    ``// at most M element ` `    ``for``(``int` `i = M; i < N; i++) { ` `        ``pref[i] += pref[i-M]; ` `    ``} ` `     `  `    ``// Print the pref[] for the result ` `    ``for``(``int` `i = 0; i < N; i++) { ` `        ``cout << pref[i] << ``' '``; ` `    ``} ` `     `  `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = {6, 19, 3, 4, 4, 2, 6, 7, 8}; ` `    ``int` `M = 2; ` `    ``int` `N = ``sizeof``(arr)/``sizeof``(arr); ` `     `  `    ``minimumCost(arr, N, M); ` `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Function that find the minimum cost of  ` `// selecting array element ` `static` `void` `minimumCost(``int` `arr[], ``int` `N, ``int` `M)  ` `{ ` `     `  `    ``// Sorting the given array in  ` `    ``// increasing order ` `    ``Arrays.sort(arr); ` `     `  `    ``// To store the prefix sum of arr[]  ` `    ``int` `[]pref = ``new` `int``[N]; ` `    ``pref[``0``] = arr[``0``]; ` `     `  `    ``for``(``int` `i = ``1``; i < N; i++) ` `    ``{ ` `        ``pref[i] = arr[i] + pref[i - ``1``]; ` `    ``} ` `     `  `    ``// Update the pref[] to find the cost ` `    ``// selecting array element by selecting ` `    ``// at most M element ` `    ``for``(``int` `i = M; i < N; i++) ` `    ``{ ` `        ``pref[i] += pref[i - M]; ` `    ``} ` `     `  `    ``// Print the pref[] for the result ` `    ``for``(``int` `i = ``0``; i < N; i++)  ` `    ``{ ` `        ``System.out.print(pref[i] + ``" "``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `arr[] = { ``6``, ``19``, ``3``, ``4``, ``4``, ``2``, ``6``, ``7``, ``8` `}; ` `    ``int` `M = ``2``; ` `    ``int` `N = arr.length; ` `     `  `    ``minimumCost(arr, N, M); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

## Python3

 `# Python3 program for the above approach  ` ` `  `# Function that find the minimum cost  ` `# of selecting array element  ` `def` `minimumCost(arr, N, M): ` `     `  `    ``# Sorting the given array in  ` `    ``# increasing order  ` `    ``arr.sort() ` `     `  `    ``# To store the prefix sum of arr[]  ` `    ``pref ``=` `[] ` `     `  `    ``pref.append(arr[``0``]) ` `     `  `    ``for` `i ``in` `range``(``1``, N): ` `        ``pref.append(arr[i] ``+` `pref[i ``-` `1``]) ` `     `  `    ``# Update the pref[] to find the cost  ` `    ``# selecting array element by selecting  ` `    ``# at most M element  ` `    ``for` `i ``in` `range``(M, N): ` `        ``pref[i] ``+``=` `pref[i ``-` `M] ` `     `  `    ``# Print the pref[] for the result  ` `    ``for` `i ``in` `range``(N): ` `        ``print``(pref[i], end ``=` `' '``) ` ` `  `# Driver Code  ` `arr ``=` `[ ``6``, ``19``, ``3``, ``4``, ``4``, ``2``, ``6``, ``7``, ``8` `] ` `M ``=` `2` `N ``=` `len``(arr) ` ` `  `minimumCost(arr, N, M); ` ` `  `# This code is contributed by yatinagg `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function that find the minimum cost   ` `// of selecting array element ` `static` `void` `minimumCost(``int` `[]arr, ``int` `N, ` `                                   ``int` `M)  ` `{ ` `     `  `    ``// Sorting the given array   ` `    ``// in increasing order ` `    ``Array.Sort(arr); ` `     `  `    ``// To store the prefix sum of []arr  ` `    ``int` `[]pref = ``new` `int``[N]; ` `    ``pref = arr; ` `     `  `    ``for``(``int` `i = 1; i < N; i++) ` `    ``{ ` `       ``pref[i] = arr[i] + pref[i - 1]; ` `    ``} ` `     `  `    ``// Update the pref[] to find the cost ` `    ``// selecting array element by selecting ` `    ``// at most M element ` `    ``for``(``int` `i = M; i < N; i++) ` `    ``{ ` `       ``pref[i] += pref[i - M]; ` `    ``} ` `     `  `    ``// Print the pref[] for the result ` `    ``for``(``int` `i = 0; i < N; i++)  ` `    ``{ ` `       ``Console.Write(pref[i] + ``" "``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]arr = { 6, 19, 3, 4, 4,   ` `                  ``2, 6, 7, 8 }; ` `    ``int` `M = 2; ` `    ``int` `N = arr.Length; ` `     `  `    ``minimumCost(arr, N, M); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar `

Output:

```2 5 11 18 30 43 62 83 121
```

Time Complexity: O(N*log N), where N is the number of element in the array.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.