Codeforces Round 917 (Div. 2) A~F

A.Least Product(思维)

题意：

给出一个数组 $a_1, a_2, ..., a_n$ ，你可以进行若干次以下操作：

选择数组中的一个元素 $a_i$ ，将这个数字修改为 $\sim a_i$ 之间的任意数字。

问，最少需要多少次操作可以使得 $\prod\limits_{i = 1}^{n}a_i$ 的结果最小，并输出对应的操作。

分析：

可以将问题分成两种情况：

存在 $a_i = 0$ 或负数的出现次数为奇数，此时无论进行任何操作都无法使结果变得更小，输出0
其他情况，由于数字只能被修改到 $\sim a_i$ 之间，那么正负数是无法互相转换的，因此，当结果为正数时，任选一个 $a_i$ ，将其修改为 $0$ ，就能获得最小的结果

代码：

#include<bits/stdc++.h>using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;void solve() {int n;cin >> n;int zero = 0, sign = 0;for (int i = 1; i <= n; i++) {int a;cin >> a;if (a == 0) {zero = 1;} else if (a < 0) {sign++;}}if (zero || sign % 2 == 1) cout << 0 << endl;else {cout << 1 << endl;cout << "1 0" << endl;}
}int main() {int Case;cin >> Case;while (Case--) {solve();}return 0;
}

B.Erase First or Second Letter(思维)

题意：

给出一个长度为 $n$ 的字符串 $s$ ，你可以进行若干次以下操作：

移除第一个字符
移除第二个字符

问：经过若干次操作后，可以获得多少种不同的非空字符串？

分析：

将字符串划分为前后两部分，枚举两部分的分界点，每次枚举完分界点后，将后半部分视为不进行修改的部分，仅会对前半部分进行操作，那么由于每次枚举的后半部分均不同，为了保证方案的独立性，前半部分仅保留一个字符，那么此时的方案数就是前半部分中包含的不同字母的数量。

使用计数数组或set动态记录不同字符数量，每次枚举分界点后更新前半部分字符种类并记录到答案中即可。

代码：

#include<bits/stdc++.h>using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;int vis[30];void solve() {memset(vis, 0, sizeof (vis));int n;string s;cin >> n >> s;int cnt = 0, ans = 0;for (int i = 0; i < n; i++) {vis[s[i] - 'a']++;if (vis[s[i] - 'a'] == 1) cnt++;ans += cnt;}cout << ans << endl;
}int main() {int Case;cin >> Case;while (Case--) {solve();}return 0;
}

C.Watering an Array(枚举)

题意：

给出一个长度为 $n$ 的数组 $a$ ,你将在接下来的 $d$ 天里每天选择执行以下两个操作之一：

给所有的 $a_1, a_2, ..., a_{b_i}$ 加上一，其中 $b_i$ 为题目给出的第 $i$ 天的操作数。
数组 $a$ 中 $a_i = i$ 的数量就是你本轮获得的得分，然后将 $a$ 数组所有元素修改为 $0$

问：最多可以获得多少得分？

Tips:由于天数较多，因此 $b$ 数组采用 $b = [v_1, v_2, ..., v_k, v_1, v_2, ..., v_k, ...]$ 的形式给出。

分析：

如果数组 $a$ 开始全部为 $0$ ，那么最优策略就是操作 $1, 2$ 轮流进行，可以获得 $\lfloor\frac{d}{2}\rfloor$ 点得分（注意：开始时若 $a_1 \ge 1$ ，则需要使用一次操作 $2$ 将 $a_1$ 修改为 $0$ ，此时得分为 $(\lfloor\frac{d - 1}{2}\rfloor + \text{开始时数组元素可以产生的得分}$ ）。

而由于初始的数组是包含初始数字的，且长度为 $n$ 的数组最多可以产生 $n$ 点得分，因此，只需要在 $\times n - 1$ 的操作次数内均有可能超过循环操作获取的 $n$ 点固定得分。

枚举第一次进行操作 $2$ 前会进行多少次操作 $1$ ，每次遍历数组统计得分，剩余的操作次数使用最优策略进行。记录过程中最大的得分即可。

坑点

既然获取的长度为 $n$ 的数字最高可以产生 $n$ 点得分，那么只枚举 $n$ 次操作是否就够了？

反例：

原数组为 $2, 1, 2, ..., n - 1$ ，给出的 $b$ 数组为 $[1, 1, ..., 1, n]$ ，其中 $b_i = n$ 前有 $\times n) - 4$ 个1，此时 $\times n$ 。

可以发现，枚举 $\sim n$ 次操作 $1$ ，均无法产生额外得分，此时获得的最高总分为 $\lfloor \frac{d - 1}{2} \rfloor = n - 1$ ，而依次使用 $\times n) - 3$ 次操作 $1$ ，再进行操作 $2$ ，可以获得 $n - 1$ 点得分，此时还剩下两次操作，还可以继续一次最优策略，最后得分为 $n$ 。

代码：

#include<bits/stdc++.h>using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;LL a[MAXN], b[MAXN];void solve() {LL n, k, d;cin >> n >> k >> d;LL ans = 0;for (int i = 1; i <= n; i++) cin >> a[i];for (int i = 0; i < k; i++) cin >> b[i];for (int i = 0; i <= 2 * n && i < d; i++) {LL cnt = 0;for (int j = 1; j <= n; j++) if (a[j] == j) cnt++;ans = max(ans, cnt + (d - i - 1) / 2);for (int j = 1; j <= b[i % k]; j++) {if (a[j] == j) cnt--;a[j]++;if (a[j] == j) cnt++;}}cout << ans << endl;
}int main() {int Case;cin >> Case;while (Case--) {solve();}return 0;
}

D.Yet Another Inversions Problem(树状数组+逆序对)

题意：

给定一个由 $1$ 到 $2 n - 1$ 的奇数组成的排列 $p_0,p_1,…,p_{n−1}$ 和一个由 $0$ 到 $k - 1$ 的整数组成的排列 $q_0,q_1,…,q_{k−1}$ 。定义长度为 $nk$ 的数组 $a_0,a_1,…,a_{nk−1}$ 如下：对于所有 $\le i \lt n$ 和所有 $\le j \lt k$ ，有 $a_{i⋅k+j}=p_i⋅2^{q_j}$ 。例如，如果 $p = [3, 5, 1]$ 且 $q = [0, 1]$ ，那么 $a = [3, 6, 5, 10, 1, 2]$ 。所有数组都是从零开始索引的。注意，数组 $a$ 中每个元素是唯一确定的。计算数组 $a$ 中逆序对 $\le i < j < nk)$ 的数量，结果对 $998244353$ 取模。

分析：

对于同一个 $a_i$ ，逆序对个数仅取决于 ${q}$ 的逆序对个数。

考虑用树状数组求逆序对个数的过程。对该过程稍作修改，可以得到下面的算法：
对于 $a_i$ ，大小在 $a_i,2a_i)$ 之间的数而言， $a_i⋅2^{p_j}$ 与这些数能够形成的逆序对为 $a_i⋅2^{p_j},a_x⋅2^{p_j-1})$ , $a_i⋅2^{p_j},a_x⋅2^{p_j-2})$ …… $a_i⋅2^{p_j},a_x⋅2^0)$ ，共有 $p_j$ 个， $a_i$ 与这些数所能形成的逆序对数量为 $\sum\limits_{i=0}^{k}p_i=(0+k-1)\times\frac{k}{2}$ 。同理对大小在 $2a_i,4a_i)$ 的数而言， $a_i$ 与这些数所能形成的逆序对数量为 $\sum\limits_{i=0}^{k}p_i=(0+k-2)\times\frac{k-1}{2}$ ，如此不断向上倍增求答案，直到上限。

相反的，对于大小在 $(\frac{a_i}{2},a_i)$ 之间的数，可以按相同的方式考虑，如此不断向下除二求答案，直到下限。

代码：

#include <bits/stdc++.h>using namespace std;
typedef long long LL;
const LL mod = 998244353;
const LL N = 5e5;struct BIT {LL n;vector<LL> tr;BIT(LL n) : n(n), tr(n + 1, 0) {}LL lowbit(LL x) {return x & -x;}void modify(LL x, LL m) {for (LL i = x; i <= n; i += lowbit(i)) {tr[i] += m;}}void modify(LL l, LL r, LL m) {modify(l, m);modify(r + 1, -m);}LL query(LL x) {LL res = 0;for (LL i = x; i; i -= lowbit(i))res += tr[i];return res;}LL query(LL x, LL y) {return query(y) - query(x);}
};LL tmp[N];LL merge_sort(LL q[], LL l, LL r) {if (l >= r)return 0;LL mid = (l + r) >> 1;LL res = merge_sort(q, l, mid) + merge_sort(q, mid + 1, r);LL i = l, j = mid + 1, k = 0;while (i <= mid && j <= r) {if (q[i] <= q[j]) tmp[k++] = q[i++];else {res += mid - i + 1;tmp[k++] = q[j++];}}while (i <= mid)tmp[k++] = q[i++];while (j <= r)tmp[k++] = q[j++];for (LL i = l, j = 0; i <= r; i++, j++)q[i] = tmp[j];return res;
}void solve() {LL n, k;cin >> n >> k;BIT num(4 * n + 5), sum(k + 5);LL a[n], b[k];for (LL i = 0; i < n; i++) {cin >> a[i];num.modify(a[i], 1);}for (LL i = 0; i < k; i++) {cin >> b[i];}LL ans = merge_sort(b, 0, k - 1);ans *= n;ans %= mod;for (LL i = 0; i < n; i++) {LL x = a[i];LL cnt = 1;while (x < 2 * n) {LL t = x * 2;LL nn = num.query(x, t);if (nn == 0) {x = t;cnt++;continue;}LL end = max(1LL * 0, k - cnt);LL ns = (1 + end) * end / 2;ans += ns * nn;ans %= mod;x = t;cnt++;}x = a[i];cnt = 1;while (1) {if (x == 1)break;LL t = (x + 1) / 2;LL nn = num.query(t - 1, x - 1);if (nn == 0) {x = t;cnt++;continue;}LL st = min(k, cnt);LL cntt = k - st + 1;LL res = k - cntt;LL ns = k * res + (st + k) * cntt / 2;ans += nn * ns;ans %= mod;;x = t;cnt++;}num.modify(a[i], -1);}cout << ans << endl;
}int main() {LL t = 1;cin >> t;while (t--) {solve();}return 0;
}

E.Construct Matrix(构造)

题意：

给定一个偶数 $n$ 和一个整数 $k$ 。构造一个大小为 $n \times n$ 的矩阵，由数字 $0$ 和 $1$ 组成，使其满足以下条件，或者输出不可能

所需满足的条件:

矩阵中所有数的和正好是 $k$ ;
第 $i$ 行中所有数字按位异或对每个 $i$ 都是相同的;
第 $j$ 列中所有数字按位异或对每个 $j$ 都是相同的。

分析：

首先，因为所有列的 $XOR$ 的 $XOR$ 显然为 $0$ （因为 $n$ 为偶），因此所有数的 $XOR$ 也为 $0$ ，故 $k$ 不可能为奇数。

如果 $k$ 是 $4$ 的倍数，这种情况是比较简单的。易知一个 $2 x 2$ 的全 $1$ 矩阵可以在不破坏原矩阵的情况下被添加进去，那么不断添加这样的矩阵就可以了。

如果 $k \equiv 2 (m o d 4)$ ，不妨假设 $\le \frac{n^2}{2}$ ，如果不满足，令 $k^{'}=n^2-k$ ，构造完再全部取反即可。当 $k = 2$ 时，显然不存在满足条件的矩阵。当 $k = 6$ 时，可以构造出一个 $\times 3$ 的矩阵，如下：

1 1 0
1 0 1
0 1 1

当 $k \geq 6$ 时，考虑将上面这个矩阵放在前 $4$ 行 $4$ 列的位置，然后其他位置再通过添加 $2\times2$ 的全 $1$ 矩阵，即可构造满足要求的矩阵。

代码：

#include <bits/stdc++.h>using namespace std;
typedef long long LL;
const int N = 1005;
int T, n, k;
bool mat[N][N];
int draw_first2block = 0;void reset() {for (int i = 1; i <= n; ++i)for (int j = 1; j <= n; ++j)mat[i][j] = 0;draw_first2block = 0;
}void draw() {mat[1][1] = mat[1][2] = mat[2][1] = mat[2][3] = mat[3][2] = mat[3][3] = 1;draw_first2block = 1;
}void solve(int cnt) {int i = 1, j = 0;while (cnt) {if (++j > n / 2) {++i;j = 1;}if (i <= 2 && j <= 2 && draw_first2block)continue;--cnt;mat[i * 2][j * 2] = mat[i * 2 - 1][j * 2] = mat[i * 2][j * 2 - 1] = mat[i * 2 - 1][j * 2 - 1] = 1;}
}void reverse() {for (int i = 1; i <= n; ++i)for (int j = 1; j <= n; ++j)mat[i][j] ^= 1;
}int main() {cin >> T;while (T--) {cin >> n >> k;if (n == 2 && k == 2) {cout << "Yes\n0 1\n1 0\n";continue;}bool check = false;if (k % 4 == 0) {check = true;reset();solve(k / 4);} else {bool reversed = false;if (k * 2 > n * n) {reversed = true;k = n * n - k;}if (k % 4 == 2 && k != 2) {check = true;reset();draw();solve((k - 6) / 4);if (reversed)reverse();}}if (check) {cout << "Yes\n";for (int i = 1; i <= n; ++i) {for (int j = 1; j <= n; ++j)cout << (mat[i][j] ? '1' : '0') << " \n"[j == n];}} else cout << "No\n";}return 0;
}

F.Construct Tree(bitset)

题意：

给定一个整数数组 $l_1,l_2,…,l_n$ 和一个整数 $d$ 。是否能构造一棵满足以下三个条件的树:

该树包含 $n + 1$ 个节点。
第 $i$ 条边的长度等于 $l_i$ 。
该树的（加权）直径等于 $d$ 。

分析：

考虑形式化地描述这个问题。先把 $l$ 排序。然后相当于是否存在一个 ${1,2,…,n}$ 的子集S，使得 $\sum\limits_{i∈S}{l_i}=d$ ， $\exists T \subseteq S$ ， $max(l_i)≤min(\sum\limits_{i\in T}{l_i},\sum\limits_{i\in S∧i\notin T}{l_i})$ 。

注意到若 $n - 1 \in S \land n \in S$ ，则第二个条件一定满足，让 $n - 1 \in T$ 且 $\notin T$ 即可。所以如果 $l_1,l_2…l_n-2$ 能凑出来 $d−a_{n−1}−a_n$ 就可行。

然后依次讨论 $ma x (i) = n - 1$ （ $\notin S$ ）或 $n$ 的情况:

若 $ma x (i) = n - 1$ （ $\notin S$ ），那么 $n \in S$ 。若前 $n - 2$ 个元素能凑出来和为 $x$ 和 $d−x−a_n$ 的两个不相交集合，且 $a_{n-1}≤min(x+a_n,d−x−a_n)$ $就可行。
若 $ma x (i) = n$ （ $\notin S$ ），那么若前 $n - 1$ 个元素能凑出来和为 $x$ 和 $d - x$ 的两个不相交集合，且 $a_n≤min(x,d−x)$ 就可行。

使用 $bi t se t$ 进行优化。

代码：

#include <bits/stdc++.h>using namespace std;
typedef long long LL;
const int maxn = 2005;int n, m, a[maxn];
bitset<maxn> f[maxn], g;void solve() {cin >> n >> m;for (int i = 1; i <= n; ++i) {cin >> a[i];}sort(a + 1, a + n + 1);for (int i = 0; i <= m; ++i) {f[i].reset();}g.reset();f[0].set(0);g.set(0);for (int i = 1; i < n; ++i) {if (i == n - 1) {if (a[n - 1] + a[n] <= m && g.test(m - a[n - 1] - a[n])) {cout << "Yes" << endl;return;}for (int j = 0; j <= m - a[n]; ++j) {if (a[i] <= min(j + a[n], m - a[n] - j) && f[j].test(m - j - a[n])) {cout << "Yes" << endl;return;}}}for (int j = m; ~j; --j) {f[j] |= (f[j] << a[i]);if (j >= a[i]) {f[j] |= f[j - a[i]];}}g |= (g << a[i]);}for (int i = a[n]; i <= m - a[n]; ++i) {if (f[i].test(m - i)) {cout << "Yes" << endl;return;}}cout << "No" << endl;
}int main() {int T = 1;cin >> T;while (T--) {solve();}return 0;
}