寻找广告的最大可能价值

给定M小时的广告限制[0, M)和N 个广告，每个广告都有开始时间和广告价值。每个广告时长为1 分钟。如果两个广告之间的时间差必须至少为K分钟，则任务是找到可实现的最大可能广告价值。

例子：

Input: Arr[][] = {{0, 10}, {4, 10}, {5, 30}} 
N = 3 
K = 4 
M = 6 
Output: 40
Either we can take advertisement starting at 0 and 4 or at 0 and 5. 
Maximum Value if 40 if we take 0 and 5 pair.

Input: Arr[][] = {{0, 10}, {4, 110}, {5, 30}} 
N = 3 
K = 4 
M = 6 
Output: 120  

方法：

• 我们将使用动态规划，维护一个dp[M][2]其中
  • dp[i][0]表示第i分钟开始没有广告时达到的最大广告值，
  • dp[i][1]表示如果我们选择第 i 分钟开始的广告获得的最大广告价值。最终答案将是dp[M-1][0] 和 dp[M-1][1] 的最大值。
• 建立 dp 状态-
  • 对于dp[i][0] ，因为我们没有广告在第i分钟开始，所以没有K分钟的限制，因此dp[i][0] = max(dp[i-1][0], dp[i-1][1])作为前一分钟，我们可以有两种情况。
  • 对于dp[i][1] ，现在我们在第i分钟开始有广告，这意味着在分钟i – 1, i – 2, …, i – (K – 1)我们不能有任何广告。因此，我们必须查看第(i – K)分钟。因此， dp[i][1] = value[i] + max(dp[iK][0], dp[iK][1]) ，在第i – K分钟，我们可以再次拥有这两种情况。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
#define ll long long int
 
// Function to find maximum
// possible advertising value
int max_value(int array[][2], int M,
              int K, int N)
{
    // To store advertising
    // value at i-th minute
    int time[M] = { 0 };
 
    for (int i = 0; i < N; i++) {
        time[array[i][0]] = array[i][1];
    }
 
    int dp[M][2];
 
    // Base Case
    dp[0][0] = 0;
    dp[0][1] = time[0];
 
    for (int i = 1; i < M; i++) {
 
        // If no advertisement is
        // taken on ith minute
        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
 
        // If advertisement is taken
        // on i-th minute
        dp[i][1] = time[i];
 
        if (i - K >= 0) {
            dp[i][1]
                += max(dp[i - K][0], dp[i - K][1]);
        }
    }
 
    return max(dp[M - 1][0], dp[M - 1][1]);
}
 
// Driver's Code
int main()
{
    // array[][0] start time
    // array[][1] advertising value
    int array[][2] = {
        { 0, 10 },
        { 4, 110 },
        { 5, 30 }
    };
 
    int N = 3;
    int K = 4;
    int M = 6;
 
    cout << max_value(array, M, K, N);
}

Java

// Java program for the above approach
import java.util.*;
import java.lang.*;
 
class GFG{
     
// Function to find maximum
// possible advertising value
static int max_value(int array[][], int M,
                     int K, int N)
{
     
    // To store advertising
    // value at i-th minute
    int[] time = new int[M];
   
    for(int i = 0; i < N; i++)
    {
        time[array[i][0]] = array[i][1];
    }
   
    int[][] dp = new int[M][2];
     
    // Base Case
    dp[0][0] = 0;
    dp[0][1] = time[0];
   
    for(int i = 1; i < M; i++)
    {
         
        // If no advertisement is
        // taken on ith minute
        dp[i][0] = Math.max(dp[i - 1][0],
                            dp[i - 1][1]);
   
        // If advertisement is taken
        // on i-th minute
        dp[i][1] = time[i];
   
        if (i - K >= 0)
        {
            dp[i][1] += Math.max(dp[i - K][0],
                                 dp[i - K][1]);
        }
    }
    return Math.max(dp[M - 1][0], dp[M - 1][1]);
}
   
// Driver code
public static void main(String[] args)
{
     
    // array[][0] start time
    // array[][1] advertising value
    int array[][] = { { 0, 10 },
                      { 4, 110 },
                      { 5, 30 } };
     
    int N = 3;
    int K = 4;
    int M = 6;
     
    System.out.println(max_value(array, M, K, N));
}
}
 
// This code is contributed by offbeat

Javascript

 
// Javascript program for the above approach
 
// Function to find maximum
// possible advertising value
function max_value(array, M, K, N)
{
    // To store advertising
    // value at i-th minute
    var time = Array(M).fill(0);
 
    for (var i = 0; i < N; i++) {
        time[array[i][0]] = array[i][1];
    }
 
    var dp = Array.from(Array(M), ()=> Array(2));
 
    // Base Case
    dp[0][0] = 0;
    dp[0][1] = time[0];
 
    for (var i = 1; i < M; i++) {
 
        // If no advertisement is
        // taken on ith minute
        dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1]);
 
        // If advertisement is taken
        // on i-th minute
        dp[i][1] = time[i];
 
        if (i - K >= 0) {
            dp[i][1]
                += Math.max(dp[i - K][0], dp[i - K][1]);
        }
    }
 
    return Math.max(dp[M - 1][0], dp[M - 1][1]);
}
 
// Driver's Code
// array[][0] start time
// array[][1] advertising value
var array = [
    [ 0, 10],
    [ 4, 110 ],
    [ 5, 30 ]
];
var N = 3;
var K = 4;
var M = 6;
document.write( max_value(array, M, K, N));
 
 

输出：

120

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