A. Divide and Multiply
题意:给定一个数组 a a a,每次可以进行一下操作:
- 选定 a a a 中的两个元素 a i , a j a_i, a_j ai,aj,要满足 a i a_i ai 为 2 2 2 的倍数
- a i = a i 2 a_i = \frac{a_i}{2} ai=2ai
- a j = a j × 2 a_j = a_j\times 2 aj=aj×2
目标是使得最后得到的数组 a a a 的和 ∑ i = 1 n a i \sum\limits_{i = 1}^{n}a_i i=1∑nai 最大,问这个最大值是多少
上述过程可以看作将一个偶数中的一个 2 2 2 因子取出来乘到另外一个数上
那么整个过程可以看作是:
- 先把数组中所有的 2 2 2 全部取出来
- 再将这些 2 2 2 分配给一些数字
用什么样的分配策略呢
很显然,将所有的 2 2 2 分配给最大的数即可
很显然会爆 i n t int int(样例也说明了这一点)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
int cs, n;
signed main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin >> cs;
while (cs--) {
cin >> n;
vector<int> rec;
int ans = 1;
for (int i = 0, x; i < n; i++) {
cin >> x;
while (x % 2 == 0) {
x >>= 1;
ans <<= 1;
}
rec.push_back(x);
}
sort(rec.begin(), rec.end());
ans *= rec.back();
for (int i = 0; i < n - 1; i++) {
ans += rec[i];
}
cout << ans << '\n';
}
return 0;
}
B. William the Vigilant
题意:给定一个长度为 n n n 的字符串 S S S 和 q q q 组修改+查询,每组修改将 S S S 的 p o s pos pos 位置变为 c c c,并输出一个查询的结果
查询的内容是:对于当前字符串 S S S ,至少需要删除多少个字符,才能使得 S S S 中不含 a b c abc abc 子串
首先对于一个字符串 S S S 来说,需要至少删多少次才能满足不含 a b c abc abc 子串呢?显然答案是含有多少个 a b c abc abc 子串
那么我们的问题就变成了动态维护 S S S 中有多少个 a b c abc abc 字串
将 S [ p o s ] S[pos] S[pos] 替换为 c c c 蕴含两个过程:
- 先将 S [ p o s ] S[pos] S[pos] 删除
- 后将 S [ p o s ] S[pos] S[pos] 赋为 c c c
我们只需要对于这两个操作维护 a b c abc abc 的个数即可
时间复杂度: O ( N + Q ) O(N + Q) O(N+Q)
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int cnt, n, q;
string s;
void change(int pos, char ch) {
for (int i = pos - 2; i <= pos; i++) {
if (i >= 1 && i + 2 <= n && s.substr(i, 3) == "abc") cnt--;
}
s[pos] = ch;
for (int i = pos - 2; i <= pos; i++) {
if (i >= 1 && i + 2 <= n && s.substr(i, 3) == "abc") cnt++;
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin >> n >> q >> s;
s = '#' + s;
for (int i = 1; i <= n - 2; i++) {
cnt += s.substr(i, 3) == "abc";
}
int pos; string p;
for (int i = 1; i <= q; i++) {
cin >> pos >> p;
change(pos, p[0]);
cout << cnt << '\n';
}
return 0;
}
C. Complex Market Analysis
题意:给定一个长度为 n n n 的数组 a a a 和一个自然数 e e e,计算有多少组 ( i , k ) (i, k) (i,k) 满足
- 1 ≤ i , k 1\leq i, k 1≤i,k
- i + e × k ≤ n i + e\times k \leq n i+e×k≤n
- a i × a i + e × a i + 2 e × . . . × a i + k e a_i\times a_{i + e}\times a_{i + 2e}\times ...\times a_{i + ke} ai×ai+e×ai+2e×...×ai+ke 是一个素数
我们首先看第 3 3 3 个条件,若干个数的乘积是一个素数,那么:
- 其中有且仅有一个素数
- 其他的数都是 1 1 1
由此,我们可以将整个数组中的值分为 3 3 3 类:素数, 1 1 1,合数
我们再来看第 1 , 2 1, 2 1,2 个条件,也就是说这一段序列需要是下标是 e e e 的等差序列
那么我们可以先对原数组 a a a 进行分割,分割为 e e e 个子数组,分别为
- a 1 , a e + 1 , a 2 e + 1 , . . . a_1, a_{e + 1}, a_{2e + 1}, ... a1,ae+1,a2e+1,...
- a 2 , a e + 2 , a 2 e + 1 , . . . a_2, a_{e + 2}, a_{2e + 1}, ... a2,ae+2,a2e+1,...
- . . . . . . ...... ......
- a e , a 2 e , a 3 e , . . . a_{e}, a_{2e}, a_{3e}, ... ae,a2e,a3e,...
那么现在我们对每一个子集计算答案即可
对于一个集合来说我们暴力枚举每一个素数周围的 1 1 1 的个数
- 假设当前素数左边有 l n u m l_{num} lnum 个 1 1 1,右边有 r n u m r_{num} rnum 个 1 1 1
- 那么当前素数对于答案的贡献就为 l n u m × r n u m − 1 l_{num}\times r_{num} - 1 lnum×rnum−1
- 暴力做即可,因为每个数仅会被周围的两个素数扩展一边,也就是说每个数最多被遍历两边,时间复杂度是线性的
总时间复杂度: O ( max a i log max a i + N ) O(\max a_i\log\max a_i + N) O(maxailogmaxai+N) (前面那个复杂度是欧拉筛)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 5;
int cs, n, e, vis[N];
void init(void) {
for (int i = 2; i < N; i++) {
if (vis[i]) continue;
for (int j = i + i; j < N; j += i) {
vis[j] = 1;
}
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
init();
cin >> cs;
while (cs--) {
cin >> n >> e;
vector<int> vt(n, 0);
for (int i = 0; i < n; i++) {
cin >> vt[i];
}
vector<int> now;
ll ans = 0;
for (int i = 0; i < e; i++) {
now.clear();
for (int j = i; j < n; j += e) {
if (vt[j] == 1) now.push_back(1);
else if (vis[vt[j]]) now.push_back(0);
else now.push_back(2);
}
// for (auto it: now) {
// cout << it << ' ';
// }
// cout << endl;
int id = 0, l, r;
while (id < (int) now.size()) {
if (now[id] == 0 || now[id] == 1) {
id++; continue;
}
else {
l = 1, r = 1;
while (id - l >= 0 && now[id - l] == 1) l++;
while (id + r < (int) now.size() && now[id + r] == 1) r++;
ans += 1ll * l * r - 1;
id += r;
}
}
}
cout << ans << endl;
}
return 0;
}
D. Social Network
题意:给定 n n n 个人, d d d 个约束
对于一些约束,你需要构建一张图使得对于约束的两方,其在图中是连通的,并且要使得最大出度的点的出度最大
对于前 i i i 个约束,在连 i − 1 i - 1 i−1 条边的前提下,输出一个这个值
对于前 i i i 个约束,我们可以维护出当前图中的联通快个数,对于一个含有 k k k 个点的连通块来说,其最大出度的最大出度为 k − 1 k - 1 k−1
但是对于前 i i i 个约束我们未必需要 i − 1 i - 1 i−1 条边,所以多出来的边可以用来将连通块之间相连
怎么连最优呢?连最大的 k k k 个
连通块个数和联通块大小的信息需要用并查集来维护
时间复杂度: O ( d n log n ) O(dn\log n) O(dnlogn)
#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int fa[N], sz[N], n, d, x[N], y[N], v, vis[N];
vector<int> vt;
bool cmp(int a, int b) {return a > b;}
int find(int now) {
return fa[now] == now? now: fa[now] = find(fa[now]);
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin >> n >> d;
for (int i = 1; i <= n; i++) {
fa[i] = i; sz[i] = 1;
}
for (int i = 1; i <= d; i++) {
cin >> x[i] >> y[i];
}
for (int i = 1; i <= d; i++) {
int xrt = find(x[i]), yrt = find(y[i]);
if (xrt == yrt) v++;
else {
fa[xrt] = yrt;
sz[yrt] += sz[xrt];
}
fill(vis + 1, vis + n + 1, 0);
vt.clear();
for (int j = 1; j <= n; j++) {
int rt = find(j);
if (vis[rt]) continue;
vis[rt] = 1;
vt.push_back(sz[rt]);
}
sort(vt.begin(), vt.end(), cmp);
int ans = 0;
for (int i = 0; i < min(v + 1, (int) vt.size()); i++) {
ans += vt[i];
}
cout << ans - 1 << '\n';
}
return 0;
}
E. William The Oblivious
B B B 的增强版
题意:给定一个长度为 n n n 的字符串 S S S 和 q q q 组修改+查询,每组修改将 S S S 的 p o s pos pos 位置变为 c c c,并输出一个查询的结果
查询的内容是:对于当前字符串 S S S ,至少需要删除多少个字符,才能使得 S S S 中不含 a b c abc abc 子序列
做法是线段树+动态规划
首先我们考虑如何动态规划的合并
定义 d p [ i ] [ j ] dp[i][j] dp[i][j] 表示将区间的字符进行删除,使其不包含 i i i 到 j j j 的最小修改次数是多少,比如不含 a b ab ab 就是 d p [ 0 ] [ 1 ] dp[0][1] dp[0][1],不含 a b c abc abc 就是 d p [ 0 ] [ 2 ] dp[0][2] dp[0][2],下面为了方便表述直接写成字符的形式,如 d p [ 0 ] [ 2 ] dp[0][2] dp[0][2] 写成 d p [ a b c ] dp[abc] dp[abc]
那么怎么将两个区间 d p 1 dp_1 dp1 和 d p 2 dp_2 dp2 合并为 d p dp dp 呢?
- d p [ a ] ← d p 1 [ a ] + d p 2 [ a ] dp[a] \leftarrow dp_1[a] + dp_2[a] dp[a]←dp1[a]+dp2[a]
- d p [ b ] ← d p 1 [ b ] + d p 2 [ b ] dp[b] \leftarrow dp_1[b] + dp_2[b] dp[b]←dp1[b]+dp2[b]
- d p [ c ] ← d p 1 [ c ] + d p 2 [ c ] dp[c] \leftarrow dp_1[c] + dp_2[c] dp[c]←dp1[c]+dp2[c]
- d p [ a b ] ← max ( d p 1 ( a b ) + d p 2 ( b ) , d p 1 ( a ) + d p 2 ( a b ) ) dp[ab]\leftarrow \max(dp_1(ab) + dp_2(b), dp_1(a) + dp_2(ab)) dp[ab]←max(dp1(ab)+dp2(b),dp1(a)+dp2(ab))
- d p [ b c ] ← max ( d p 1 ( b c ) + d p 2 ( c ) , d p 1 ( b ) + d p 2 ( b c ) ) dp[bc]\leftarrow \max(dp_1(bc) + dp_2(c), dp_1(b) + dp_2(bc)) dp[bc]←max(dp1(bc)+dp2(c),dp1(b)+dp2(bc))
- d p [ a b c ] ← max ( d p 1 ( a ) + d p 2 ( a b c ) , d p 1 ( a b c ) + d p 2 ( c ) , d p 1 ( a b ) + d p 2 ( b c ) ) dp[abc]\leftarrow \max(dp_1(a) + dp_2(abc), dp_1(abc) + dp_2(c), dp_1(ab) + dp_2(bc)) dp[abc]←max(dp1(a)+dp2(abc),dp1(abc)+dp2(c),dp1(ab)+dp2(bc))
知道了区间合并,那么怎么查询/修改呢?
这显然是一个线段树问题了,只需要单点修改的操作就行
答案就是根节点的 d p [ 0 ] [ 2 ] dp[0][2] dp[0][2] 或者说是 d p [ a b c ] dp[abc] dp[abc]
时间复杂度: O ( q log n ) O(q\log n) O(qlogn)
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, q;
char s[N];
struct node {
int l, r, a[3][3];
}tree[N << 2];
struct SegTree {
void init(int n, char rec[]) {
build(1, n, rec);
}
void pushup(int rt) {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
tree[rt].a[i][j] = 0;
for (int k = i; k <= j; k++) {
tree[rt].a[i][j] = max(tree[rt].a[i][j], tree[rt << 1].a[i][k] + tree[rt << 1 | 1].a[k][j]);
}
}
}
}
void initleaf(int rt, int c) {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
tree[rt].a[i][j] = 1;
}
}
tree[rt].a[c][c] = 0;
}
void build(int l, int r, char rec[], int rt = 1) {
tree[rt].l = l; tree[rt].r = r;
if (l == r) {
initleaf(rt, rec[l] - 'a');
return;
}
int mid = (l + r) >> 1;
build(l, mid, rec, rt << 1);
build(mid + 1, r, rec, rt << 1 | 1);
pushup(rt);
}
void update(int now, int c, int rt = 1) {
if (tree[rt].l == tree[rt].r) {
initleaf(rt, c);
return;
}
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (now <= mid) update(now, c, rt << 1);
else update(now, c, rt << 1 | 1);
pushup(rt);
}
}seg;
string p;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin >> n >> q >> s + 1;
seg.init(n, s);
for (int i = 1, pos; i <= q; i++) {
cin >> pos >> p;
seg.update(pos, p[0] - 'a');
cout << n - tree[1].a[0][2] << '\n';
}
return 0;
}