A. Median of an Array （思维）
题意：
给定一个数组 a a a，每次操作可以选择数组 a a a中一个数字并将其加一，询问至少需要操作多少次，才能使得数组 a a a中位数增加。
分析：
我们先对数组排序，找出中位数，从中位数开始，和中位数大小相同的元素都需要加一。
代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 998244353;
const int N = 2e5 + 5;
int a[N];
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + 1 + n);
int pos = (n + 1) / 2, ans = 0;
for (int i = pos; i <= n; i++) {
if (a[i] == a[pos])
ans++;
}
cout << ans << endl;
}
return 0;
}
B.Maximum Sum （思维）
题意：
给出一个
n
n
n 个整数组成的数组
a
a
a 。现在要对它进行
k
k
k 次操作。在一次操作中，选择了数组
a
a
a 的任意连续子数组（可能为空），并在数组的任意位置插入了该子数组的和。
询问经过
k
k
k 次操作后数组的最大和。
答案需要模
1
0
9
+
7
10^9 + 7
109+7 。
分析：
每次操作取当前最大的连续子数组，再把它插到原来的连续子数组里面，相当于每次乘两倍。
代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<LL> a(n + 1);
LL ans = 0;
LL maxval = 0;
LL minval = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ans += a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= n; i++) {
maxval = max(maxval, a[i] - a[minval]);
if (a[i] < a[minval])
minval = i;
}
ans -= maxval;
for (int i = 1; i <= k; i++) {
maxval = maxval * 2LL % mod;
}
cout << ((ans % mod) + maxval + mod) % mod << endl;
}
return 0;
}
C.Tree Cutting （二分答案）
题意：
给定一棵树，需要删除 k k k条边，使得剩下的 k + 1 k+1 k+1个联通块中的最小结点数最大。输出这个最大值。
分析：
二分答案 x x x，能否让剩余的连通块最小值为 x x x。设当前父节点为 u u u，那么对于当前节点 v v v及其子树，如果它的 s i z e ≥ x size \ge x size≥x，那么就删除 u , v u,v u,v这条边。如果不足 x x x就保留，尝试和父节点凑更多的点。
代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int N = 2e5 + 5;
int n, k, x;
vector<int> g[N];
int res;
int dfs(int u, int f) {
int size1 = 1;
for (auto v: g[u]) {
if (v == f) {
continue;
}
size1 += dfs(v, u);
}
if (size1 >= x) {
++res;
size1 = 0;
}
return size1;
}
int check(int mid) {
x = mid;
res = 0;
int size1 = dfs(1, -1);
return res > k;
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
g[i].clear();
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int l = 1, r = 1e9, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
cout << ans << endl;
}
return 0;
}
D.Birthday Gift （位运算）
题意：
将数组划分为 k k k个连续段，并满足以下要求：
- 求出每个连续段的异或和
- 这些异或和做或运算，最终答案小于等于 x x x
求出最大的 k k k。
分析：
首先将 x x x进行加一，将不等式变为各个异或段的或运算的结果小于 x x x。对于特定第 i i i位：
-
如果存在奇数个 1 1 1，那么它们异或的结果为 1 1 1，在这里边分成多段，加若干或运算，结果也是 1 1 1。
-
如果存在偶数个 1 1 1，为使得最终的各个异或段的或运算的结果为 0 0 0，我们可以对偶数个 1 1 1进行分段。
因为要尽可能让段的个数尽可能多，所以我们按照每两个 1 1 1进行分段。从高位往低位枚举，如果所有元素在第 i i i位的运算结果为 1 1 1
-
如果 x x x在第 i i i的结果为 0 0 0，那么停止分段，因为此时的分段运算结果，已经大于 x x x了。
-
如果 x x x在第 i i i的结果为 1 1 1，那么可以在下一个低位，继续分段，因为此时分段运算结果等于 x x x，只要后续低位，存在小于 x x x对应 b i t bit bit位的元素，就可以使用该分段了。
如果所有元素在第 i i i位的运算结果为 0 0 0并且 x x x在第 i i i位的结果为 1 1 1，那么此时数组 a a a的分段的运算结果是小于 x x x的，可以计算当前分段个数，更新答案。
代码：
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
x++;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
int ans = -1;
int flag1 = 0;
for (int i = 30; i >= 0; i--) {
vector<int> tmp;
bool flag = 0;
for (int j = 0; j < a.size(); j++) {
if (!flag)
tmp.push_back(a[j]);
else
tmp.back() ^= a[j];
if (a[j] & (1 << i))
flag = !flag;
}
if (!(x & (1 << i))) {
if (flag) {
cout << ans << endl;
flag1 = 1;
break;
}
a = tmp;
} else {
if (!flag)
ans = max(ans, (int) tmp.size());
}
}
if (flag1 == 0)
cout << ans << endl;
}
return 0;
}
E. Girl Permutation （数学）
题意：
现有一个长度为 n n n的排列 p p p，给定 p p p的前缀最大值的下标集合 a a a和后缀最大值的下标集合 b b b(按升序排序)，求可能的排列数量，并将答案对 1 0 9 + 7 10^9 + 7 109+7取模。
分析：
根据定义可以发现最大值 n n n的位置一定会出现在前缀和后缀数组中，并且分别是前缀的最大值与后缀的最小值。首先检查一下合法性，如果两者不等则直接返回 0 0 0。其余部分可以从剩余的 n − 1 n - 1 n−1个数字中挑选前缀需要的数目的数字，剩余的交给后缀。每次从后往前看，如果当前位置出现在了前缀数组中，我们就只能拿当前手上最大的值放在这里，否则可以拿手上除了最大值的任意值放在这里。前后缀独立处理完的结果相乘就得到了答案。
代码：
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
template<const int T>
struct ModInt {
const static int mod = T;
int x;
ModInt(int x = 0) : x(x % mod) {}
ModInt(long long x) : x(int(x % mod)) {}
int val() { return x; }
ModInt operator+(const ModInt &a) const {
int x0 = x + a.x;
return ModInt(x0 < mod ? x0 : x0 - mod);
}
ModInt operator-(const ModInt &a) const {
int x0 = x - a.x;
return ModInt(x0 < 0 ? x0 + mod : x0);
}
ModInt operator*(const ModInt &a) const { return ModInt(1LL * x * a.x % mod); }
ModInt operator/(const ModInt &a) const { return *this * a.inv(); }
bool operator==(const ModInt &a) const { return x == a.x; };
bool operator!=(const ModInt &a) const { return x != a.x; };
void operator+=(const ModInt &a) {
x += a.x;
if (x >= mod)
x -= mod;
}
void operator-=(const ModInt &a) {
x -= a.x;
if (x < 0)
x += mod;
}
void operator*=(const ModInt &a) { x = 1LL * x * a.x % mod; }
void operator/=(const ModInt &a) { *this = *this / a; }
friend ModInt operator+(int y, const ModInt &a) {
int x0 = y + a.x;
return ModInt(x0 < mod ? x0 : x0 - mod);
}
friend ModInt operator-(int y, const ModInt &a) {
int x0 = y - a.x;
return ModInt(x0 < 0 ? x0 + mod : x0);
}
friend ModInt operator*(int y, const ModInt &a) { return ModInt(1LL * y * a.x % mod); }
friend ModInt operator/(int y, const ModInt &a) { return ModInt(y) / a; }
friend ostream &operator<<(ostream &os, const ModInt &a) { return os << a.x; }
friend istream &operator>>(istream &is, ModInt &t) { return is >> t.x; }
ModInt pow(int64_t n) const {
ModInt res(1), mul(x);
while (n) {
if (n & 1)
res *= mul;
mul *= mul;
n >>= 1;
}
return res;
}
ModInt inv() const {
int a = x, b = mod, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0)
u += mod;
return u;
}
};
using mint = ModInt<mod>;
mint fact[N], invfact[N];
void init() {
fact[0] = invfact[0] = 1;
for (int i = 1; i < N; i++)
fact[i] = fact[i - 1] * i;
invfact[N - 1] = fact[N - 1].inv();
for (int i = N - 2; i; i--)
invfact[i] = invfact[i + 1] * (i + 1);
}
inline mint C(int a, int b) {
if (a < 0 || b < 0 || a < b)
return 0;
return fact[a] * invfact[b] * invfact[a - b];
}
int main() {
init();
int T;
cin >> T;
while (T--) {
int n, m1, m2;
cin >> n >> m1 >> m2;
vector<int> p(m1 + 1), s(m2 + 1);
vector<int> map1(n + 1);
for (int i = 1; i <= m1; i++) {
cin >> p[i];
map1[p[i]] = 1;
}
for (int i = 1; i <= m2; i++) {
cin >> s[i];
map1[s[i]] = 1;
}
if (p[m1] != s[1]) {
cout << "0" << endl;
continue;
}
mint ans = C(n - 1, s[1] - 1);
int len = s[1] - 1;
for (int i = len; i >= 1; i--)
if (!map1[i])
ans = ans * (i - 1);
len = s[1] + 1;
for (int i = len; i <= n; i++)
if (!map1[i])
ans = ans * (n - i);
cout << ans << endl;
}
return 0;
}
F. Nobody is needed （数据结构）
题意：
有一个长度为 n n n 的排列 a a a ， q q q 个询问，每个问题都有两个数字 l l l 和 r r r ，输出任意长度 k ≥ 1 k \ge 1 k≥1 的索引集 ( t 1 , t 2 , … , t k ) (t_1, t_2, \ldots, t_k) (t1,t2,…,tk) 的个数：
-
从 1 1 1 到 k k k 的每个 i i i 的 l ≤ t i ≤ r l \le t_i \le r l≤ti≤r 。
-
从 1 1 1 到 k − 1 k-1 k−1 的每个 i i i 为 t i < t i + 1 t_i < t_{i+1} ti<ti+1 。
-
从 1 1 1 到 k − 1 k-1 k−1 的每一个 i i i 都能被 a t i a_{t_i} ati 整除。
分析：
枚举合法的左右端点，设为 t 1 , t k {t_1,t_k} t1,tk， t 1 t_1 t1是 t k t_k tk的因子，最多只有 n l o g n nlogn nlogn 对合法的 t 1 , t k {t_1,t_k} t1,tk，只要知道所有的 t 1 , t k {t_1,t_k} t1,tk对答案的贡献 x x x，也就是区间 [ l , r ] [l,r] [l,r]对答案增量为 x x x，就可以利用扫描线求得答案。
将问题转化成：已知 t 1 , t k {t_1,t_k} t1,tk，如何计算对答案的贡献 x x x。其中可能存在转移 t 1 → t 2 → t k t_1 \rightarrow t_2 \rightarrow t_k t1→t2→tk， t 1 = t 2 t_1 = t_2 t1=t2， t 2 ≠ t k t_2 \neq t_k t2=tk。那么设 f [ t 1 ] = 1 f[t_1]=1 f[t1]=1，其他为 0 0 0。固定左端点 t 1 t_1 t1，模拟 d p dp dp转移，再枚举倍数 t 2 , t k t_2,t_k t2,tk，显然答案最后在所有 t 1 t_1 t1的倍数内。
代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template<typename T>
struct Fenwick {
int n;
std::vector<T> a;
Fenwick(int n = 0) { init(n); }
void init(int n) {
this->n = n;
a.assign(n, T());
}
void add(int x, T v) {
for (int i = x + 1; i <= n; i += i & -i) {
a[i - 1] += v;
}
}
T sum(int x) {
auto ans = T();
for (int i = x; i > 0; i -= i & -i) {
ans += a[i - 1];
}
return ans;
}
T rangeSum(int l, int r) {
return sum(r) - sum(l);
}
int kth(T k) {
int x = 0;
for (int i = 1 << std::__lg(n); i; i /= 2) {
if (x + i <= n && k >= a[x + i - 1]) {
x += i;
k -= a[x - 1];
}
}
return x;
}
};
int main() {
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
vector<int> a(n + 1), p(n + 1);
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++)
p[a[i]] = i;
vector<array<int, 3>> query(m);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
query[i] = {l, r, i};
}
vector<array<int, 3>> tmp;
vector<int> f(n + 1);
for (int l = 1; l <= n; l++) {
int x = a[l];
f[x] = 1;
for (int y = x; y <= n; y += x) {
int m = p[y];
if (l > m)
continue;
for (int z = 2 * y; z <= n; z += y) {
int r = p[z];
if (r < m)
continue;
f[z] += f[y];
}
}
for (int y = x; y <= n; y += x) {
int r = p[y];
tmp.push_back({l, r, f[y]});
f[y] = 0;
}
}
Fenwick<LL> fen(n + 1);
sort(tmp.begin(), tmp.end(), [&](auto edge1, auto edge2) { return edge1[1] < edge2[1]; });
sort(query.begin(), query.end(), [&](auto edge1, auto edge2) { return edge1[1] < edge2[1]; });
int k = tmp.size();
vector<LL> ans(m);
int i = 0, j = 0;
for (int r = 1; r <= n; r++) {
while (i < k && tmp[i][1] == r) {
auto [l, r, x] = tmp[i];
i++;
fen.add(l, x);
}
while (j < m && query[j][1] == r) {
auto [l, r, id] = query[j];
j++;
ans[id] = fen.rangeSum(l, n + 1);
}
}
for (auto x: ans) {
cout << x << " ";
}
cout << endl;
}
return 0;
}
赛后交流
在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。
群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。
741
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
