Related Articles

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

• Difficulty Level : Hard
• Last Updated : 17 Sep, 2021

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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 = 3.
2. On day 4, call a worker for 7-day which costs cost = 8, which covers day 4, 5, …, 10.
3. On day 17, call worker for 1-day which costs cost = 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, cost, cost}.
• 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.
• Initialize a variable, say val2 and modify the value as dp[i + 7] + cost.
• Initialize a variable say val3 and modify the value as dp[i + 30] + cost.
• 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 as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``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,``                       ``min(cost,``                           ``cost));` `    ``// 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;` `            ``// If worker is hired for 7 days``            ``int` `val2 = cost``                       ``+ ((i + 7 >= size)``                              ``? 0``                              ``: dp[i + 7]);` `            ``// If worker is hired for 30 days``            ``int` `val3``                ``= cost``                  ``+ ((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;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 4, 6, 7, 8, 10, 17 };``    ``int` `cost[] = { 3, 8, 20 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``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``]))` `    ``# Poleter 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, Math.Min(cost, cost));` `    ``// 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;` `            ``// If worker is hired for 7 days``            ``int` `val2 = cost + ((i + 7 >= size) ?``                            ``0 : dp[i + 7]);` `            ``// If worker is hired for 30 days``            ``int` `val3 = cost + ((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;``}` `// 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

 ``
Output:
`14`

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

My Personal Notes arrow_drop_up