Deltix Round, Autumn 2021 (Div. 1 + Div. 2)

A. Divide and Multiply

题意：给定一个数组 $a$，每次可以进行一下操作：

• 选定 $a$ 中的两个元素 $a_i,a_j$，要满足 $a_i$ 为 $2$ 的倍数
• $a_i=\frac{a_i}{2}$
• $a_j=a_j\times 2$

目标是使得最后得到的数组 $a$ 的和 $\sum _{i=1}^n{a}_i$ 最大，问这个最大值是多少

上述过程可以看作将一个偶数中的一个 $2$ 因子取出来乘到另外一个数上

那么整个过程可以看作是：

• 先把数组中所有的 $2$ 全部取出来
• 再将这些 $2$ 分配给一些数字

用什么样的分配策略呢

很显然，将所有的 $2$ 分配给最大的数即可

很显然会爆 $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$ 的字符串 $S$ 和 $q$ 组修改+查询，每组修改将 $S$ 的 $pos$ 位置变为 $c$，并输出一个查询的结果

查询的内容是：对于当前字符串 $S$ ，至少需要删除多少个字符，才能使得 $S$ 中不含 $abc$ 子串

首先对于一个字符串 $S$ 来说，需要至少删多少次才能满足不含 $abc$ 子串呢？显然答案是含有多少个 $abc$ 子串

那么我们的问题就变成了动态维护 $S$ 中有多少个 $abc$ 字串

将 $S[pos]$ 替换为 $c$ 蕴含两个过程：

• 先将 $S[pos]$ 删除
• 后将 $S[pos]$ 赋为 $c$

我们只需要对于这两个操作维护 $abc$ 的个数即可

时间复杂度：$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$ 的数组 $a$ 和一个自然数 $e$，计算有多少组 $(i,k)$ 满足

• $1\le i,k$
• $i+e\times k\le n$
• $a_i\times a_{i+e}\times a_{i+2e}\times ...\times a_{i+ke}$ 是一个素数

我们首先看第 $3$ 个条件，若干个数的乘积是一个素数，那么：

• 其中有且仅有一个素数
• 其他的数都是 $1$

由此，我们可以将整个数组中的值分为 $3$ 类：素数，$1$，合数

我们再来看第 $1,2$ 个条件，也就是说这一段序列需要是下标是 $e$ 的等差序列

那么我们可以先对原数组 $a$ 进行分割，分割为 $e$ 个子数组，分别为

• $a_1,a_{e+1},a_{2e+1},...$
• $a_2,a_{e+2},a_{2e+1},...$
• $......$
• $a_e,a_{2e},a_{3e},...$

那么现在我们对每一个子集计算答案即可

对于一个集合来说我们暴力枚举每一个素数周围的 $1$ 的个数

• 假设当前素数左边有 $l_{num}$ 个 $1$，右边有 $r_{num}$ 个 $1$
• 那么当前素数对于答案的贡献就为 $l_{num}\times r_{num}-1$
• 暴力做即可，因为每个数仅会被周围的两个素数扩展一边，也就是说每个数最多被遍历两边，时间复杂度是线性的

总时间复杂度：$O(\max a_i\log \max a_i+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$ 个人，$d$ 个约束

对于一些约束，你需要构建一张图使得对于约束的两方，其在图中是连通的，并且要使得最大出度的点的出度最大

对于前 $i$ 个约束，在连 $i-1$ 条边的前提下，输出一个这个值

对于前 $i$ 个约束，我们可以维护出当前图中的联通快个数，对于一个含有 $k$ 个点的连通块来说，其最大出度的最大出度为 $k-1$

但是对于前 $i$ 个约束我们未必需要 $i-1$ 条边，所以多出来的边可以用来将连通块之间相连

怎么连最优呢？连最大的 $k$ 个

连通块个数和联通块大小的信息需要用并查集来维护

时间复杂度：$O(dn\log n)$

#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$ 的增强版

题意：给定一个长度为 $n$ 的字符串 $S$ 和 $q$ 组修改+查询，每组修改将 $S$ 的 $pos$ 位置变为 $c$，并输出一个查询的结果

查询的内容是：对于当前字符串 $S$ ，至少需要删除多少个字符，才能使得 $S$ 中不含 $abc$ 子序列

做法是线段树+动态规划

首先我们考虑如何动态规划的合并

定义 $dp[i][j]$ 表示将区间的字符进行删除，使其不包含 $i$ 到 $j$ 的最小修改次数是多少，比如不含 $ab$ 就是 $dp[0][1]$，不含 $abc$ 就是 $dp[0][2]$，下面为了方便表述直接写成字符的形式，如 $dp[0][2]$ 写成 $dp[abc]$

那么怎么将两个区间 $d{p}_1$ 和 $d{p}_2$ 合并为 $dp$ 呢？

• $dp[a]\leftarrow d{p}_1[a]+d{p}_2[a]$
• $dp[b]\leftarrow d{p}_1[b]+d{p}_2[b]$
• $dp[c]\leftarrow d{p}_1[c]+d{p}_2[c]$
• $dp[ab]\leftarrow \max (d{p}_1(ab)+d{p}_2(b),d{p}_1(a)+d{p}_2(ab))$
• $dp[bc]\leftarrow \max (d{p}_1(bc)+d{p}_2(c),d{p}_1(b)+d{p}_2(bc))$
• $dp[abc]\leftarrow \max (d{p}_1(a)+d{p}_2(abc),d{p}_1(abc)+d{p}_2(c),d{p}_1(ab)+d{p}_2(bc))$

知道了区间合并，那么怎么查询/修改呢？

这显然是一个线段树问题了，只需要单点修改的操作就行

答案就是根节点的 $dp[0][2]$ 或者说是 $dp[abc]$

时间复杂度：$O(q\log n)$

#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;
}