A.Legs（贪心）
题意：
农夫约翰的农场又迎来了美好的一天。
农夫约翰来到农场后，数了数共 n n n条腿。众所周知，农场里只住着鸡和牛，一只鸡有 2 2 2条腿，而一头牛有 4 4 4条腿。
假设约翰农场主数清了所有动物的腿，那么他的农场里最少有多少动物？
分析：
求最少有几只动物，贪心考虑让牛最多，然后计算剩下鸡的数量， n n n先除 4 4 4，余数再除 2 2 2。
代码：
#include<bits/stdc++.h>
using namespace std;
int n;
void solve() {
cin >> n;
int ox = n / 4;
n -= ox * 4;
int chic = n / 2;
cout << ox + chic << endl;
}
int main() {
int t;
cin >> t;
while (t--)
solve();
return 0;
}
B.Scale（思维）
题意：
蒂娜有一个行数为 n n n列数为 n n n的正方形网格。网格中的每个单元格要么是 0 0 0要么是 1 1 1。
蒂娜希望将网格缩小 k k k（ k k k是 n n n的除数）。为此，蒂娜将网格分割成 k × k k\times k k×k个不重叠的单元格块，使得每个单元格都正好属于一个单元格块。
然后，蒂娜将每个单元格块替换为与单元格块中单元格值相等的单个单元格。保证同一区块中的每个单元格都具有相同的值。
帮助蒂娜将网格缩小 k k k倍。
分析：
可以发现每一个 k × k k×k k×k网格中的值是一样的，枚举从 1 , k + 1 , 2 k + 1 1,k+1,2k+1 1,k+1,2k+1到$n−k+1的每一行和从 1 , k + 1 , 2 k + 1 1,k+1,2k+1 1,k+1,2k+1到 n − k + 1 n−k+1 n−k+1的每一列，输出这些行列上的数字即可。
代码：
#include<bits/stdc++.h>
using namespace std;
const int N = 1005;
bool mp[N][N];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
scanf("%1d", &mp[i][j]);
for (int i = 1; i <= n; i += k) {
for (int j = 1; j <= n; j += k)
cout << mp[i][j];
cout << endl;
}
}
int main() {
int t;
cin >> t;
while (t--)
solve();
return 0;
}
C.Sort（前缀和）
题意：
给你两个长度为 n n n的字符串 a a a和 b b b。然后回答 q q q个问题。
每个查询都会给你一个由 l l l和 r r r限定的范围。在一次操作中，您可以选择一个整数 i i i( l ≤ i ≤ r l\leq i\leq r l≤i≤r)，并设置 a i = x a_i=x ai=x其中 x x x是您想要的任何字符。计算必须执行的最小操作数，以便 sorted(a[l..r]) = sorted(b[l..r]) \texttt{sorted(a[l..r])}=\texttt{sorted(b[l..r])} sorted(a[l..r])=sorted(b[l..r])。对一个查询执行的操作不会影响其他查询。
对于任意字符串 c c c， sorted(c[l..r]) \texttt{sorted(c[l..r])} sorted(c[l..r])表示按词典顺序排序的由字符 c l , c l + 1 , . . . , c r c_l,c_{l+1},...,c_r cl,cl+1,...,cr组成的子串。
分析：
设 c n t 1 i , j cnt1_{i,j} cnt1i,j为字符串 a a a种前 i i i个字符里 j j j字符的数量， c n t 2 i , j cnt2_{i,j} cnt2i,j为字符串 b b b种前 i i i个字符里 j j j字符的数量。可以先把 c n t 1 cnt1 cnt1与 c n t 2 cnt2 cnt2预处理出来。
要使得区间内每个字符的数目相等，需要先统计差异的个数。对于每次询问，依次枚举每个字符，设 x x x为 c n t 1 r , j − c n t 1 l − 1 , j cnt1_{r,j}−cnt1_{l−1,j} cnt1r,j−cnt1l−1,j， y y y为 c n t 2 r , j − c n t 2 l − 1 , j cnt2_{r,j}−cnt2_{l−1,j} cnt2r,j−cnt2l−1,j，使 a n s ans ans累加上 ∣ x − y ∣ ∣x−y∣ ∣x−y∣。最后答案即为 a n s 2 \frac{ans}{2} 2ans。
代码：
#include<bits/stdc++.h>
typedef long long LL;
using namespace std;
const LL N = 2e5 + 5;
LL n, q;
char a[N], b[N];
LL cnt1[N][30], cnt2[N][30];
void solve() {
scanf("%lld %lld", &n, &q);
scanf("%s", a + 1);
scanf("%s", b + 1);
for (LL i = 1; i <= n; i++)
for (LL j = 1; j <= 26; j++)
cnt1[i][j] = cnt1[i - 1][j] + (a[i] == 'a' + j - 1);
for (LL i = 1; i <= n; i++)
for (LL j = 1; j <= 26; j++)
cnt2[i][j] = cnt2[i - 1][j] + (b[i] == 'a' + j - 1);
while (q--) {
LL l, r, res = 0;
scanf("%lld %lld", &l, &r);
for (LL i = 1; i <= 26; i++) {
LL x = cnt1[r][i] - cnt1[l - 1][i];
LL y = cnt2[r][i] - cnt2[l - 1][i];
if (x > y)
res += x - y;
}
printf("%lld\n", res);
}
for (LL i = 1; i <= n; i++)
for (LL j = 1; j <= 26; j++)
cnt1[i][j] = cnt2[i][j] = 0;
}
int main() {
LL t;
cin >> t;
while (t--)
solve();
return 0;
}
D.Fun（数学）
题意：
给定两个整数 n n n和 x x x，求 a b + a c + b c ≤ n ab+ac+bc\le n ab+ac+bc≤n和 a + b + c ≤ x a+b+c\le x a+b+c≤x的正整数的三连式（ a , b , c a,b,c a,b,c）的个数。
注意顺序问题（例如( 1 , 1 , 2 1,1,2 1,1,2)和( 1 , 2 , 1 1,2,1 1,2,1) 被视为不同）， a a a， b b b， c c c必须严格大于 0 0 0。
分析：
考虑只枚举 a , b a,b a,b。
因为
a
+
b
+
c
≤
x
a+b+c≤x
a+b+c≤x，所以
c
≤
x
−
a
−
b
c≤x−a−b
c≤x−a−b。
又因为
a
b
+
a
c
+
b
c
≤
n
ab+ac+bc≤n
ab+ac+bc≤n，所以
a
b
+
(
a
+
b
)
c
≤
n
ab+(a+b)c≤n
ab+(a+b)c≤n，即
c
≤
a
+
b
n
−
a
b
c≤\frac{a+b}{n−ab}
c≤n−aba+b。
因此 c c c可能的个数为 m i n ( x − a − b , n − a b a + b ) min(x−a−b,\frac{n−ab}{a+b}) min(x−a−b,a+bn−ab)。 这样时间复杂度为 O ( n 2 ) O(n^2) O(n2)，但不是所有的 a , b a,b a,b都能有合法的 c c c。
因为 a b + a c + b c ≤ n ab+ac+bc≤n ab+ac+bc≤n，所以 a b ≤ n − a − b ab≤n−a−b ab≤n−a−b，所以 a b ≤ n ab≤n ab≤n，即 b ≤ n a b≤\frac{n}{a} b≤an。
即当确定了 a , b a,b a,b的可能个数为 n a \frac{n}{a} an，那么合法 b b b的总数量为 ∑ a = 1 n n a \sum_{a=1}^n \frac{n}{a} ∑a=1nan，这是一个调和级数，所以总数量约为 n l o g n nlogn nlogn量级。所以只要保证 a b ≤ n ab≤n ab≤n，时间复杂度为 O ( n l o g n ) O(nlogn) O(nlogn)，可以通过，
代码：
#include<bits/stdc++.h>
typedef long long LL;
using namespace std;
void solve() {
LL n, x, ans = 0;
cin >> n >> x;
for (LL a = 1; a < x; a++) {
for (LL b = 1; b < x; b++) {
if (a * b > n) {
break;
}
LL c = max(0LL, min(x - a - b, (n - a * b) / (a + b)));
ans += c;
}
}
cout << ans << "\n";
}
int main() {
LL t;
cin >> t;
while (t--)
solve();
return 0;
}
E.Decode（前缀和）
题意：
为了获得你最爱的女主角，你不惜黑进了游戏的源代码。经过几天的努力，你终于找到了编码游戏中加恰系统的二进制字符串。为了解码它，您必须首先解决以下问题。
给你一个长度为 n n n的二进制字符串 s s s。对于每一对整数 ( l , r ) (l,r) (l,r) ( 1 ≤ l ≤ r ≤ n ) (1\leq l\leq r\leq n) (1≤l≤r≤n)中，数出 ( x , y ) (x,y) (x,y) ( l ≤ x ≤ y ≤ r ) (l\leq x\leq y\leq r) (l≤x≤y≤r)这样的整数对的个数。 ( l ≤ x ≤ y ≤ r ) (l\leq x\leq y\leq r) (l≤x≤y≤r)中 0 \mathtt{0} 0的数量等于子串 s x s x + 1 . . . s y s_xs_{x+1}...s_y sxsx+1...sy中 1 \mathtt{1} 1的数量。
输出所有可能的 ( l , r ) (l,r) (l,r)对 1 0 9 + 7 10^9+7 109+7取模的结果。
分析：
题目表明 0 0 0和 1 1 1数量相同，对于这类问题我们可以把 0 0 0设为 − 1 −1 −1，从而把题目转换为区间和为 0 0 0的问题。对于区间和为 0 0 0的问题，先做一个前缀和，进而转换为两点前缀和相减为 0 0 0的问题，即两点前缀和一样。
然后考虑扫描线求解，固定 y y y端点，用 m a p map map维护所有 x x x端点对答案的贡献。对于区间 [ x , y ] [x,y] [x,y],它会被覆盖 x ( n − y + 1 ) x(n−y+1) x(n−y+1)次。
代码：
#include<bits/stdc++.h>
typedef long long LL;
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
int n;
LL a[N], sum[N];
char s[N];
map<LL, LL> mp;
void solve() {
scanf("%s", s + 1);
n = strlen(s + 1);
mp.clear();
LL ans = 0;
mp[0] = 1;
for (int i = 1; i <= n; i++) {
a[i] = (s[i] == '1' ? 1 : -1);
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n; i++) {
ans = (ans + (n - i + 1) * mp[sum[i]] % mod) % mod;
mp[sum[i]] += i + 1;
}
printf("%lld\n", ans);
}
int main() {
LL t;
scanf("%lld", &t);
while (t--)
solve();
return 0;
}
F.Bomb（二分）
题意：
Sparkle给你两个长度为 n n n的数组 a a a和 b b b。最初，分数是 0 0 0。在一次操作中，可以选择一个整数 i i i并将 a i a_i ai添加到分数中。然后，必须设置 a i a_i ai= max ( 0 , a i − b i ) \max(0,a_i-b_i) max(0,ai−bi)。
在闪亮引爆核弹之前，只有时间进行 k k k次操作！在 k k k次操作后，能获得的最高分数是多少？
分析：
简单的想法是考虑贪心，我们使用优先队列维护 a a a数组每一个元素当前的值，每次操作取最大值即可。但是这样会超时，为了满足题目数据范围，我们对贪心的过程进行分析，由于每次取得数组的最大值，那么在 k k k次操作取完之后，必然存在一个分界线 x x x，使得所有分数 ⩾ x ⩾x ⩾x的全部被取到，分数恰好为 x − 1 x−1 x−1的可能取到，分数 ⩽ x − 2 ⩽x−2 ⩽x−2的不会被取到。
可以二分查找到这个分界线 x x x，直接取得 ⩾ x ⩾x ⩾x的分数，扣除得分次数以后剩下的再使用优先队列维护贪心。因为队列至多有 n n n个元素，而 b i ⩾ 1 b_i⩾1 bi⩾1，所以分数恰好为 x − 1 x−1 x−1的元素至多只有 n n n个，获取这些得分以后不会产生新的 x − 1 x−1 x−1，所以使用优先队列维护贪心的复杂度为 O ( n l o g n ) O(nlogn) O(nlogn)，满足要求。
代码：
#include<bits/stdc++.h>
typedef long long LL;
using namespace std;
const LL N = 2e5 + 10;
LL n, k, a[N], b[N];
bool check(LL x) {
LL t = 0;
for (LL i = 1; i <= n; i++) {
t += max(0ll, (a[i] - x) / b[i] + (a[i] >= x));
}
return t <= k;
}
LL getl() {
LL l = 0, r = 1e9 + 1;
while (l < r) {
LL mid = l + r >> 1;
if (check(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
void solve() {
cin >> n >> k;
for (LL i = 1; i <= n; i++) {
cin >> a[i];
}
for (LL i = 1; i <= n; i++) {
cin >> b[i];
}
LL x = getl();
LL res = 0;
priority_queue<LL> q;
for (LL i = 1; i <= n; i++) {
LL c = max(0LL, (a[i] - x) / b[i] + (a[i] >= x));
res += (2 * a[i] - (c - 1) * b[i]) * c / 2;
k -= c;
if (a[i] - c * b[i] >= 0) {
q.push(a[i] - c * b[i]);
}
}
while (k && !q.empty()) {
LL v = q.top();
q.pop();
res += v;
k--;
}
cout << res << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
赛后交流
在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。
群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。
