A.Least Product(思维)
题意：
给出一个数组 a 1 , a 2 , . . . , a n a_1, a_2, ..., a_n a1,a2,...,an，你可以进行若干次以下操作：
- 选择数组中的一个元素 a i a_i ai，将这个数字修改为 0 ∼ a i 0 \sim a_i 0∼ai之间的任意数字。
问，最少需要多少次操作可以使得 ∏ i = 1 n a i \prod\limits_{i = 1}^{n}a_i i=1∏nai的结果最小，并输出对应的操作。
分析：
可以将问题分成两种情况：
-
存在 a i = 0 a_i = 0 ai=0或负数的出现次数为奇数，此时无论进行任何操作都无法使结果变得更小，输出0
-
其他情况，由于数字只能被修改到 0 ∼ a i 0 \sim a_i 0∼ai之间，那么正负数是无法互相转换的，因此，当结果为正数时，任选一个 a i a_i ai，将其修改为 0 0 0，就能获得最小的结果
代码：
cpp
#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 n n的字符串 s s s，你可以进行若干次以下操作：
-
移除第一个字符
-
移除第二个字符
问：经过若干次操作后，可以获得多少种不同的非空字符串？
分析：
将字符串划分为前后两部分，枚举两部分的分界点，每次枚举完分界点后，将后半部分视为不进行修改的部分，仅会对前半部分进行操作，那么由于每次枚举的后半部分均不同，为了保证方案的独立性，前半部分仅保留一个字符，那么此时的方案数就是前半部分中包含的不同字母的数量。
使用计数数组或set动态记录不同字符数量，每次枚举分界点后更新前半部分字符种类并记录到答案中即可。
代码：
cpp
#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 n n的数组 a a a,你将在接下来的 d d d天里每天选择执行以下两个操作之一：
-
给所有的 a 1 , a 2 , . . . , a b i a_1, a_2, ..., a_{b_i} a1,a2,...,abi加上一，其中 b i b_i bi为题目给出的第 i i i天的操作数。
-
数组 a a a中 a i = i a_i = i ai=i的数量就是你本轮获得的得分，然后将 a a a数组所有元素修改为 0 0 0
问：最多可以获得多少得分？
Tips:由于天数较多，因此 b b b数组采用 b = [ v 1 , v 2 , . . . , v k , v 1 , v 2 , . . . , v k , . . . ] b = [v_1, v_2, ..., v_k, v_1, v_2, ..., v_k, ...] b=[v1,v2,...,vk,v1,v2,...,vk,...]的形式给出。
分析：
如果数组 a a a开始全部为 0 0 0，那么最优策略就是操作 1 , 2 1,2 1,2轮流进行，可以获得 ⌊ d 2 ⌋ \lfloor\frac{d}{2}\rfloor ⌊2d⌋点得分（注意：开始时若 a 1 ≥ 1 a_1 \ge 1 a1≥1，则需要使用一次操作 2 2 2将 a 1 a_1 a1修改为 0 0 0，此时得分为 ( ⌊ d − 1 2 ⌋ + 开始时数组元素可以产生的得分 (\lfloor\frac{d - 1}{2}\rfloor + \text{开始时数组元素可以产生的得分} (⌊2d−1⌋+开始时数组元素可以产生的得分）。
而由于初始的数组是包含初始数字的，且长度为 n n n的数组最多可以产生 n n n点得分，因此，只需要在 2 × n − 1 2 \times n - 1 2×n−1的操作次数内均有可能超过循环操作获取的 n n n点固定得分。
枚举第一次进行操作 2 2 2前会进行多少次操作 1 1 1，每次遍历数组统计得分，剩余的操作次数使用最优策略进行。记录过程中最大的得分即可。
坑点
既然获取的长度为 n n n的数字最高可以产生 n n n点得分，那么只枚举 n n n次操作是否就够了？
反例：
原数组为 2 , 1 , 2 , . . . , n − 1 2, 1, 2, ..., n - 1 2,1,2,...,n−1，给出的 b b b数组为 [ 1 , 1 , . . . , 1 , n ] [1, 1, ..., 1, n] [1,1,...,1,n]，其中 b i = n b_i = n bi=n前有 ( 2 × n ) − 4 (2 \times n) - 4 (2×n)−4个1，此时 d = 2 × n d = 2 \times n d=2×n。
可以发现，枚举 0 ∼ n 0 \sim n 0∼n次操作 1 1 1，均无法产生额外得分，此时获得的最高总分为 ⌊ d − 1 2 ⌋ = n − 1 \lfloor \frac{d - 1}{2} \rfloor = n - 1 ⌊2d−1⌋=n−1，而依次使用 ( 2 × n ) − 3 (2 \times n) - 3 (2×n)−3次操作 1 1 1，再进行操作 2 2 2，可以获得 n − 1 n - 1 n−1点得分，此时还剩下两次操作，还可以继续一次最优策略，最后得分为 n n n。
代码：
cpp
#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 1 1到 2 n − 1 2n-1 2n−1的奇数组成的排列 p 0 , p 1 , ... , p n − 1 p_0,p_1,...,p_{n−1} p0,p1,...,pn−1和一个由 0 0 0到 k − 1 k-1 k−1的整数组成的排列 q 0 , q 1 , ... , q k − 1 q_0,q_1,...,q_{k−1} q0,q1,...,qk−1。定义长度为 n k nk nk的数组 a 0 , a 1 , ... , a n k − 1 a_0,a_1,...,a_{nk−1} a0,a1,...,ank−1如下：对于所有 0 ≤ i < n 0 \le i \lt n 0≤i<n和所有 0 ≤ j < k 0 \le j \lt k 0≤j<k，有 a i ⋅ k + j = p i ⋅ 2 q j a_{i⋅k+j}=p_i⋅2^{q_j} ai⋅k+j=pi⋅2qj。例如，如果 p = [ 3 , 5 , 1 ] p=[3,5,1] p=[3,5,1]且 q = [ 0 , 1 ] q=[0,1] q=[0,1]，那么 a = [ 3 , 6 , 5 , 10 , 1 , 2 ] a=[3,6,5,10,1,2] a=[3,6,5,10,1,2]。所有数组都是从零开始索引的。注意，数组 a a a中每个元素是唯一确定的。计算数组 a a a中逆序对 ( i , j ) ( 0 ≤ i < j < n k ) (i,j)(0 \le i < j < nk) (i,j)(0≤i<j<nk)的数量，结果对 998244353 998244353 998244353取模。
分析：
对于同一个 a i a_i ai，逆序对个数仅取决于 q {q} q的逆序对个数。
考虑用树状数组求逆序对个数的过程。对该过程稍作修改，可以得到下面的算法：
对于 a i a_i ai，大小在 ( a i , 2 a i ) (a_i,2a_i) (ai,2ai)之间的数而言， a i ⋅ 2 p j a_i⋅2^{p_j} ai⋅2pj与这些数能够形成的逆序对为 ( a i ⋅ 2 p j , a x ⋅ 2 p j − 1 ) (a_i⋅2^{p_j},a_x⋅2^{p_j-1}) (ai⋅2pj,ax⋅2pj−1), ( a i ⋅ 2 p j , a x ⋅ 2 p j − 2 ) (a_i⋅2^{p_j},a_x⋅2^{p_j-2}) (ai⋅2pj,ax⋅2pj−2)...... ( a i ⋅ 2 p j , a x ⋅ 2 0 ) (a_i⋅2^{p_j},a_x⋅2^0) (ai⋅2pj,ax⋅20)，共有 p j p_j pj个， a i a_i ai与这些数所能形成的逆序对数量为 ∑ i = 0 k p i = ( 0 + k − 1 ) × k 2 \sum\limits_{i=0}^{k}p_i=(0+k-1)\times\frac{k}{2} i=0∑kpi=(0+k−1)×2k。同理对大小在 ( 2 a i , 4 a i ) (2a_i,4a_i) (2ai,4ai)的数而言， a i a_i ai与这些数所能形成的逆序对数量为 ∑ i = 0 k p i = ( 0 + k − 2 ) × k − 1 2 \sum\limits_{i=0}^{k}p_i=(0+k-2)\times\frac{k-1}{2} i=0∑kpi=(0+k−2)×2k−1，如此不断向上倍增求答案，直到上限。
相反的，对于大小在 ( a i 2 , a i ) (\frac{a_i}{2},a_i) (2ai,ai)之间的数，可以按相同的方式考虑，如此不断向下除二求答案，直到下限。
代码：
cpp
#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 n n和一个整数 k k k。构造一个大小为 n × n n×n n×n的矩阵，由数字 0 0 0和 1 1 1组成，使其满足以下条件，或者输出不可能
所需满足的条件:
- 矩阵中所有数的和正好是 k k k;
- 第 i i i行中所有数字按位异或对每个 i i i都是相同的;
- 第 j j j列中所有数字按位异或对每个 j j j都是相同的。
分析：
首先，因为所有列的 X O R XOR XOR的 X O R XOR XOR显然为 0 0 0（因为 n n n为偶），因此所有数的 X O R XOR XOR也为 0 0 0，故 k k k不可能为奇数。
如果 k k k是 4 4 4的倍数，这种情况是比较简单的。易知一个 2 x 2 2x2 2x2的全 1 1 1矩阵可以在不破坏原矩阵的情况下被添加进去，那么不断添加这样的矩阵就可以了。
如果 k ≡ 2 ( m o d 4 ) k≡2(mod4) k≡2(mod4)，不妨假设 k ≤ n 2 2 k \le \frac{n^2}{2} k≤2n2，如果不满足，令 k ′ = n 2 − k k^{'}=n^2-k k′=n2−k，构造完再全部取反即可。当 k = 2 k=2 k=2时，显然不存在满足条件的矩阵。当 k = 6 k=6 k=6时，可以构造出一个 3 × 3 3 \times 3 3×3的矩阵，如下：
1 1 0
1 0 1
0 1 1
当 k ≥ 6 k≥6 k≥6时，考虑将上面这个矩阵放在前 4 4 4行 4 4 4列的位置，然后其他位置再通过添加 2 × 2 2\times2 2×2的全 1 1 1矩阵，即可构造满足要求的矩阵。
代码：
cpp
#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 l_1,l_2,...,l_n l1,l2,...,ln和一个整数 d d d。是否能构造一棵满足以下三个条件的树:
- 该树包含 n + 1 n+1 n+1个节点。
- 第 i i i条边的长度等于 l i l_i li。
- 该树的（加权）直径等于 d d d。
分析：
考虑形式化地描述这个问题。先把 l l l排序。然后相当于是否存在一个 1 , 2 , ... , n {1,2,...,n} 1,2,...,n的子集S，使得 ∑ i ∈ S l i = d \sum\limits_{i∈S}{l_i}=d i∈S∑li=d， ∃ T ⊆ S ∃T⊆S ∃T⊆S， m a x ( l i ) ≤ m i n ( ∑ i ∈ T l i , ∑ i ∈ S ∧ i ∉ T l i ) max(l_i)≤min(\sum\limits_{i\in T}{l_i},\sum\limits_{i\in S∧i\notin T}{l_i}) max(li)≤min(i∈T∑li,i∈S∧i∈/T∑li)。
注意到若 n − 1 ∈ S ∧ n ∈ S n−1∈S∧n∈S n−1∈S∧n∈S，则第二个条件一定满足，让 n − 1 ∈ T n−1∈T n−1∈T且 n ∉ T n \notin T n∈/T即可。所以如果 l 1 , l 2 ... l n − 2 l_1,l_2...l_n-2 l1,l2...ln−2能凑出来 d − a n − 1 − a n d−a_{n−1}−a_n d−an−1−an就可行。
然后依次讨论 m a x ( i ) = n − 1 max(i)=n−1 max(i)=n−1（ i ∉ S i \notin S i∈/S）或 n n n的情况:
- 若 m a x ( i ) = n − 1 max(i)=n−1 max(i)=n−1（ i ∉ S i \notin S i∈/S），那么 n ∈ S n∈S n∈S。若前 n − 2 n−2 n−2个元素能凑出来和为 x x x和 d − x − a n d−x−a_n d−x−an的两个不相交集合，且 a n − 1 ≤ m i n ( x + a n , d − x − a n ) a_{n-1}≤min(x+a_n,d−x−a_n) an−1≤min(x+an,d−x−an)$就可行。
- 若 m a x ( i ) = n max(i)=n max(i)=n（ i ∉ S i \notin S i∈/S），那么若前 n − 1 n−1 n−1个元素能凑出来和为 x x x和 d − x d−x d−x的两个不相交集合，且 a n ≤ m i n ( x , d − x ) a_n≤min(x,d−x) an≤min(x,d−x)就可行。
使用 b i t s e t bitset bitset进行优化。
代码：
cpp
#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;
}学习交流
以下为学习交流QQ群，群号： 546235402，每周题解完成后都会转发到群中，大家可以加群一起交流做题思路，分享做题技巧，欢迎大家的加入。
