codeforces/contest/796/problem/E

女孩在物理考试中遇到困难,计划从两个天才同学那里作弊。每个同学的答题纸上有一些已回答的问题,女孩每次最多查看k个连续问题,总共可以查看p次。帮助女孩找到最多能答对的题目数量。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

E. Exam Cheating
time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
Zane and Zane’s crush have just decided to date! However, the girl is having a problem with her Physics final exam, and needs your help.

There are n questions, numbered from 1 to n. Question i comes before question i + 1 (1 ≤ i < n). Each of the questions cannot be guessed on, due to the huge penalty for wrong answers. The girl luckily sits in the middle of two geniuses, so she is going to cheat.

However, the geniuses have limitations. Each of them may or may not know the answers to some questions. Anyway, it is safe to assume that the answers on their answer sheets are absolutely correct.

To make sure she will not get caught by the proctor, the girl will glance at most p times, each time looking at no more than k consecutive questions on one of the two geniuses’ answer sheet. When the girl looks at some question on an answer sheet, she copies the answer to that question if it is on that answer sheet, or does nothing otherwise.

Help the girl find the maximum number of questions she can get correct.

Input
The first line contains three integers n, p, and k (1 ≤ n, p ≤ 1, 000, 1 ≤ k ≤ min(n, 50)) — the number of questions, the maximum number of times the girl can glance, and the maximum number of consecutive questions that can be looked at in one time glancing, respectively.

The second line starts with one integer r (0 ≤ r ≤ n), denoting the number of questions the first genius has answered on his answer sheet. Then follow r integers a1, a2, …, ar (1 ≤ ai ≤ n) — the answered questions, given in a strictly-increasing order (that is, ai < ai + 1).

The third line starts with one integer s (0 ≤ s ≤ n), denoting the number of questions the second genius has answered on his answer sheet. Then follow s integers b1, b2, …, bs (1 ≤ bi ≤ n) — the answered questions, given in a strictly-increasing order (that is, bi < bi + 1).

Output
Print one integer — the maximum number of questions the girl can answer correctly.

Examples
input
6 2 3
3 1 3 6
4 1 2 5 6
output
4
input
8 3 3
4 1 3 5 6
5 2 4 6 7 8
output
7
Note
Let (x, l, r) denote the action of looking at all questions i such that l ≤ i ≤ r on the answer sheet of the x-th genius.

In the first sample, the girl could get 4 questions correct by performing sequence of actions (1, 1, 3) and (2, 5, 6).

In the second sample, the girl could perform sequence of actions (1, 3, 5), (2, 2, 4), and (2, 6, 8) to get 7 questions correct.

题意:有一个女孩作弊,旁边有两个人,她可以看这两个人的试卷,她每次最多看k个连续的题目,而且她做多看p次,旁边两个人的试卷上的题目不是有所有的有答案,只有部分有,但是只要有的就一定是对的,问你女孩最后最多能做对多少题(抄到多少题)。

解题思路:另dp[i][j[a][b],为前i个题目,已经看了j次,之后,对于第一个人还有a个连续的题目可看,第二个人还有b个连续的题目可看的最多可以做对的题目数。
考虑每次看一次,这一次看第一个人,或者第二个人,或者不看,进行状态转移.具体做法如代码:

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int inf = 1e9;
int dp[2][maxn][60][60];
int n,p,k;
int A[maxn];
int B[maxn];
void init()
{
    for(int i = 0; i < 2; i++)
    {
        for(int j = 0; j < maxn; j++)
        {
            for(int a = 0; a < 55; a++)
            {
                for(int b = 0; b < 55; b++)
                {
                    dp[i][j][a][b] = -inf;
                }
            }
        }
    }
    dp[0][0][0][0] = 0;
    memset(A,0,sizeof(A));
    memset(B,0,sizeof(B));
}
int main()
{
    scanf("%d%d%d",&n,&p,&k);
    if(p > 2*((n + k - 1)/k)) p = 2*((n + k - 1)/k);
    init();
    int r;
    int x;
    scanf("%d",&r);
    for(int i = 1; i <= r; i++)
    {
        scanf("%d",&x);
        A[x] = 1;
    }
    int s;
    scanf("%d",&s);
    for(int i = 1; i <= s; i++)
    {
        scanf("%d",&x);
        B[x] = 1;
    }

    for(int i = 1; i <= n; i++)
    {
        int now = i&1;
        int pre = !now;
        for(int j = 0; j <= p; j++)
        {
            for(int a = 0; a < k; a++)
            {
                for(int b = 0; b < k; b++)
                {
                    if(a == 0&&b != 0)
                    {
                        dp[now][j + 1][k - 1][b - 1] = max(dp[now][j + 1][k - 1][b - 1],dp[pre][j][a][b] + (A[i]|B[i]));
                        dp[now][j + 1][a][k - 1] = max(dp[now][j + 1][a][k - 1],dp[pre][j][a][b] + B[i]);
                        dp[now][j][a][b - 1] = max(dp[now][j][a][b - 1],dp[pre][j][a][b] + B[i]);
                    }
                    else if(b == 0&&a != 0)
                    {
                        dp[now][j + 1][k - 1][b] = max(dp[now][j + 1][k - 1][b],dp[pre][j][a][b] + A[i]);

                        dp[now][j + 1][a - 1][k - 1] = max(dp[now][j + 1][a - 1][k - 1],dp[pre][j][a][b] + (A[i]|B[i]));
                        dp[now][j][a - 1][b] = max(dp[now][j][a - 1][b],dp[pre][j][a][b] + A[i]);
                    }
                    else if(a == 0&&b == 0)
                    {
                        dp[now][j + 1][k - 1][b] = max(dp[now][j + 1][k - 1][b],dp[pre][j][a][b] + A[i]);

                        dp[now][j + 1][a][k - 1] = max(dp[now][j + 1][a][k - 1],dp[pre][j][a][b] + B[i]);
                        dp[now][j][a][b] = max(dp[now][j][a][b],dp[pre][j][a][b]);
                    }
                    else
                    {
                        dp[now][j + 1][k - 1][b - 1] = max(dp[now][j + 1][k - 1][b - 1],dp[pre][j][a][b] + (A[i]|B[i]));
                        dp[now][j + 1][a - 1][k - 1] = max(dp[now][j + 1][a - 1][k - 1],dp[pre][j][a][b] + (A[i]|B[i]));
                        dp[now][j][a - 1][b - 1] = max(dp[now][j][a - 1][b - 1],dp[pre][j][a][b] + (A[i]|B[i]));

                    }


                }
            }
        }
        for(int j = 0; j <= p; j++)
        {
            for(int a = 0; a <= k; a++)
            {
                for(int b = 0; b <= k; b++)
                {
                    dp[pre][j][a][b] = -inf;
                }
            }
        }
    }
    int Max = -inf;
    for(int j = 0; j <= p; j++)
    {
        for(int a = 0; a <= k; a++)
        {
            for(int b = 0; b <= k; b++)
            {
                Max = max(Max,dp[n&1][j][a][b]);
            }
        }
    }
    printf("%d\n",Max);
    return 0;

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值