Minimum time to finish tasks without skipping two consecutive
Last Updated :
20 Dec, 2022
Given the time taken by n tasks. Find the minimum time needed to finish the tasks such that skipping of tasks is allowed, but can not skip two consecutive tasks.
Examples :
Input : arr[] = {10, 5, 7, 10}
Output : 12
We can skip first and last task and
finish these task in 12 min.
Input : arr[] = {10}
Output : 0
There is only one task and we can
skip it.
Input : arr[] = {10, 30}
Output : 10
Input : arr[] = {10, 5, 2, 4, 8, 6, 7, 10}
Output : 22
The given problem has the following recursive property.
Let minTime(i) be minimum time to finish till i'th task. It can be written as minimum of two values.
- Minimum time if i'th task is included in list, let this time be incl(i)
- Minimum time if i'th task is excluded from result, let this time be excl(i)
minTime(i) = min(excl(i), incl(i))
The result is minTime(n-1) if there are n tasks and indexes start from 0.
incl(i) can be written as below.
// There are two possibilities
// (a) Previous task is also included
// (b) Previous task is not included
incl(i) = min(incl(i-1), excl(i-1)) +
arr[i] // Since this is inclusive
// arr[i] must be included
excl(i) can be written as below.
// There is only one possibility (Previous task must be
// included as we can't skip consecutive tasks.
excl(i) = incl(i-1)
A simple solution is to make two tables incl[] and excl[] to store times for tasks. Finally, return a minimum of incl[n-1] and excl[n-1]. This solution requires O(n) time and O(n) space.
If we take a closer look, we can notice that we only need incl and excl of the previous job. So we can save space and solve the problem in O(n) time and O(1) space.
Below is the implementation of the above approach:
C++
// C++ program to find minimum time to finish tasks
// such that no two consecutive tasks are skipped.
#include <bits/stdc++.h>
using namespace std;
// arr[] represents time taken by n given tasks
int minTime(int arr[], int n)
{
// Corner Cases
if (n <= 0)
return 0;
// Initialize value for the case when there
// is only one task in task list.
int incl = arr[0]; // First task is included
int excl = 0; // First task is excluded
// Process remaining n-1 tasks
for (int i=1; i<n; i++)
{
// Time taken if current task is included
// There are two possibilities
// (a) Previous task is also included
// (b) Previous task is not included
int incl_new = arr[i] + min(excl, incl);
// Time taken when current task is not
// included. There is only one possibility
// that previous task is also included.
int excl_new = incl;
// Update incl and excl for next iteration
incl = incl_new;
excl = excl_new;
}
// Return minimum of two values for last task
return min(incl, excl);
}
// Driver code
int main()
{
int arr1[] = {10, 5, 2, 7, 10};
int n1 = sizeof(arr1)/sizeof(arr1[0]);
cout << minTime(arr1, n1) << endl;
int arr2[] = {10, 5, 7, 10};
int n2 = sizeof(arr2)/sizeof(arr2[0]);
cout << minTime(arr2, n2) << endl;
int arr3[] = {10, 5, 2, 4, 8, 6, 7, 10};
int n3 = sizeof(arr3)/sizeof(arr3[0]);
cout << minTime(arr3, n3) << endl;
return 0;
}
// Java program to find minimum time to
// finish tasks such that no two
// consecutive tasks are skipped.
import java.io.*;
class GFG {
// arr[] represents time taken by n
// given tasks
static int minTime(int arr[], int n)
{
// Corner Cases
if (n <= 0)
return 0;
// Initialize value for the case
// when there is only one task in
// task list.
// First task is included
int incl = arr[0];
// First task is excluded
int excl = 0;
// Process remaining n-1 tasks
for (int i = 1; i < n; i++)
{
// Time taken if current task is
// included. There are two
// possibilities
// (a) Previous task is also included
// (b) Previous task is not included
int incl_new = arr[i] + Math.min(excl,
incl);
// Time taken when current task is not
// included. There is only one
// possibility that previous task is
// also included.
int excl_new = incl;
// Update incl and excl for next
// iteration
incl = incl_new;
excl = excl_new;
}
// Return minimum of two values for
// last task
return Math.min(incl, excl);
}
// Driver code
public static void main(String[] args)
{
int arr1[] = {10, 5, 2, 7, 10};
int n1 = arr1.length;
System.out.println(minTime(arr1, n1));
int arr2[] = {10, 5, 7, 10};
int n2 = arr2.length;
System.out.println(minTime(arr2, n2));
int arr3[] = {10, 5, 2, 4, 8, 6, 7, 10};
int n3 = arr3.length;
System.out.println(minTime(arr3, n3));
}
}
// This code is contributed by Prerna Saini
# Python3 program to find minimum
# time to finish tasks such that no
# two consecutive tasks are skipped.
# arr[] represents time
# taken by n given tasks
def minTime(arr, n):
# Corner Cases
if (n <= 0): return 0
# Initialize value for the
# case when there is only
# one task in task list.
incl = arr[0] # First task is included
excl = 0 # First task is excluded
# Process remaining n-1 tasks
for i in range(1, n):
# Time taken if current task is included
# There are two possibilities
# (a) Previous task is also included
# (b) Previous task is not included
incl_new = arr[i] + min(excl, incl)
# Time taken when current task is not
# included. There is only one possibility
# that previous task is also included.
excl_new = incl
# Update incl and excl for next iteration
incl = incl_new
excl = excl_new
# Return minimum of two values for last task
return min(incl, excl)
# Driver code
arr1 = [10, 5, 2, 7, 10]
n1 = len(arr1)
print(minTime(arr1, n1))
arr2 = [10, 5, 7, 10]
n2 = len(arr2)
print(minTime(arr2, n2))
arr3 = [10, 5, 2, 4, 8, 6, 7, 10]
n3 = len(arr3)
print(minTime(arr3, n3))
# This code is contributed by Anant Agarwal.
// C# program to find minimum time to
// finish tasks such that no two
// consecutive tasks are skipped.
using System;
class GFG {
// arr[] represents time taken by n
// given tasks
static int minTime(int []arr, int n)
{
// Corner Cases
if (n <= 0)
return 0;
// Initialize value for the case
// when there is only one task in
// task list.
// First task is included
int incl = arr[0];
// First task is excluded
int excl = 0;
// Process remaining n-1 tasks
for (int i = 1; i < n; i++)
{
// Time taken if current task is
// included. There are two
// possibilities
// (a) Previous task is also included
// (b) Previous task is not included
int incl_new = arr[i] + Math.Min(excl,
incl);
// Time taken when current task is not
// included. There is only one
// possibility that previous task is
// also included.
int excl_new = incl;
// Update incl and excl for next
// iteration
incl = incl_new;
excl = excl_new;
}
// Return minimum of two values for
// last task
return Math.Min(incl, excl);
}
// Driver code
public static void Main()
{
int []arr1 = {10, 5, 2, 7, 10};
int n1 = arr1.Length;
Console.WriteLine(minTime(arr1, n1));
int []arr2 = {10, 5, 7, 10};
int n2 = arr2.Length;
Console.WriteLine(minTime(arr2, n2));
int []arr3 = {10, 5, 2, 4, 8, 6, 7, 10};
int n3 = arr3.Length;
Console.WriteLine(minTime(arr3, n3));
}
}
// This code is contributed by Anant Agarwal.
<?php
// PHP program to find minimum time
// to finish tasks such that no two
// consecutive tasks are skipped.
// arr[] represents time
// taken by n given tasks
function minTime($arr, $n)
{
// Corner Cases
if ($n <= 0)
return 0;
// Initialize value for the
// case when there is only
// one task in task list.
// First task is included
$incl = $arr[0];
// First task is excluded
$excl = 0;
// Process remaining n-1 tasks
for ($i = 1; $i < $n; $i++)
{
// Time taken if current task is
// included There are two possibilities
// (a) Previous task is also included
// (b) Previous task is not included
$incl_new = $arr[$i] + min($excl, $incl);
// Time taken when current task
// is not included. There is only
// one possibility that previous
// task is also included.
$excl_new = $incl;
// Update incl and excl
// for next iteration
$incl = $incl_new;
$excl = $excl_new;
}
// Return minimum of two
// values for last task
return min($incl, $excl);
}
// Driver code
$arr1 = array(10, 5, 2, 7, 10);
$n1 = sizeof($arr1);
echo minTime($arr1, $n1),"\n" ;
$arr2 = array(10, 5, 7, 10);
$n2 = sizeof($arr2);
echo minTime($arr2, $n2),"\n" ;
$arr3 = array(10, 5, 2, 4,
8, 6, 7, 10);
$n3 = sizeof($arr3);
echo minTime($arr3, $n3);
// This code is contributed
// by nitin mittal.
?>
<script>
// Javascript program to find minimum time to
// finish tasks such that no two
// consecutive tasks are skipped.
// arr[] represents time taken by n
// given tasks
function minTime(arr, n)
{
// Corner Cases
if (n <= 0)
return 0;
// Initialize value for the case
// when there is only one task in
// task list.
// First task is included
let incl = arr[0];
// First task is excluded
let excl = 0;
// Process remaining n-1 tasks
for (let i = 1; i < n; i++)
{
// Time taken if current task is
// included. There are two
// possibilities
// (a) Previous task is also included
// (b) Previous task is not included
let incl_new = arr[i] + Math.min(excl,
incl);
// Time taken when current task is not
// included. There is only one
// possibility that previous task is
// also included.
let excl_new = incl;
// Update incl and excl for next
// iteration
incl = incl_new;
excl = excl_new;
}
// Return minimum of two values for
// last task
return Math.min(incl, excl);
}
// Driver Code
let arr1 = [10, 5, 2, 7, 10];
let n1 = arr1.length;
document.write(minTime(arr1, n1) + "<br/>");
let arr2 = [10, 5, 7, 10];
let n2 = arr2.length;
document.write(minTime(arr2, n2) + "<br/>");
let arr3 = [10, 5, 2, 4, 8, 6, 7, 10];
let n3 = arr3.length;
document.write(minTime(arr3, n3) + "<br/>");
</script>
Time Complexity: O(n)
Auxiliary Space: O(1)
Related Problems:
Find minimum time to finish all jobs with given constraints
Maximum sum such that no two elements are adjacent.
Similar Reads
Minimize total cost without repeating same task in two consecutive iterations Given an array arr[][] of size M X N where M represents the number of tasks and N represents number of iteration. An entry in the array arr[i][j] represents the cost to perform task j at the ith iteration. Given that the same task j cannot be computed in two consecutive iterations, the task is to co
14 min read
Minimum work to be done per day to finish given tasks within D days Given an array task[] of size N denoting amount of work to be done for each task, the problem is to find the minimum amount of work to be done on each day so that all the tasks can be completed in at most D days. Note: On one day work can be done for only one task. Examples: Input: task[] = [3, 4, 7
9 min read
Assign N tasks to N persons to minimize total time There are N persons and N jobs. Given an array arr[] of size N*N where (arr[0], arr[1], . . ., arr[N-1]) denotes the time taken by the first person to perform (1st, 2nd, . . ., Nth) job respectively and similarly from arr[N] to arr[2*N -1] for the second and so on for other persons. The task is to a
15+ min read
Find minimum time to finish all jobs with given constraints Given an array job[], where each element represents the time required to complete a specific job. There are k identical assignees available to complete these jobs, and each assignee takes t units of time to complete one unit of a job. The task is to determine the minimum time required to complete al
11 min read
Minimum time required to complete all tasks without altering their order Given a string S consisting of N characters (representing the tasks to perform) and a positive integer K, the task is to find the minimum time required to complete all the given tasks in the given order such that each task takes one unit of time and each task of the same type must be performed at an
6 min read