Given a sorted array arr[] consisting of N positive integers such that arr[i] represent the days in which a worker will work and an array cost[] of size 3 representing the salary paid to the workers for 1 day, 7 days and 30 days respectively, the task is to find the minimum cost required to have a worker for all the given days in arr[].
Examples:
Input: arr[] = [2, 4, 6, 7, 8, 10, 17], cost[] = [3, 8, 20]
Output: 14
Explanation:
Below is one of the possible ways of hiring workers with minimum cost:
- On day 2, call a worker for 1 day which costs cost[0] = 3.
- On day 4, call a worker for 7-day which costs cost[1] = 8, which covers day 4, 5, …, 10.
- On day 17, call worker for 1-day which costs cost[0] = 3, which covers day 17.
Therefore, the total cost is 3 + 8 + 3 = 14, which is minimum among all possible combinations of hiring workers.
Input: arr[]= [1, 2, 3, 4, 6, 7, 8, 9, 11, 15, 20, 29], cost = [3, 8, 10]
Output: 10
Approach: The given above problem can be solved using Dynamic Programming because it has Optimal Substructure and Overlapping Subproblems. Follow the steps below to solve the problem:
- Initialize an array, say dp[] where dp[i] stores the minimum cost required to have a worker on the days [i, arr[N – 1]].
- Initialize the value of dp[arr[N – 1]] as the minimum of {cost[0], cost[1], cost[2]}.
- Initialize a variable, say ptr that points at the current element of the array arr[].
-
Iterate over the range [arr[N – 1] – 1, 0] using the variable i and perform the following steps:
-
If the value of ptr >= 0 and arr[ptr] == i then,
- Initialize a variable, say val1 and modify the value as dp[i + 1] + cost[0].
- Initialize a variable, say val2 and modify the value as dp[i + 7] + cost[1].
- Initialize a variable say val3 and modify the value as dp[i + 30] + cost[2].
- Now, update the value of dp[i] as the minimum of {val1, val2, val3}.
- Decrease the value of ptr by 1.
- Otherwise, update the value of dp[i] as dp[i + 1].
-
If the value of ptr >= 0 and arr[ptr] == i then,
- After completing the above steps, print the value of dp[1] as the result.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum cost // to hire the workers for the given // days in the array days[] int MinCost( int days[], int cost[], int N)
{ int size = days[N - 1] + 1;
// Initialize the array dp
int dp[size];
// Minimum Cost for Nth day
dp[size - 1] = min(cost[0],
min(cost[1],
cost[2]));
// Pointer of the array arr[]
int ptr = N - 2;
// Traverse from right to left
for ( int i = size - 2; i > 0; i--) {
if (ptr >= 0 && days[ptr] == i) {
// If worker is hired for 1 day
int val1 = dp[i + 1] + cost[0];
// If worker is hired for 7 days
int val2 = cost[1]
+ ((i + 7 >= size)
? 0
: dp[i + 7]);
// If worker is hired for 30 days
int val3
= cost[2]
+ ((i + 30 >= size)
? 0
: dp[i + 30]);
// Update the value of dp[i] as
// minimum of 3 options
dp[i] = min(val1, min(val2, val3));
ptr--;
}
// If the day is not at the
// array arr[]
else {
dp[i] = dp[i + 1];
}
}
// Return the answer
return dp[1];
} // Driver Code int main()
{ int arr[] = { 2, 4, 6, 7, 8, 10, 17 };
int cost[] = { 3, 8, 20 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << MinCost(arr, cost, N);
return 0;
} |
// Java program for the above approach public class GFG
{ // Function to find the minimum cost // to hire the workers for the given // days in the array days[] static int MinCost( int days[], int cost[], int N)
{ int size = days[N - 1 ] + 1 ;
// Initialize the array dp
int []dp = new int [size];
// Minimum Cost for Nth day
dp[size - 1 ] = Math.min(cost[ 0 ], Math.min(cost[ 1 ], cost[ 2 ]));
// Pointer of the array arr[]
int ptr = N - 2 ;
// Traverse from right to left
for ( int i = size - 2 ; i > 0 ; i--) {
if (ptr >= 0 && days[ptr] == i) {
// If worker is hired for 1 day
int val1 = dp[i + 1 ] + cost[ 0 ];
// If worker is hired for 7 days
int val2 = cost[ 1 ] + ((i + 7 >= size)
? 0
: dp[i + 7 ]);
// If worker is hired for 30 days
int val3
= cost[ 2 ]
+ ((i + 30 >= size)
? 0
: dp[i + 30 ]);
// Update the value of dp[i] as
// minimum of 3 options
dp[i] = Math.min(val1, Math.min(val2, val3));
ptr--;
}
// If the day is not at the
// array arr[]
else {
dp[i] = dp[i + 1 ];
}
}
// Return the answer
return dp[ 1 ];
} // Driver Code public static void main(String args[])
{ int arr[] = { 2 , 4 , 6 , 7 , 8 , 10 , 17 };
int cost[] = { 3 , 8 , 20 };
int N = arr.length;
System.out.println(MinCost(arr, cost, N));
} } // This code is contributed by SoumikMondal |
# Python Program for the above approach # Function to find the minimum cost # to hire the workers for the given # days in the array days[] def MinCost(days, cost, N):
size = days[N - 1 ] + 1
# Initialize the array dp
dp = [ 0 for i in range (size)]
# Minimum Cost for Nth day
dp[size - 1 ] = min (cost[ 0 ], min (cost[ 1 ], cost[ 2 ]))
# Pointer of the array arr[]
ptr = N - 2
# Traverse from right to left
for i in range (size - 2 , 0 , - 1 ):
if (ptr > = 0 and days[ptr] = = i):
# If worker is hired for 1 day
val1 = dp[i + 1 ] + cost[ 0 ]
# If worker is hired for 7 days
val2 = cost[ 1 ] + ( 0 if (i + 7 > = size) else dp[i + 7 ])
# If worker is hired for 30 days
val3 = cost[ 2 ] + ( 0 if (i + 30 > = size) else dp[i + 30 ])
# Update the value of dp[i] as
# minimum of 3 options
dp[i] = min (val1, min (val2, val3))
ptr - = 1 ;
# If the day is not at the
# array arr[]
else :
dp[i] = dp[i + 1 ]
# Return the answer
return dp[ 1 ]
# Driver Code arr = [ 2 , 4 , 6 , 7 , 8 , 10 , 17 ]
cost = [ 3 , 8 , 20 ]
N = len (arr)
print (MinCost(arr, cost, N))
# This code is contributed by gfgking |
// C# program for the above approach using System;
class GFG{
// Function to find the minimum cost // to hire the workers for the given // days in the array days[] static int MinCost( int [] days, int [] cost, int N)
{ int size = days[N - 1] + 1;
// Initialize the array dp
int [] dp = new int [size];
// Minimum Cost for Nth day
dp[size - 1] = Math.Min(
cost[0], Math.Min(cost[1], cost[2]));
// Pointer of the array arr[]
int ptr = N - 2;
// Traverse from right to left
for ( int i = size - 2; i > 0; i--)
{
if (ptr >= 0 && days[ptr] == i)
{
// If worker is hired for 1 day
int val1 = dp[i + 1] + cost[0];
// If worker is hired for 7 days
int val2 = cost[1] + ((i + 7 >= size) ?
0 : dp[i + 7]);
// If worker is hired for 30 days
int val3 = cost[2] + ((i + 30 >= size) ?
0 : dp[i + 30]);
// Update the value of dp[i] as
// minimum of 3 options
dp[i] = Math.Min(val1, Math.Min(val2, val3));
ptr--;
}
// If the day is not at the
// array arr[]
else
{
dp[i] = dp[i + 1];
}
}
// Return the answer
return dp[1];
} // Driver Code public static void Main()
{ int [] arr = { 2, 4, 6, 7, 8, 10, 17 };
int [] cost = { 3, 8, 20 };
int N = arr.Length;
Console.WriteLine(MinCost(arr, cost, N));
} } // This code is contributed by subhammahato348 |
<script> // JavaScript Program for the above approach
// Function to find the minimum cost
// to hire the workers for the given
// days in the array days[]
function MinCost(days, cost, N)
{
let size = days[N - 1] + 1;
// Initialize the array dp
let dp = new Array(size);
// Minimum Cost for Nth day
dp[size - 1] = Math.min(cost[0],
Math.min(cost[1],
cost[2]));
// Pointer of the array arr[]
let ptr = N - 2;
// Traverse from right to left
for (let i = size - 2; i > 0; i--) {
if (ptr >= 0 && days[ptr] == i) {
// If worker is hired for 1 day
let val1 = dp[i + 1] + cost[0];
// If worker is hired for 7 days
let val2 = cost[1]
+ ((i + 7 >= size)
? 0
: dp[i + 7]);
// If worker is hired for 30 days
let val3
= cost[2]
+ ((i + 30 >= size)
? 0
: dp[i + 30]);
// Update the value of dp[i] as
// minimum of 3 options
dp[i] = Math.min(val1, Math.min(val2, val3));
ptr--;
}
// If the day is not at the
// array arr[]
else {
dp[i] = dp[i + 1];
}
}
// Return the answer
return dp[1];
}
// Driver Code
let arr = [2, 4, 6, 7, 8, 10, 17];
let cost = [3, 8, 20];
let N = arr.length;
document.write(MinCost(arr, cost, N));
// This code is contributed by Potta Lokesh
</script>
|
14
Time Complexity: O(M), where M is the maximum element of the array.
Auxiliary Space: O(M)
Recursive Approach:
We have three options:
- Select either First Pass, Second Pass, or Last Pass.
- If a day falls within the validity period of a previously selected pass, we can travel without incurring any expenses.
- The base rule is that if we finish our journey, we won’t have to pay anything.
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum cost // to hire the workers for the given // days in the array days[] int solve( int days[], int costs[], int i, int validity,
int N)
{ if (i >= N)
return 0;
if (days[i] <= validity)
return solve(days, costs, i + 1, validity, N);
else {
int ch1 = costs[0]
+ solve(days, costs, i + 1, days[i], N);
int ch2
= costs[1]
+ solve(days, costs, i + 1, days[i] + 6, N);
int ch3
= costs[2]
+ solve(days, costs, i + 1, days[i] + 29, N);
return min(ch1, min(ch2, ch3));
}
} int MinCost( int days[], int cost[], int N)
{ return solve(days, cost, 0, 0, N);
} // Driver Code int main()
{ int arr[] = { 2, 4, 6, 7, 8, 10, 17 };
int cost[] = { 3, 8, 20 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << MinCost(arr, cost, N);
return 0;
} |
// Java program for the above approach import java.util.Arrays;
public class Main {
// Function to find the minimum cost
// to hire the workers for the given
// days in the array days[]
public static int solve( int [] days, int [] costs, int i,
int validity, int N)
{
if (i >= N)
return 0 ;
if (days[i] <= validity)
return solve(days, costs, i + 1 , validity, N);
else {
int ch1
= costs[ 0 ]
+ solve(days, costs, i + 1 , days[i], N);
int ch2 = costs[ 1 ]
+ solve(days, costs, i + 1 ,
days[i] + 6 , N);
int ch3 = costs[ 2 ]
+ solve(days, costs, i + 1 ,
days[i] + 29 , N);
return Math.min(ch1, Math.min(ch2, ch3));
}
}
public static int MinCost( int [] days, int [] cost, int N)
{
return solve(days, cost, 0 , 0 , N);
}
// Driver Code
public static void main(String[] args)
{
int [] arr = { 2 , 4 , 6 , 7 , 8 , 10 , 17 };
int [] cost = { 3 , 8 , 20 };
int N = arr.length;
System.out.println(MinCost(arr, cost, N));
}
} |
# Python3 program for the above approach # Function to find the minimum cost # to hire the workers for the given # days in the array days[] def solve(days, costs, i, validity, N):
if i > = N:
return 0
if days[i] < = validity:
return solve(days, costs, i + 1 , validity, N)
else :
ch1 = costs[ 0 ] + solve(days, costs, i + 1 , days[i], N)
ch2 = costs[ 1 ] + solve(days, costs, i + 1 , days[i] + 6 , N)
ch3 = costs[ 2 ] + solve(days, costs, i + 1 , days[i] + 29 , N)
return min (ch1, min (ch2, ch3))
def MinCost(days, cost, N):
return solve(days, cost, 0 , 0 , N)
# Driver Code if __name__ = = '__main__' :
arr = [ 2 , 4 , 6 , 7 , 8 , 10 , 17 ]
cost = [ 3 , 8 , 20 ]
N = len (arr)
print (MinCost(arr, cost, N))
|
using System;
public class GFG
{ // Function to find the minimum cost
// to hire the workers for the given
// days in the array days[]
public static int Solve( int [] days, int [] costs, int i, int validity, int N)
{
if (i >= N)
return 0;
if (days[i] <= validity)
return Solve(days, costs, i + 1, validity, N);
else
{
int ch1 = costs[0] + Solve(days, costs, i + 1, days[i], N);
int ch2 = costs[1] + Solve(days, costs, i + 1, days[i] + 6, N);
int ch3 = costs[2] + Solve(days, costs, i + 1, days[i] + 29, N);
return Math.Min(ch1, Math.Min(ch2, ch3));
}
}
public static int MinCost( int [] days, int [] cost, int N)
{
return Solve(days, cost, 0, 0, N);
}
// Driver Code
public static void Main()
{
int [] arr = { 2, 4, 6, 7, 8, 10, 17 };
int [] cost = { 3, 8, 20 };
int N = arr.Length;
Console.WriteLine(MinCost(arr, cost, N));
}
} |
// Javascript program for the above approach // Function to find the minimum cost // to hire the workers for the given // days in the array days[] function solve(days, costs, i, validity, N)
{ if (i >= N)
return 0;
if (days[i] <= validity)
return solve(days, costs, i + 1, validity, N);
else {
let ch1 = costs[0]
+ solve(days, costs, i + 1, days[i], N);
let ch2
= costs[1]
+ solve(days, costs, i + 1, days[i] + 6, N);
let ch3
= costs[2]
+ solve(days, costs, i + 1, days[i] + 29, N);
return Math.min(ch1, Math.min(ch2, ch3));
}
} function MinCost(days, cost, N)
{ return solve(days, cost, 0, 0, N);
} // Driver Code let arr = [2, 4, 6, 7, 8, 10, 17]; let cost = [3, 8, 20]; let N = arr.length; console.log(MinCost(arr, cost, N)); // The code is contributed by Nidhi goel. |
14
- Time Complexity: O(3N), where N = size of array
- Auxiliary Space: O(N)
Dp Memoization (DP Approach):
Cache the recursive result and don’t recompute the repeated subproblems
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum cost // to hire the workers for the given // days in the array days[] int solve( int days[], int costs[], int i, int validity,
int N, vector<vector< int > >& dp)
{ if (i >= N)
return 0;
if (dp[i][validity] != -1)
return dp[i][validity];
if (days[i] <= validity)
return dp[i][validity]
= solve(days, costs, i + 1, validity, N, dp);
else {
int ch1
= costs[0]
+ solve(days, costs, i + 1, days[i], N, dp);
int ch2 = costs[1]
+ solve(days, costs, i + 1, days[i] + 6,
N, dp);
int ch3 = costs[2]
+ solve(days, costs, i + 1, days[i] + 29,
N, dp);
return dp[i][validity] = min(ch1, min(ch2, ch3));
}
} int MinCost( int days[], int cost[], int n)
{ int max_validity = days[n - 1] + 30;
vector<vector< int > > dp(n,
vector< int >(max_validity, -1));
return solve(days, cost, 0, 0, n, dp);
} // Driver Code int main()
{ int arr[] = { 2, 4, 6, 7, 8, 10, 17 };
int cost[] = { 3, 8, 20 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << MinCost(arr, cost, N);
return 0;
} |
//Java code for above implementation import java.util.*;
class GFG {
// Driver code
public static void main(String[] args)
{
int [] arr = { 2 , 4 , 6 , 7 , 8 , 10 , 17 };
int [] cost = { 3 , 8 , 20 };
int N = arr.length;
System.out.println(MinCost(arr, cost, N));
}
public static int MinCost( int [] days, int [] cost, int n)
{
int max_validity = days[n - 1 ] + 30 ;
int [][] dp = new int [n][max_validity];
for ( int i = 0 ; i < n; i++)
Arrays.fill(dp[i], - 1 );
return solve(days, cost, 0 , 0 , n, dp);
}
// Function to find the minimum cost
// to hire the workers for the given
// days in the array days[]
public static int solve( int [] days, int [] costs, int i,
int validity, int N, int [][] dp)
{
if (i >= N)
return 0 ;
if (dp[i][validity] != - 1 )
return dp[i][validity];
if (days[i] <= validity)
return dp[i][validity] = solve(
days, costs, i + 1 , validity, N, dp);
else {
int ch1 = costs[ 0 ]
+ solve(days, costs, i + 1 , days[i],
N, dp);
int ch2 = costs[ 1 ]
+ solve(days, costs, i + 1 ,
days[i] + 6 , N, dp);
int ch3 = costs[ 2 ]
+ solve(days, costs, i + 1 ,
days[i] + 29 , N, dp);
return dp[i][validity]
= Math.min(ch1, Math.min(ch2, ch3));
}
}
} |
# Function to find the minimum cost # to hire the workers for the given # days in the array days[] def solve(days, costs, i, validity, N, dp):
if i > = N:
return 0
if dp[i][validity] ! = - 1 :
return dp[i][validity]
if days[i] < = validity:
return solve(days, costs, i + 1 , validity, N, dp)
else :
ch1 = costs[ 0 ] + solve(days, costs, i + 1 , days[i], N, dp)
ch2 = costs[ 1 ] + solve(days, costs, i + 1 , days[i] + 6 , N, dp)
ch3 = costs[ 2 ] + solve(days, costs, i + 1 , days[i] + 29 , N, dp)
dp[i][validity] = min (ch1, min (ch2, ch3))
return dp[i][validity]
def MinCost(days, cost, n):
max_validity = days[n - 1 ] + 30
dp = [[ - 1 for j in range (max_validity)] for i in range (n)]
return solve(days, cost, 0 , 0 , n, dp)
# Driver Code arr = [ 2 , 4 , 6 , 7 , 8 , 10 , 17 ]
cost = [ 3 , 8 , 20 ]
N = len (arr)
print (MinCost(arr, cost, N))
|
using System;
using System.Collections.Generic;
class GFG {
// Function to find the minimum cost
// to hire the workers for the given
// days in the array days[]
static int Solve( int [] days, int [] costs, int i,
int validity, int N,
List<List< int > > dp)
{
if (i >= N)
return 0;
if (dp[i][validity] != -1)
return dp[i][validity];
if (days[i] <= validity)
return dp[i][validity] = Solve(
days, costs, i + 1, validity, N, dp);
else {
int ch1 = costs[0]
+ Solve(days, costs, i + 1, days[i],
N, dp);
int ch2 = costs[1]
+ Solve(days, costs, i + 1,
days[i] + 6, N, dp);
int ch3 = costs[2]
+ Solve(days, costs, i + 1,
days[i] + 29, N, dp);
return dp[i][validity]
= Math.Min(ch1, Math.Min(ch2, ch3));
}
}
static int MinCost( int [] days, int [] cost, int n)
{
int max_validity = days[n - 1] + 30;
List<List< int > > dp = new List<List< int > >();
for ( int i = 0; i < n; i++) {
List< int > temp = new List< int >();
for ( int j = 0; j < max_validity; j++)
temp.Add(-1);
dp.Add(temp);
}
return Solve(days, cost, 0, 0, n, dp);
}
// Driver Code
static void Main()
{
int [] arr = { 2, 4, 6, 7, 8, 10, 17 };
int [] cost = { 3, 8, 20 };
int N = arr.Length;
Console.WriteLine(MinCost(arr, cost, N));
}
} |
// Function to find the minimum cost // to hire the workers for the given // days in the array days[] function solve(days, costs, i, validity, N, dp) {
if (i >= N) {
return 0;
}
if (dp[i][validity] != -1) {
return dp[i][validity];
}
if (days[i] <= validity) {
return solve(days, costs, i + 1, validity, N, dp);
} else {
let ch1 = costs[0] + solve(days, costs, i + 1, days[i], N, dp);
let ch2 = costs[1] + solve(days, costs, i + 1, days[i] + 6, N, dp);
let ch3 = costs[2] + solve(days, costs, i + 1, days[i] + 29, N, dp);
dp[i][validity] = Math.min(ch1, Math.min(ch2, ch3));
return dp[i][validity];
}
} function MinCost(days, cost, n) {
let max_validity = days[n - 1] + 30;
let dp = new Array(n);
for (let i = 0; i < dp.length; i++) {
dp[i] = new Array(max_validity).fill(-1);
}
return solve(days, cost, 0, 0, n, dp);
} // Driver Code let arr = [2, 4, 6, 7, 8, 10, 17]; let cost = [3, 8, 20]; let N = arr.length; console.log(MinCost(arr, cost, N)); |
14
Time Complexity: O(N), where N = size of array
Auxiliary Space: O(N)
Efficient Approach Using Queues:
Intuition:
Use two queues to keep the indices of the days that are no earlier than the ith day by 7 days and 30 days, respectively.idea behind using queue from no of expired days which will be of no use . So i’ll be removing those using 2 Queues
“1 for days in month and 2nd one for days in week”
Because our final ans(cost obtained) will be min(cost(days), cost(week), cost(month).
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum cost // to hire the workers for the given // days in the array days[] int MinCost(vector< int >& days, vector< int >& costs)
{ queue<pair< int , int > > qmonth;
queue<pair< int , int > > qweek;
// Don't initialize with INT_MAX otherwise ans will go
// in -ve range(i.e wrong answer will be obtained)
int ans = 0;
// loop over days array
for ( int day : days) {
/* Below is intution behind using queue in this
* question */
// Step1: remove expired days from both queues
while (!qmonth.empty()
&& qmonth.front().first + 30 <= day) {
qmonth.pop();
}
while (!qweek.empty()
&& qweek.front().first + 7 <= day) {
qweek.pop();
}
// Step2: add current day's cost
qmonth.push(make_pair(day, ans + costs[2]));
qweek.push(make_pair(day, ans + costs[1]));
// Step3: Update ans
ans = min(ans + costs[0],
min(qmonth.front().second,
qweek.front().second));
}
return ans;
} // Driver Code int main()
{ vector< int > arr{ 2, 4, 6, 7, 8, 10, 15 };
vector< int > cost{ 3, 108, 20 };
cout << MinCost(arr, cost);
return 0;
} |
import java.util.LinkedList;
import java.util.Queue;
import java.util.Vector;
public class Main {
// Function to find the minimum cost to hire the workers
static int minCost(Vector<Integer> days,
Vector<Integer> costs)
{
Queue<Pair<Integer, Integer> > qmonth
= new LinkedList<>();
Queue<Pair<Integer, Integer> > qweek
= new LinkedList<>();
// Don't initialize with Integer.MAX_VALUE otherwise
// the 'ans' will go in the negative range (i.e.
// wrong answer will be obtained)
int ans = 0 ;
// Loop over the days array
for ( int day : days) {
/* Below is the intuition behind using queues in
* this question */
// Step 1: Remove expired days from both queues
while (!qmonth.isEmpty()
&& qmonth.peek().getKey() + 30 <= day) {
qmonth.poll();
}
while (!qweek.isEmpty()
&& qweek.peek().getKey() + 7 <= day) {
qweek.poll();
}
// Step 2: Add the current day's cost
qmonth.add( new Pair<>(day, ans + costs.get( 2 )));
qweek.add( new Pair<>(day, ans + costs.get( 1 )));
// Step 3: Update ans
ans = Math.min(
ans + costs.get( 0 ),
Math.min(qmonth.peek().getValue(),
qweek.peek().getValue()));
}
return ans;
}
// Pair class to store pairs of integers
static class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value)
{
this .key = key;
this .value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
// Driver Code
public static void main(String[] args)
{
Vector<Integer> days = new Vector<>();
days.add( 2 );
days.add( 4 );
days.add( 6 );
days.add( 7 );
days.add( 8 );
days.add( 10 );
days.add( 15 );
Vector<Integer> costs = new Vector<>();
costs.add( 3 );
costs.add( 108 );
costs.add( 20 );
System.out.println( "Minimum cost to hire workers: "
+ minCost(days, costs));
}
} // This code is contributed by akshitaguprzj3 |
# Python program for the above approach def min_cost(days, costs):
q_month = [] # queue for monthly workers
q_week = [] # queue for weekly workers
ans = 0
# loop over days array
for day in days:
# Step1: remove expired days from both queues
while q_month and q_month[ 0 ][ 0 ] + 30 < = day:
q_month.pop( 0 )
while q_week and q_week[ 0 ][ 0 ] + 7 < = day:
q_week.pop( 0 )
# Step2: add current day's cost
q_month.append((day, ans + costs[ 2 ]))
q_week.append((day, ans + costs[ 1 ]))
# Step3: Update ans
ans = min (ans + costs[ 0 ], min (q_month[ 0 ][ 1 ], q_week[ 0 ][ 1 ]))
return ans
#Driver code if __name__ = = "__main__" :
days = [ 2 , 4 , 6 , 7 , 8 , 10 , 15 ]
costs = [ 3 , 108 , 20 ]
print (min_cost(days, costs))
|
// C# program for the above approach using System;
using System.Collections.Generic;
public class GFG
{ public static int MinCost(List< int > days, List< int > costs)
{
List<( int day, int cost)> qMonth = new List<( int , int )>(); // queue for monthly workers
List<( int day, int cost)> qWeek = new List<( int , int )>(); // queue for weekly workers
int ans = 0;
// loop over days array
foreach ( int day in days)
{
// remove expired days from both queues
while (qMonth.Count > 0 && qMonth[0].day + 30 <= day)
{
qMonth.RemoveAt(0);
}
while (qWeek.Count > 0 && qWeek[0].day + 7 <= day)
{
qWeek.RemoveAt(0);
}
// add current day's cost
qMonth.Add((day, ans + costs[2]));
qWeek.Add((day, ans + costs[1]));
// Update ans
ans = Math.Min(ans + costs[0], Math.Min(qMonth[0].cost, qWeek[0].cost));
}
return ans;
}
// Driver code
public static void Main( string [] args)
{
List< int > days = new List< int > { 2, 4, 6, 7, 8, 10, 15 };
List< int > costs = new List< int > { 3, 108, 20 };
Console.WriteLine(MinCost(days, costs));
}
} |
function minCost(days, costs) {
const qMonth = [];
const qWeek = [];
// Don't initialize with Infinity, otherwise ans will go
// in negative range (i.e., the wrong answer will be obtained)
let ans = 0;
// Loop over days array
for (const day of days) {
/* Below is the intuition behind using a queue in this question */
// Step 1: Remove expired days from both queues
while (qMonth.length > 0 && qMonth[0][0] + 30 <= day) {
qMonth.shift();
}
while (qWeek.length > 0 && qWeek[0][0] + 7 <= day) {
qWeek.shift();
}
// Step 2: Add current day's cost
qMonth.push([day, ans + costs[2]]);
qWeek.push([day, ans + costs[1]]);
// Step 3: Update ans
ans = Math.min(ans + costs[0], Math.min(qMonth[0][1], qWeek[0][1]));
}
return ans;
} // Driver Code const arr = [2, 4, 6, 7, 8, 10, 15]; const cost = [3, 108, 20]; console.log(minCost(arr, cost)); // This code is contributed by shivamgupta310570 |
20
Time complexity: O(N)
AuxilairySpace: O(1)