# Minimum cost of choosing the array element

• Last Updated : 28 Feb, 2022

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

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]`
1. 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.```
1.
```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.```
1.
2. 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[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++) {``        ``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[0]);``    ` `    ``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[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++)``    ``{``       ``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`

## Javascript

 ``

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.

My Personal Notes arrow_drop_up