📜  动态规划 |高努力与低努力的任务问题

📅  最后修改于: 2021-09-17 07:39:14             🧑  作者: Mango

您有 n 天,每天 (di) 您可以执行高工作量任务 (hi) 或低工作量任务 (li) 或不执行任务,限制条件是您只能选择高工作量任务前一天没有任务。编写一个程序来找出你在这 n 天内可以执行的最大任务量。
例子:

No. of days (n) = 5
Day      L.E.   H.E
1        1       3
2        5       6
3        4       8
4        5       7
5        3       6
Maximum amount of tasks 
        = 3 + 5 + 4 + 5 + 3 
        = 20

最优子结构
要找到直到第 i 天完成的最大任务量,我们需要比较 2 个选择:

  1. 在那天做高强度的任务,然后找出直到 (i – 2) 天为止完成的最大任务量。
  2. 在当天进行低努力任务,并找到直到第 (i – 1) 天完成的最大任务量。

设 high [1…n] 是第 i 天高努力任务量的输入数组,low [1…n] 是第 i 天低努力任务量的输入数组。
设 max_task (high [], low [], i) 是返回到第 i 天完成的最大任务量的函数,因此它将返回 max(high[i] + max_task(high, low, (i – 2)) , 低 [i] + max_task (高, 低, (i – 1)))
因此,该问题具有最优子结构性质,因为该问题可以使用子问题的解来解决。
重叠子问题
以下是 High-effort vs. Low-effort 任务问题的简单递归实现。实现只是简单地遵循上面提到的递归结构。因此,High-effort vs. Low-effort Task Problem 具有动态规划问题的两个特性。

C++
// A naive recursive C++ program to find maximum
// tasks.
#include 
using namespace std;
 
// Returns the maximum among the 2 numbers
int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
int maxTasks(int high[], int low[], int n)
{
    // If n is less than equal to 0, then no
    // solution exists
    if (n <= 0)
        return 0;
 
    /* Determines which task to choose on day n,
    then returns the maximum till that day */
    return max(high[n - 1] + maxTasks(high, low, (n - 2)),
            low[n - 1] + maxTasks(high, low, (n - 1)));
}
 
// Driver code
int main()
{
    int n = 5;
    int high[] = {3, 6, 8, 7, 6};
    int low[] = {1, 5, 4, 5, 3};
    cout << maxTasks(high, low, n);
    return 0;
}
 
// This code is contributed by Shubhamsingh10


C
// A naive recursive C program to find maximum
// tasks.
#include
 
// Returns the maximum among the 2 numbers
int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
int maxTasks(int high[], int low[], int n)
{
    // If n is less than equal to 0, then no
    // solution exists
    if (n <= 0)
        return 0;
 
    /* Determines which task to choose on day n,
       then returns the maximum till that day */
    return max(high[n-1] + maxTasks(high, low, (n-2)),
              low[n-1] + maxTasks(high, low, (n-1)));
}
 
// Driver program to test above function
int main()
{
    int n = 5;
    int high[] = {3, 6, 8, 7, 6};
    int low[] = {1, 5, 4, 5, 3};
    printf("%dn", maxTasks(high, low, n));
    return 0;
}


Java
// A naive recursive Java program
// to find maximum tasks.
 
class GFG{
     
    // Returns maximum amount of task
    // that can be done till day n
    static int maxTasks(int high[], int low[], int n)
    {
         
        // If n is less than equal to 0,
        // then no solution exists
        if (n <= 0)
            return 0;
 
        /* Determines which task to choose on day n,
            then returns the maximum till that day */
        return Math.max(high[n - 1] + maxTasks(high, low, (n - 2)),
                low[n - 1] + maxTasks(high, low, (n - 1)));
    }
 
    // Driver code
    public static void main(String []args)
    {
        int n = 5;
        int high[] = {3, 6, 8, 7, 6};
        int low[] = {1, 5, 4, 5, 3};
        System.out.println( maxTasks(high, low, n));
    }
}
 
// This code is contributed by Ita_c.


Python3
# A naive recursive Python3 program to
# find maximum tasks.
 
# Returns maximum amount of task
# that can be done till day n
def maxTasks(high, low, n) :
     
    # If n is less than equal to 0,
    # then no solution exists
    if (n <= 0) :
        return 0
 
    # Determines which task to choose on day n,
    # then returns the maximum till that day
    return max(high[n - 1] + maxTasks(high, low, (n - 2)),
               low[n - 1] + maxTasks(high, low, (n - 1)));
 
# Driver Code
if __name__ == "__main__" :
 
    n = 5;
    high = [3, 6, 8, 7, 6]
    low = [1, 5, 4, 5, 3]
    print(maxTasks(high, low, n));
 
# This code is contributed by Ryuga


C#
// A naive recursive C# program
// to find maximum tasks.
using System;
 
class GFG
{
     
    // Returns maximum amount of task
    // that can be done till day n
    static int maxTasks(int[] high,
                    int[] low, int n)
    {
         
        // If n is less than equal to 0,
        // then no solution exists
        if (n <= 0)
            return 0;
 
        /* Determines which task to choose on day n,
            then returns the maximum till that day */
        return Math.Max(high[n - 1] +
            maxTasks(high, low, (n - 2)), low[n - 1] +
            maxTasks(high, low, (n - 1)));
    }
 
    // Driver code
    public static void Main()
    {
        int n = 5;
        int[] high = {3, 6, 8, 7, 6};
        int[] low = {1, 5, 4, 5, 3};
        Console.Write( maxTasks(high, low, n));
    }
}
 
// This code is contributed by Ita_c.


PHP


Javascript


C++
// A DP based C++ program to find maximum tasks.
#include
 
// Returns the maximum among the 2 numbers
int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
int maxTasks(int high[], int low[], int n)
{
    // An array task_dp that stores the maximum
    // task done
    int task_dp[n+1];
 
    // If n = 0, no solution exists
    task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    task_dp[1] = high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for (int i = 2; i <= n; i++)
        task_dp[i] = max(high[i-1] + task_dp[i-2],
                         low[i-1] + task_dp[i-1]);
    return task_dp[n];
}
 
// Driver program to test above function
int main()
{
    int n = 5;
    int high[] = {3, 6, 8, 7, 6};
    int low[] = {1, 5, 4, 5, 3};
    printf("%dn", maxTasks(high, low, n));
    return 0;
}


Java
// A DP based Java program to find maximum tasks.
class GFG
{
     
// Returns the maximum among the 2 numbers
static int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
static int maxTasks(int []high, int []low, int n)
{
    // An array task_dp that stores the maximum
    // task done
    int[] task_dp = new int[n + 1];
 
    // If n = 0, no solution exists
    task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    task_dp[1] = high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for (int i = 2; i <= n; i++)
        task_dp[i] = Math.max(high[i - 1] + task_dp[i - 2],
                        low[i - 1] + task_dp[i - 1]);
    return task_dp[n];
}
 
// Driver code
public static void main(String[] args)
{
    int n = 5;
    int []high = {3, 6, 8, 7, 6};
    int []low = {1, 5, 4, 5, 3};
    System.out.println(maxTasks(high, low, n));
}
}
 
// This code is contributed by Code_Mech.


Python3
# A DP based Python3 program to find maximum tasks.
# Returns the maximum among the 2 numbers
def max1(x, y):
 
    return x if(x > y) else y;
 
# Returns maximum amount of task
# that can be done till day n
def maxTasks(high, low, n):
 
    # An array task_dp that stores
    # the maximum task done
    task_dp = [0] * (n + 1);
 
    # If n = 0, no solution exists
    task_dp[0] = 0;
 
    # If n = 1, high effort task
    # on that day will be the solution
    task_dp[1] = high[0];
 
    # Fill the entire array determining
    # which task to choose on day i
    for i in range(2, n + 1):
        task_dp[i] = max(high[i - 1] + task_dp[i - 2],
                          low[i - 1] + task_dp[i - 1]);
    return task_dp[n];
 
# Driver code
n = 5;
high = [3, 6, 8, 7, 6];
low = [1, 5, 4, 5, 3];
print(maxTasks(high, low, n));
 
# This code is contributed by mits


C#
// A DP based C# program to find maximum tasks.
using System;
 
class GFG
{
     
// Returns the maximum among the 2 numbers
static int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
static int maxTasks(int []high, int []low, int n)
{
    // An array task_dp that stores the maximum
    // task done
    int[] task_dp = new int[n + 1];
 
    // If n = 0, no solution exists
    task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    task_dp[1] = high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for (int i = 2; i <= n; i++)
        task_dp[i] = max(high[i - 1] + task_dp[i - 2],
                        low[i - 1] + task_dp[i - 1]);
    return task_dp[n];
}
 
// Driver program to test above function
static void Main()
{
    int n = 5;
    int []high = {3, 6, 8, 7, 6};
    int []low = {1, 5, 4, 5, 3};
    Console.WriteLine(maxTasks(high, low, n));
}
}
 
// This code is contributed by mits


PHP
 $y ? $x : $y);
}
 
// Returns maximum amount of task that can be
// done till day n
function maxTasks($high, $low, $n)
{
    // An array task_dp that stores the maximum
    // task done
    $task_dp = array($n + 1);
 
    // If n = 0, no solution exists
    $task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    $task_dp[1] = $high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for ($i = 2; $i <= $n; $i++)
        $task_dp[$i] = max($high[$i - 1] + $task_dp[$i - 2],
                        $low[$i - 1] + $task_dp[$i - 1]);
    return $task_dp[$n];
}
 
// Driver code
{
    $n = 5;
    $high = array(3, 6, 8, 7, 6);
    $low = array(1, 5, 4, 5, 3);
    echo(maxTasks($high, $low, $n));
}
 
// This code is contributed by Code_Mech.


Javascript


输出 :

20

需要注意的是,上述函数一次又一次地计算相同的子问题。
因此,这个问题具有重叠子问题的性质。因此,High-effort vs. Low-effort Task Problem 具有动态规划问题的两个特性。
动态规划解决方案

C++

// A DP based C++ program to find maximum tasks.
#include
 
// Returns the maximum among the 2 numbers
int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
int maxTasks(int high[], int low[], int n)
{
    // An array task_dp that stores the maximum
    // task done
    int task_dp[n+1];
 
    // If n = 0, no solution exists
    task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    task_dp[1] = high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for (int i = 2; i <= n; i++)
        task_dp[i] = max(high[i-1] + task_dp[i-2],
                         low[i-1] + task_dp[i-1]);
    return task_dp[n];
}
 
// Driver program to test above function
int main()
{
    int n = 5;
    int high[] = {3, 6, 8, 7, 6};
    int low[] = {1, 5, 4, 5, 3};
    printf("%dn", maxTasks(high, low, n));
    return 0;
}

Java

// A DP based Java program to find maximum tasks.
class GFG
{
     
// Returns the maximum among the 2 numbers
static int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
static int maxTasks(int []high, int []low, int n)
{
    // An array task_dp that stores the maximum
    // task done
    int[] task_dp = new int[n + 1];
 
    // If n = 0, no solution exists
    task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    task_dp[1] = high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for (int i = 2; i <= n; i++)
        task_dp[i] = Math.max(high[i - 1] + task_dp[i - 2],
                        low[i - 1] + task_dp[i - 1]);
    return task_dp[n];
}
 
// Driver code
public static void main(String[] args)
{
    int n = 5;
    int []high = {3, 6, 8, 7, 6};
    int []low = {1, 5, 4, 5, 3};
    System.out.println(maxTasks(high, low, n));
}
}
 
// This code is contributed by Code_Mech.

蟒蛇3

# A DP based Python3 program to find maximum tasks.
# Returns the maximum among the 2 numbers
def max1(x, y):
 
    return x if(x > y) else y;
 
# Returns maximum amount of task
# that can be done till day n
def maxTasks(high, low, n):
 
    # An array task_dp that stores
    # the maximum task done
    task_dp = [0] * (n + 1);
 
    # If n = 0, no solution exists
    task_dp[0] = 0;
 
    # If n = 1, high effort task
    # on that day will be the solution
    task_dp[1] = high[0];
 
    # Fill the entire array determining
    # which task to choose on day i
    for i in range(2, n + 1):
        task_dp[i] = max(high[i - 1] + task_dp[i - 2],
                          low[i - 1] + task_dp[i - 1]);
    return task_dp[n];
 
# Driver code
n = 5;
high = [3, 6, 8, 7, 6];
low = [1, 5, 4, 5, 3];
print(maxTasks(high, low, n));
 
# This code is contributed by mits

C#

// A DP based C# program to find maximum tasks.
using System;
 
class GFG
{
     
// Returns the maximum among the 2 numbers
static int max(int x, int y)
{
    return (x > y ? x : y);
}
 
// Returns maximum amount of task that can be
// done till day n
static int maxTasks(int []high, int []low, int n)
{
    // An array task_dp that stores the maximum
    // task done
    int[] task_dp = new int[n + 1];
 
    // If n = 0, no solution exists
    task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    task_dp[1] = high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for (int i = 2; i <= n; i++)
        task_dp[i] = max(high[i - 1] + task_dp[i - 2],
                        low[i - 1] + task_dp[i - 1]);
    return task_dp[n];
}
 
// Driver program to test above function
static void Main()
{
    int n = 5;
    int []high = {3, 6, 8, 7, 6};
    int []low = {1, 5, 4, 5, 3};
    Console.WriteLine(maxTasks(high, low, n));
}
}
 
// This code is contributed by mits

PHP

 $y ? $x : $y);
}
 
// Returns maximum amount of task that can be
// done till day n
function maxTasks($high, $low, $n)
{
    // An array task_dp that stores the maximum
    // task done
    $task_dp = array($n + 1);
 
    // If n = 0, no solution exists
    $task_dp[0] = 0;
 
    // If n = 1, high effort task on that day will
    // be the solution
    $task_dp[1] = $high[0];
 
    // Fill the entire array determining which
    // task to choose on day i
    for ($i = 2; $i <= $n; $i++)
        $task_dp[$i] = max($high[$i - 1] + $task_dp[$i - 2],
                        $low[$i - 1] + $task_dp[$i - 1]);
    return $task_dp[$n];
}
 
// Driver code
{
    $n = 5;
    $high = array(3, 6, 8, 7, 6);
    $low = array(1, 5, 4, 5, 3);
    echo(maxTasks($high, $low, $n));
}
 
// This code is contributed by Code_Mech.

Javascript


输出:

20

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程