寻找最大可能的广告价值

给定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] =值[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

输出：

120