Open In App

Minimum cost to complete given tasks if cost of 1, 7 and 30 days are given

Last Updated : 16 Sep, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

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:

  1. On day 2, call a worker for 1 day which costs cost[0] = 3.
  2. On day 4, call a worker for 7-day which costs cost[1] = 8, which covers day 4, 5, …, 10.
  3. 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:
    1. 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.
    2. Otherwise, update the value of dp[i] as dp[i + 1].
  • After completing the above steps, print the value of dp[1] as the result.

Below is the implementation of the above approach:

C++




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




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


Python3




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




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


Javascript




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


Output

14








Time Complexity: O(M), where M is the maximum element of the array.
Auxiliary Space: O(M)

Recursive Approach:

We have three options:

  1. Select either First Pass, Second Pass, or Last Pass.
  2. If a day falls within the validity period of a previously selected pass, we can travel without incurring any expenses.
  3. The base rule is that if we finish our journey, we won’t have to pay anything.

C++




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




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




# 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))


C#




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




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


Output

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




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




//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));
        }
    }
}


Python3




# 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))


C#




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));
    }
}


Javascript




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


Output

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




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


Java




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


Python3




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




// 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));
    }
}


Javascript




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


Output

20








Time complexity: O(N)
AuxilairySpace: O(1)



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads