Codeforces Round #666 (Div. 1)

A. Multiples of Length (CF 1396 A)

题目大意

给定一个$n$个数字的数组$a$，你需要进行三次操作。

每次操作，选择一个区间，然后对区间里的每一个数，加上一个该区间长度的倍数。不同数加的数可以不同。

输出三次操作的区间以及该区间每个数所加的数。

可以证明保证有解。

解题思路

构造题。为应对任意数字的情况，我们让每个$a_{i}$的系数变为$0$。

如果$n = 1$，那么答案就是

$1 \space \space 1$

$-a_{1}$

$1 \space \space 1$

$0$

$1 \space \space 1$

$0$

否则就

$1 \space \space 1$

$-a_{1}$

$1 \space \space n$

$0 \space \space -n \times a_{2} \space \space -n \times a_{3} \space \space \dots \space \space -n \times a_{n}$

$2 \space \space n$

$(n-1) \times a_{2} \space \space (n-1) \times a_{3} \space \space \dots \space \space (n-1) \times a_{n}$

神奇的代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int k;
    cin >> k;
    vector<LL> qwq;
    int n = k;
    while(k--){
        LL a;
        cin>>a;
        qwq.push_back(a);
    }
    if (n == 1){
        cout<<"1 1"<<endl;
        cout<<-qwq[0]<<endl;
        cout<<"1 1"<<endl;
        cout<<'0'<<endl;
        cout<<"1 1"<<endl;
        cout<<'0'<<endl;
        return 0;
    }
    cout<<"1 1"<<endl;
    cout<<-qwq[0]<<endl;
    cout<<"1 "<<n<<endl;
    qwq[0] = 0;
    for(size_t i = 0; i < qwq.size(); ++ i)
        cout<<-(LL)n*qwq[i]<<(i == qwq.size() - 1?'\n':' ');
    cout<<"2 "<<n<<endl;
    for(size_t i = 1; i < qwq.size(); ++ i)
        cout<<(LL)(n-1)*qwq[i]<<(i == qwq.size() - 1?'\n':' ');
    return 0;
}

---

B. Stoned Game (CF 1396 B)

题目大意

初始$n$堆石子，$T$和$HL$轮流拿，$T$先。一个人不能拿上一轮对方拿的那堆石子。当两者均采取最优策略的情况下，谁必赢。

解题思路

博弈题。

很显然，$n=1$时$T$赢。

$n=2$时，若两堆石子数相同，则$HL$赢，否则$T$赢。

其余的，他们采取最优策略，即总是拿石子数最多的那堆，模拟即可得到答案。

或者可以这样考虑，因为最后是剩下两堆石子的，而如果两堆石头数量相同，则$HL$赢。那么，我们假设最后剩下的是第$i$堆和第$j$堆，初始$a_{i} < a_{j}$，$HL$为了赢，需要花$a_{j} - a_{i}$轮，使得这两堆相同，剩下的取其他堆，只要此时剩下的其他堆的数量是偶数，那么最后的局面就进入$HL$必赢局面。

也即$\sum\limits_{k = 1}^{n} a_{k} - a_{i} - a_{j} - (a_{j} - a_{i}) = \sum\limits_{k = 1}^{n} a_{k} - 2a_{j}$是偶数，那么$HL$必赢。

由于$2a_{j}$时偶数，不改变结果的奇偶性，所以判断$\sum\limits_{k = 1}^{n} a_{k}$的奇偶性即可。

特别的，如果最大堆的数量大于其他堆数量的和，则$T$必赢。

综上，如果最大堆的数量大于其他堆数量的和或$\sum\limits_{k = 1}^{n} a_{k}$是奇数，则$T$必赢，否则$HL$必赢。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
int main(void) {
    int kase; read(kase);
    for (int ii = 1; ii <= kase; ii++) {
        int n;
        read(n);
        int tot = 0;
        vector<int> qwq(n);
        for(int i = 0; i < n; ++ i){
            read(qwq[i]);
            tot += qwq[i];
        }
        sort(qwq.begin(),qwq.end());
        if (n == 1) puts("T");
        else if (n == 2){
            if (qwq[0] == qwq[1]) puts("HL");
            else puts("T");
        }
        else {
            tot -= qwq[qwq.size() - 1];
            if (qwq[qwq.size() - 1] > tot) puts("T");
            else{
                tot -= qwq[qwq.size() - 1];
                if (tot & 1) puts("T");
                else puts("HL");
            }
        }
    }
    return 0;
}

---

C. Monster Invaders (CF 1396 C)

题目大意

有$n$个关卡，初始第一个关卡，第$i$个关卡有$a_{i}$个$1HP$的普通怪物和$1$个$2HP$的$Boss$怪物。

你有三种枪：

• 手枪，对一只怪物造成$1HP$伤害，花费$r_1$时间
• 激光枪，对所有怪物造成$1HP$伤害，花费$r_2$时间
• AWP，直接干掉一只怪物，花费$r_3$时间

除了第二种，其余枪要在干掉该关卡的普通小怪后才能对$Boss$造成伤害。且如果对$Boss$造成伤害，且$Boss$未死时，必须转移到上一个或下一个关卡。当然，干掉完当前关卡的怪物需要手动转移到下一个关卡。

转移关卡花费$d$时间。

问干掉$Boss$需要的最短时间。

数据保证$r_{1} \leq r_{2} \leq r_{3}$。

解题思路

干掉一个关卡的所有怪物，我们有三种方法。

• 手枪+AWP
• 激光枪+手枪
• 手枪+手枪

第一种很简单，干完该关卡boss后就跳到下一个关卡。

关键就是第二个和第三个，它会跳到其他关卡，然后再跳回来。问题就是会往哪跳，跳多远。

首先任何往后跳的都可以看成是后来往前跳，所以方向就确定了。

然后可以猜想证明的是，最优情况下，一定是只往前跳一次。也就是来回两个关卡跳。

如果是来回三个关卡跳，需要的总时间有两个，一个是跳跃总时间，一个是干掉该层怪物所需要的时间。

后者时间是固定的，我们来看前者。

三个关卡来回跳的转移次数是6次，而三个关卡来回跳可以看成两个两个关卡的来回跳，同样是转移6次，两者时间相同。（从三个关卡最左边开始）

如果是来回四个关卡跳，则转移次数是9次，而两个两个关卡来回跳外加一次跳，转移次数是7次，后者更优。

所以我们就只用关心来回两个关卡来回跳即可。

设$f[i]$表示干掉前$i$个关卡的怪物所需要的最小时间。

首先可以直接从第$i - 1$个关卡转移过来，然后采用三种方法中最小的一个干掉第$i$个关卡的怪物。

或者从第$i - 2$个关卡转移过来，考虑在第$i$个关卡和第$i - 1$个关卡来回跳，分别考虑第$i$个关卡采用三种方式和第$i-1$个关卡采用的三种方式，取最小值。

注意的是如果在考虑第$n$个关卡时，如果采用第一种方式，然后跳到第$n-1$关卡时，不需要再跳回到第$i$个关卡。

还有就是在考虑第$1$个关卡和第$2$个关卡来回跳的时候，不要算上第$0$个关卡跳到第$1$个关卡的转移时间。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
const int N = 1e6 + 8;
 
LL r1, r2, r3;
 
LL a[N];
 
LL f[N];
 
LL d, n;
 
LL fuck0(int i){
    return r1 * a[i] + r3;
}
 
LL fuck1(int i){
    return r2 + r1;
}
 
LL fuck2(int i){
    return r1 * a[i] + r1 + r1;
}
 
int main(void) {
    read(n);
    read(r1);
    read(r2);
    read(r3);
    read(d);
    for(int i = 1; i <= n; ++ i)
        read(a[i]);
    f[1] = fuck0(1);
    for(int i = 2; i <= n; ++ i){
        f[i] = min({
                    f[i - 1] + d + fuck0(i),
                    f[i - 1] + d + d + d + min(fuck1(i), fuck2(i)),
                    f[i - 2] + d + d + d + d * (i != n) + min(fuck1(i - 1), fuck2(i - 1)) + fuck0(i),
                    f[i - 2] + (i != 2) * d + d + d + d + min(fuck1(i - 1), fuck2(i - 1)) + min(fuck1(i), fuck2(i))
                });
    }
    write(f[n], '\n');
 
    return 0;
}

---