Algorithm IPL匹配中的最大和

在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”匹配时可以获得的最大费用。

您的解决方案是错误的，如果

dp[i，1]

，您没有考虑玩家玩游戏

i-1

和跳过游戏

i-2

时的情况，这是一个有效的情况

<> >当跳过<代码> < <代码> >匹配时，<代码> dp[i，0 ]＝dp[i]（1）+dp[i－2 ] [1 ] 也是错误的，因为<代码> dp[i，1 ] < /> >考虑从0到i的所有匹配，而不是仅匹配一个，因此同时添加<<代码> dp[i- 1, 1 ] < /> >和<代码> dp[i-1, 2 ] < /C> >将重复计算。

修正：

---

第一个简单的想法是找到数组

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]

你的问题代码很低

#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;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间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；
对于（inti=2；i你可以很容易地用一维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]

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

  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]);

3-丢弃第一个元素：

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

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

  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]);

因此，最终Dp[2]将是以下3项中的最大值：

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

我们可以为第i个元素扩展相同的方法：

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

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

  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]);

您是否针对给定的输入集运行了它？我认为这不正确，因为dp[I-1][0]+c[I]适用于未选择previous和dp[I-1][1]的情况当选择“上一个”时是这种情况。@newbie\u旧的两个公式都是错误的，请参阅我的update@newbie_old顺便说一句，你能给我问题陈述的链接吗？我在谷歌上找不到IPL205。我将等待其他人的回复，然后再研究你的解决方案。@newbie\u old慢慢来，我会努力改进它：）在任何一场比赛中，我们都有三个选择：1.这场比赛我们选择不比赛（dp[i][0]），因此我们必须取之前比赛的最大值max（dp[i-2][2]，dp[i-2][1]）；2.这场比赛是序列的开始，即我们知道我们只能打两场比赛，因此这场比赛是序列中的第一场比赛。dp[i-1][0]+a[i]表示我们没有选择上一个匹配项，因为当前匹配项是序列的开始，或者我们选择了上一个匹配项中的最大值。3.此匹配项是序列中的第二个匹配项。因此，除了添加上一个匹配点之外，我们别无选择。