Question

在IPL 2025中，每位玩家的支付金额因比赛而异。比赛费用取决于反对的质量，场地等。新赛季每场比赛的比赛费用已提前公布。每支球队都必须执行强制轮换政策，以便球员在赛季中不会连续三场比赛。尼基尔是队长并为每场比赛选择球队。他希望为自己分配一个比赛时间表，以便在赛季期间通过比赛费用最大化他的收入。

Input: 10 3 5 7 3
Output: 23
(Explanation: 10+3+7+3)
Input: 3 2 3 2 3 5 1 3
Output: 17
(Explanation: 3+3+3+5+3)

我的复发关系如下所示我想知道它是对还是错：

dp[i, 1] = max(dp[i-1][0] + c[i], dp[i-1][1])

dp[i, 0] = dp[i-1][1] + dp[i-2][1]

其中dp [i，1]表示在输入数组中播放“i”匹配时可以获得的最高费用。

和dp [i，0]表示在输入数组中未播放“i”匹配时可以获得的最高费用。

Answer 1

你的解决方案是错误的，如果dp[i, 1]，你没有考虑玩家在游戏中玩i - 1并跳过游戏i - 2的情况，这是一个有效案件。

如果您跳过ith匹配，dp[i, 0] = dp[i - 1][1] + dp[i - 2][1]也是错误的，因为dp[i, 1]会考虑从0到i的所有匹配，而不只是一个匹配，所以添加dp[i - 1, 1] 1}}和dp[i - 1, 2]将重复计算。

修正：

dp[i, 1] = max(dp[i - 1, 0] + c[i]  , dp[i - 2, 0] + c[i - 1] + c[i])
dp[i, 0] = max(dp[i - 1, 1] , dp[i - 1, 0])

Answer 2

使用一维DP可以轻松解决此问题让： dp [i] =直到索引i为止不包含3个连续元素的和。

从基本案例开始：

//taking only first element 
dp[0] = a[0];
//taking first and second element
dp[1] = a[1];

对于第三个元素，我们将有3种情况：

1-丢弃第三个元素

dp[2] = d[1];

2-丢弃第二个元素：

dp[2] = dp[0] + a[2]

3-丢弃第一个元素：

dp[2] = a[1] + a[2]

所以最终Dp [2]将是这3个中的最大值：

dp[2] = max( dp[1] , max( dp[0] + a[2] , a[1] + a[2] ) );

我们可以为ith元素扩展相同的方法：

  dp[i] = dp[i-1];
  dp[i] = max(dp[i],dp[i-2]+a[i]);
  dp[i] = max(dp[i],dp[i-3] + a[i-1]+a[i]);

Answer 3

第一个简单的想法是找到数组dp[N][3]。递归关系：

dp[i][0] = max( dp[i-2][2] ,dp[i-2][1] )
dp[i][1] = max( dp[i-1][0] + A[i], dp[i-2][1] + A[i], dp[i-2][2] + A[i])
dp[i][2] = dp[i-1][1] + A[i]

您的问题代码bwlow

#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include<cstring>
#include <math.h>
#include<cstdio>
#include<string>
#include <queue>
#include <list>

using namespace std;

int dp[100000][3];
int main(){
    int n = 8;
    int A[] ={3,2,3,2,3,5,1,3};
    memset(dp,0,sizeof(dp));
    dp[0][1] = A[0];
    dp[1][1] = max(A[0],A[1]);
    dp[0][2] = A[0];
    dp[1][2] = A[0]+A[1];
    int ans = 0;
    for(int i = 2; i<n; i++){
        dp[i][0] = max(dp[i-2][2],dp[i-2][1]);
        dp[i][1] = max(max(dp[i-1][0]+A[i],dp[i-2][1]+A[i]),dp[i-2][2]+A[i]);
        dp[i][2] = dp[i-1][1]+A[i];
    }
    for(int i=0; i<n; i++){
        for(int j=0; j<3; j++){
            ans = max(ans,dp[i][j]);
        }
    }
    cout<<ans;
    return 0;
}

如果你想一点，你就可以对代码进行优化。

IPL匹配的最大总和

3 个答案: