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.
- Sort the given array in increasing order.
- 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.
- 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.
- 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++ 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;
} |
// 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 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# 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 |
<script> // Javascript program for the above approach // Function that find the minimum cost of // selecting array element function minimumCost(arr, N, M)
{ // Sorting the given array in
// increasing order
arr.sort((a, b) => a - b);
// To store the prefix sum of arr[]
let pref = Array.from({length: N}, (_, i) => 0);
pref[0] = arr[0];
for (let 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 (let i = M; i < N; i++)
{
pref[i] += pref[i - M];
}
// Print the pref[] for the result
for (let i = 0; i < N; i++)
{
document.write(pref[i] + " " );
}
} // Driver Code let arr = [ 6, 19, 3, 4, 4, 2, 6, 7, 8 ];
let M = 2;
let N = arr.length;
minimumCost(arr, N, M);
</script> |
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.
Space Complexity: O(N) as pref array has been created. Here, N is the number of element in the array.