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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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.