AtCoder Beginner Contest 356 A~F

A.Subsegment Reverse

题意

给出三个正整数$N,L,R$。

对于一个序列$A=(1,2,\dots ,N)$，请你输出翻转了$L\sim R$之间数字后得到的序列。

分析

使用循环进行翻转即可。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5e2;

int a[N];

void solve() {
    int n, l, r;
    cin >> n >> l >> r;
    for (int i = 1; i <= n; i++) {
        a[i] = i;
    }
    for (int i = l, j = r; i <= j; i++, j--) {
        swap(a[i], a[j]);
    }
    for (int i = 1; i <= n; i++) {
        cout << a[i] << ' ';
    }
}

int main () {
    solve();
    return 0;
}

B.Nutrients

题意

高桥每天需要补充$M$种营养物质，第$j$种营养物质至少需要补充$A_j$单位。

今天，他将会吃掉$N$种食物，其中第$i$种食物能依次获得$X_{i,1},X_{i,2},\dots ,X_{i,M}$营养，其中$X_{i,j}$表示第$i$种食物提供的$j$营养物质的数量。

问：今天能否获得足够的营养？

分析

直接在输入的$A$数组中减去每个食物对应的营养即可。

如果输入完成后，$A$数组里只存在负数和$0$，那么就表示获得了足够的营养，否则。说明没有获得足够的营养。

代码

#include <bits/stdc++.h>
using namespace std;

const int N = 3e5 + 5e2;

int a[N];

void solve() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        cin >> a[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            int x;
            cin >> x;
            a[j] -= x;
        }
    }
    for (int i = 1; i <= m; i++) {
        if (a[i] > 0) {
            cout << "No" << endl;
            return;
        }
    }
    cout << "Yes" << endl;
}

int main () {
    solve();
    return 0;
}

C.Keys(二进制枚举)

题意

有$N$把钥匙，其中有真有假。

有一扇门，每次可以选择若干把钥匙一起开门，如果其中至少包含$k$把真的钥匙，那么就可以把门打开。

你对这个门尝试了$M$次以下操作：

• 选择$C_i$把钥匙$A_{i,1},A_{i,2},\dots ,A_{i,C_i}$，并尝试打开门。

• 获得当前尝试的结果$R_i$：

  • 如果$R_i{=}^{\prime }{o}^{\prime }$：表示门被打开了

  • 如果$R_i{=}^{\prime }{x}^{\prime }$：表示门未被打开

已知钥匙的真假情况共有$2^N$种，请问其中有多少种情况满足$M$次操作的结果。

分析

由于$n\le 15$，那么$2^n\le 2^{15}=32768$，因此，总的方案数是很小的，可以使用一个长度为$n$的二进制串表示钥匙的真假情况，即二进制串第$i$位为$0$表示第$i$把钥匙为假，第$i$位为$1$表示第$i$把钥匙为真。

然后枚举所有可能的二进制串$(0\sim 2^n-1)$，并检查每个二进制串是否满足题目要求，即能打开门的方案中真钥匙的数量是否大于等于$k$，不能打开门的方案中真钥匙的数量是否小于$k$。如果满足题目要求，就记录答案数量加一。

最后输出记录的答案数量即可。

代码

#include <bits/stdc++.h>
using namespace std;

const int N = 3e2 + 5e2;

int n, m, k, c[N], r[N], a[N][N];

bool check(int x) {
    for (int i = 1; i <= m; i++) {
        int cnt = 0;
        for (int j = 1; j <= c[i]; j++) {
            if ((x & (1 << (a[i][j] - 1))) != 0) {
                cnt++;
            }
        }
        if (cnt >= k && r[i] == 1 || cnt < k && r[i] == 0) {} else {
            return 0;
        }
    }
    return 1;
}

void solve() {
    cin >> n >> m >> k;
    for (int i = 1; i <= m; i++) {
        cin >> c[i];
        for (int j = 1; j <= c[i]; j++) {
            cin >> a[i][j];
        }
        char op;
        cin >> op;
        if (op == 'o') r[i] = 1;
        else r[i] = 0;
    }
    int ans = 0;
    for (int i = (1 << n) - 1; i >= 0; i--) {
        if (check(i)) {
            ans++;
        }
    }
    cout << ans << endl;
}

int main () {
    solve();
    return 0;
}

D.Masked Popcount(数学)

题意

给出两个数字$N,M$，请你计算KaTeX parse error: Expected 'EOF', got '&' at position 40: …opcount(k\text{&̲}M)取模$998244353$的结果。

分析

先不考虑$M$，先考虑$\sum _{k=0}^{N}popcount(k)$的结果。

使用$ans[i]$表示$1\sim N$之间二进制第$i$为为一的数字个数。

那么$\sum _{k=0}^{N}popcount(k)=\sum _{i=0}^{59}ans[i]$。

然后打表来找一下规律：

• $n=1$时, $ans=[1]$
• $n=2$时, $ans=[1,1]$
• $n=4$时, $ans=[2,2,1]$
• $n=8$时, $ans=[4,4,4,1]$
• $n=16$时,$ans=[8,8,8,8,1]$
• …
• $n=2^i$时,$ans=[2^{i-1},2^{i-1},\dots ,2^{i-1},1]$

这样就可以找到$n$为$2$的次方数，对每位二进制产生的贡献。

那如果$n=2^i+a(a<2^i)$呢？

不难想到，$2^i\sim 2^i+a$最高的二进制位固定为$1$，那么共有$1+a$个这样的数字，对第$i$个二进制位产生的贡献即为$1+a$，然后让$n$减去$2^i$，继续计算剩余的$n$还能产生的贡献即可。

因此，可以依次枚举$59\sim 0$，如果$n\ge 2^i$，那么就让所有的$ans[j](j=0\sim (i-1))$均加上$2^{i-1}$，并让$ans[i]$加上$1+n$ % $2^i$，然后让$n$减去$2^i$。

这样，就可以得到了$\sum _{k=0}^{N}popcount(k)=\sum _{i=0}^{59}ans[i]$，然后计算$popcount$时需要让KaTeX parse error: Expected 'EOF', got '&' at position 9: k \text{&̲} m，那么不难想到，答案即为所有$m$的二进制位上为$1$对应的$ans[i]$之和。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int mod = 998244353;

ll ans[105];

void solve() {
    ll n, m;
    cin >> n >> m;
    for (int i = 60; i >= 0; i--) {
        if (n >= (1ll << i)) {
            ans[i] = ((ans[i] + 1) % mod + n % (1ll << i)) % mod;
            for (int j = i - 1; j >= 0; j--) {
                ans[j] = (ans[j] + (1ll << (i - 1)) % mod) % mod;
            }
            n -=(1ll << i);
        }
    }
    ll res = 0;
    for (int i = 60; i >= 0; i--) {
        if (m & (1ll << i))
            res = (res + ans[i]) % mod;
    }
    cout << res << endl;
}

int main () {
    solve();
    return 0;
}

E.Max/Min(前缀和)

题意

给出一个序列$A=(A_1,\dots ,A_n)$，请你求出:

• $\sum _{i=1}^{n-1}\sum _{j=i+1}^n\lfloor \frac{max(A_i,A_j)}{min(A_i,A_j)}\rfloor$

分析

不难想到，如果$A_i<A_j$，那么$\lfloor \frac{max(A_i,A_j)}{min(A_i,A_j)}\rfloor =\lfloor \frac{A_j}{A_i}\rfloor$。

因此，可以考虑对所有的$A_i$，统计$\sum _{j=i+1}^n\lfloor \frac{A_j}{A_i}\rfloor$。

然后考虑怎么快速计算出$\sum _{j=i+1}^n\lfloor \frac{A_j}{A_i}\rfloor$，由于选择的是向下取整，那么对于数字$x$而言，$y=x\times j\sim (x\times (j+1))-1$得到的$\lfloor \frac{y}{x}\rfloor$均是相同的，因此，可以预处理前缀和，以便于快速知道$x\times j\sim (x\times (j+1))-1$之间的数字个数，此时产生的贡献即为$j\times (pre[(x\times (j+1))-1]-pre[x\times j-1])\times cnt$，其中$cnt$为数字$x$的出现次数。

因此，可以使用$sum$数组记录每个数字的出现次数，然后对记录的数字出现次数预处理前缀和。

然后，就可以枚举数字$i$了，对于数字$i$，再枚举$j$从$1$到$i\times j\le 10^6$的范围内。统计所有数字产生的贡献即可。

此时计算过程中会多计算了一部分，需要在计算后减去。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 5e2;
ll sum[N], pre[N];

int main() {
    int n;
    cin >> n;
    for (int i = 1, num; i <= n; i++) {
        cin >> num;
        sum[num]++;
    }
    for (int i = 1; i <= 1e6; i++) {
        pre[i] = pre[i - 1] + sum[i];
    }
    ll ans = 0;
    for (int i = 1; i <= 1e6; i++) {
        for (int j = 1; j * i <= 1e6; j++) {
            ans += j * (pre[min((j + 1) * i - 1, 1000000)] - pre[j * i - 1]) * sum[i];
        }
        ans -= sum[i] * (1 + sum[i]) / 2;
    }
    cout << ans << endl;
    return 0;
}

F.Distance Component Size Query（平衡树）

题意：

给你一个整数$K$。对于初始为空的集合$S$，依次处理以下两种类型的$Q$查询：

• 1 x:给出一个整数$x$。如果$x$在$S$中，则从$S$中删除$x$。否则，在$S$中加入$x$。
• 2 x:给出位于$S$中的整数$x$。考虑一个图，其中的顶点是$S$中的数字，并且当且仅当两个数字之间的绝对值差最多为$K$时，这两个数字之间有一条边。请打印包含$x$的连通部分中的顶点数。

分析：

本题操作$2$可以看作查询$x$所在的连通块大小，此处我们定义连通块为位于集合$S$中的数，他们中两个数的绝对值之差小于等于$K$时，就可以存在一条边。对于求一个连通块内点的个数，我们考虑缩点。

考虑使用$Set$来维护集合：$S1$维护所有点集合，$S2$维护缩点的集合，即只存放编号最大的点。在$S2$中需要求两个元素之间的距离，对于本题，暴力会超时，需要使用平衡树求排名，即$rank$。普通$Set$不方便进行求$rank$的操作，所以我们使用pb_ds对$S1$进行维护，$S2$使用普通$Set$也可以。

代码：

#include <bits/stdc++.h>
#include <bits/extc++.h>

using namespace std;
using namespace __gnu_pbds;
typedef long long LL;
const LL mod = 1000000007;
const LL MAXN = 4e18;
#define TR tree<LL, null_type, less<LL>, rb_tree_tag, tree_order_statistics_node_update>

TR s1, s2;

int main() {
    int q;
    LL k;
    cin >> q >> k;
    s1.insert(-MAXN), s1.insert(MAXN);
    s2.insert(-MAXN), s2.insert(MAXN);
    while (q--) {
        int cnt;
        LL x;
        cin >> cnt >> x;
        if (cnt == 1) {
            if (s1.find(x) == s1.end()) {
                auto it = s1.insert(x).first;
                LL w1 = *prev(it), w2 = *next(it);
                if (x - w1 <= k)
                    s2.erase(w1);
                if (w2 - x <= k)
                    continue;
                else
                    s2.insert(x);
            } else {
                auto it = s1.find(x);
                LL w1 = *prev(it), w2 = *next(it);
                s1.erase(x), s2.erase(x);
                if (w2 - w1 > k)
                    s2.insert(w1);
            }
        } else {
            auto it = s2.lower_bound(x);  // 找x所在连通块编号最大点
            cout << s1.order_of_key(*it) - s1.order_of_key(*prev(it)) << endl;
        }
    }
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。