GSEP 7级T2真题 [202312]纸牌游戏

标题形貌

[GESP202312 七级] 纸牌游戏

标题形貌

你和小杨在玩一个纸牌游戏。
你和小杨各有 3 张牌，分别是 、、0、1、2 。你们要举行 N 轮游戏，每轮游戏两边都要出一张牌，并按 1 降服 0，2 降服 1，0 降服 2 的规则决出胜败。第 i 轮的胜者可以得到 2×ai 分，败者不得分，如果两边出牌类似，则算平手，二人都可得到 ai 分（）（i=1,2,…,N） 。
玩了一会后，你们以为如许太过于单调，于是两边给本身订定了差别的新规则。小杨会在整局游戏开始前确定本身全部 n 轮的出牌，并将他的全部操持告诉你；而你从第 2 轮开始，要么继续出上一轮出的牌，要么记一次“换牌”。游戏竣事时，你换了 t 次牌，就要额外扣 b1+…+bt 分。
请盘算出你最多能得到多少分。
输入格式

第一行一个整数 N，表现游戏轮数。
第二行 N 个用单个空格隔开的非负整数 a1,…,aN ，意义见标题形貌。
第三行 N−1 个用单个空格隔开的非负整数 b1,⋯,bN−1 ，表现换牌的罚分，具体寄义见标题形貌。由于游戏举行 N 轮，以是你至多可以换 N−1 次牌。
第四行 N 个用单个空格隔开的整数 c1,,⋯,cN ，依次表现小杨从第 1 轮至第 N 轮出的牌。包管 ci∈0,1,2 。
输特别式

一行一个整数，表现你最多得到的分数。
样例 #1

样例输入 #1

2. 4
3. 1 2 10 100
4. 1 100 1
5. 1 1 2 0

复制代码

样例输出 #1

3. 219

复制代码

样例 #2

样例输入 #2

2. 6
3. 3 7 2 8 9 4
4. 1 3 9 27 81
5. 0 1 2 1 2 0

复制代码

样例输出 #2

2. 56

复制代码

提示

样例表明 1
你可以第 1 轮出 0，并在第 2,3 轮保持稳定，云云输掉第 1,2 轮，但在第 3 轮中取胜，得到 2×10=20 分；
随后，你可以在第 4 轮中以扣 1 分为代价改出 1 ，并在第 4 轮中取得胜利，得到 2×100=200 分。
云云，你可以得到最高的总分 20+200−1=

219
。
数据范围
对于 30 的测试点，包管 N<=15。
对于 60 的测试点，包管 N<=100。
对于全部测试点，包管 N≤1,000；包管 0≤ai,bi≤106。
样例输入 复制

2. 4
3. 1 2 10 100
4. 1 100 1
5. 1 1 2 0

复制代码

样例输出 复制

3. 219

复制代码

思绪分析： 
懒得在文章里写了，部门都在文章表明里了。
AC代码：

2. #include <bits/stdc++.h>
3. using namespace std;
4. typedef long long ll;
5. ll n;
6. ll sco[1005]; // 得分数组
7. ll loss[1005]; // 失分数组（前缀和）
8. ll arr[1005]; // 对手 n 轮出牌
9. ll dp[1005][3][1005]; // dp[i][j][k]: 第 i 场，出 j，换牌 k 次的最大分数
10. int main() {
11.         cin >> n;
12.         for (int i = 1; i <= n; i ++) cin >> sco[i]; // 得分数组
13.         for (int i = 1; i < n; i ++) { // 换牌至多只有 n-1 次
14.                 cin >> loss[i];
15.                 loss[i] += loss[i - 1]; // 预处理前缀和
16.         }
17.         for (int i = 1; i <= n; i ++) cin >> arr[i]; // 输入对手的出牌方案
19.         for (int i = 1; i <= n; i ++) { // 状态转移
20.                 for (int k = 0; k < i; k ++) { // 注意 k 只需要枚举到 i-1
21.                         if (arr[i] == 0) {
22.                                 dp[i][0][k] = max(dp[i - 1][0][k],
23.                                                   max(dp[i - 1][1][k - 1],
24.                                                       dp[i - 1][2][k - 1])) + sco[i];
26.                                 dp[i][1][k] = max(dp[i - 1][0][k - 1],
27.                                                   max(dp[i - 1][1][k],
28.                                                       dp[i - 1][2][k - 1])) + 2 * sco[i];
30.                                 dp[i][2][k] = max(dp[i - 1][0][k - 1],
31.                                                   max(dp[i - 1][1][k - 1],
32.                                                       dp[i - 1][2][k]));
33.                         } else if (arr[i] == 1) {
34.                                 dp[i][0][k] = max(dp[i - 1][0][k],
35.                                                   max(dp[i - 1][1][k - 1],
36.                                                       dp[i - 1][2][k - 1]));
38.                                 dp[i][1][k] = max(dp[i - 1][0][k - 1],
39.                                                   max(dp[i - 1][1][k],
40.                                                       dp[i - 1][2][k - 1])) + sco[i];
42.                                 dp[i][2][k] = max(dp[i - 1][0][k - 1],
43.                                                   max(dp[i - 1][1][k - 1],
44.                                                       dp[i - 1][2][k])) + 2 * sco[i];
45.                         } else if (arr[i] == 2) {
46.                                 dp[i][0][k] = max(dp[i - 1][0][k],
47.                                                   max(dp[i - 1][1][k - 1],
48.                                                       dp[i - 1][2][k - 1])) + 2 * sco[i];
50.                                 dp[i][1][k] = max(dp[i - 1][0][k - 1],
51.                                                   max(dp[i - 1][1][k],
52.                                                       dp[i - 1][2][k - 1]));
54.                                 dp[i][2][k] = max(dp[i - 1][0][k - 1],
55.                                                   max(dp[i - 1][1][k - 1],
56.                                                       dp[i - 1][2][k])) + sco[i];
57.                         }
58.                 }
59.         }
60.         // 统计答案
61.         ll ans = 0;
62.         for (int k = 0; k < n; k ++) {
63.                 for (int j = 0; j < 3; j ++) {
64.                         ans = max(ans, dp[n][j][k] - loss[k]);
65.                 }
66.         }
67.         cout << ans << endl;
68.         return 0;
69. }

复制代码