给定 n 个任务所花费的时间。求完成任务所需的最短时间，使得允许跳过任务，但不能跳过两个连续的任务。
例子 ：
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预期时间复杂度为 O(n)，额外空间为 O(1)。
给定的问题具有以下递归性质。
让minTime(i)是完成第 i 个任务的最短时间。它可以写成两个值中的最小值。
- 如果第 i 个任务包含在列表中，则最短时间为 incl(i)
- 如果从结果中排除第 i 个任务的最短时间，让这个时间为 excl(i)
minTime(i) = min(excl(i), incl(i)) 如果有 n 个任务且索引从 0 开始，则结果为minTime(n-1) 。
incl(i)可以写成如下。
// 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)可以写成如下。
// There is only one possibility (Previous task must be
// included as we can't skip consecutive tasks.
excl(i) = incl(i-1) 一个简单的解决方案是制作两个表 incl[] 和 excl[] 来存储任务的时间。最后返回 incl[n-1] 和 excl[n-1] 的最小值。该解决方案需要 O(n) 时间和 O(n) 空间。
如果我们仔细观察，我们会注意到我们只需要 incl 和 excl 以前的工作。所以我们可以节省空间，在 O(n) 时间和 O(1) 空间内解决问题。下面是这个想法的 C++ 实现。
C++
// C++ program to find minimum time to finish tasks
// such that no two consecutive tasks are skipped.
#include
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 exluded
// Process remaining n-1 tasks
for (int i=1; i Java
// 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 exluded
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 maximum 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 SainiPython3
# 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 exluded
# 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 maximum 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#
// 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 exluded
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 maximum 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
Javascript
输出 ：
12
12
22如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。