【补题笔记】Codeforces Round #809 (Div. 2) (CF1706)

A - Another String Minimization Problem

题目链接

对于每个$x$，可以将原字符串的两个位置更改为$A$，则优先修改编号小的位置为$A$，如果编号小的位置已经修改成$A$了，就修改编号大的位置。如果两个位置都修改过了，那么不管怎么样都不会导致原字符串变化，就可以随便改了。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

string s;
int a[55];
int n, m;

void main2() {
	cin >> n >> m;
	for (int i = 1; i <= m; ++i) {
		a[i] = 0;
	}
	for (int i = 1; i <= n; ++i) {
		int x; cin >> x;
		int p = min(x, m - x + 1), q = max(x, m - x + 1);
		if (a[p] == 1) a[q] = 1;
		else a[p] = 1;
	}
	for (int i = 1; i <= m; ++i) {
		if (a[i]) cout << 'A';
		else cout << 'B';
	}
	cout << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _ = 1;
	cin >> _;
	while (_--) main2();
	return 0;
}

B - Making Towers

题目链接

根据题目的性质我们可以发现，如果想让同颜色的块儿放在一列，那么这些列在原序列的下标两两之间的差值一定是奇数。我们利用这个性质，将每个颜色的下标单独提取出来。判断最大长度的方法很多，可以“数第一个奇数开始，后面偶数奇数轮换的长度；数第一个偶数开始，后面奇数偶数轮换的长度”，也可以通过差值求最大长度。总之，找出原序列中长度最大的、差值均为奇数的子序列。

时间复杂度$O(n)$。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

int n;
int c[100005], vis[100005];
vector<int> v[100005];

void main2() {
	cin >> n;
	for (int i = 1; i <= n; ++i) {
		cin >> c[i];
		v[i].clear();
	}
	for (int i = 1; i <= n; ++i) {
		v[c[i]].push_back(i);
	}
	for (int i = 1; i <= n; ++i) {
		int ans1 = 0, ans2 = 0, o = -1, e = -1;
		for (int j = 0; j < v[i].size(); ++j) {
			if (v[i][j] % 2 == 0 and e == -1) e = j, ans1 = 1;
			if (v[i][j] % 2 == 1 and o == -1) o = j, ans2 = 1;
			if (o != -1 and e != -1) break;
		}
		if (e != -1) {
			int ee = e; e = v[i][ee];
			for (int j = ee + 1; j < v[i].size(); ++j) {
				if (e % 2 == 0 and v[i][j] % 2 == 1) {
					++ans1; e = v[i][j];
				}
				else if (e % 2 == 1 and v[i][j] % 2 == 0) {
					++ans1; e = v[i][j];
				}
			}
		}
		if (o != -1) {
			int oo = o; o = v[i][oo];
			for (int j = oo + 1; j < v[i].size(); ++j) {
				if (o % 2 == 0 and v[i][j] % 2 == 1) {
					++ans2; o = v[i][j];
				}
				else if (o % 2 == 1 and v[i][j] % 2 == 0) {
					++ans2; o = v[i][j];
				}
			}
		}
		cout << max(ans1, ans2) << ' ';
	}
	cout << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _ = 1;
	cin >> _;
	while (_--) main2();
	return 0;
}

C - Qpwoeirut And The City

题目链接

很容易想到，如果想让cool buildings最多，先考虑数量，一定有下标$2,4,6,\cdots$或者是$3,5,7,\cdots$这种方案可选。所以有$n$栋楼，就会有$\lfloor \frac{n-1}{2}\rfloor$栋是cool buildings。

所以我们可以先看看，$2,4,6,\cdots$和$3,5,7,\cdots$一定是唯二的答案吗？并不一定。当$n$是奇数的时候确实如此，但当$n$是偶数的时候事情就会有些变化。

观察$n=8$，如果我们用0表示普通的楼，1表示cool building，那么就可以出现这样的情况：01010010。

这种情况该怎么考虑呢？我们可以把它拆成01010100的前$4$位+00101010的后$4$位的结果。同样的方法我们还可以拼出01001010。也就是说，我们可以把01010100和00101010这两种基础的方案的前缀和后缀答案算出来，然后通过拼接求出各种与基础方案不同的方法的答案，即01010100的前$i$位的答案和00101010的后$n-i$位的答案加一起作为一个新方案的答案。最终所有情况答案取最小值即可。

可以发现，不会有除此之外的其他答案了。时间复杂度$O(n)$。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

LL n, a1, a2;
LL a[100005], ans1[100005], ans2[100005];

void main2() {
	cin >> n;
	a1 = a2 = 0;
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
		ans1[i] = ans2[i] = 0;
	}
	ans1[0] = ans2[0] = 0;
	for (int i = 2; i < n; i += 2) {
		if (a[i] > a[i - 1] and a[i] > a[i + 1]) {
			++a1;
			ans1[a1] = ans1[a1 - 1];
			continue;
		}
		++a1;
		ans1[a1] = ans1[a1 - 1] + (max(a[i + 1], a[i - 1]) + 1 - a[i]);
	}
	if (n == 3) {
		cout << ans1[a1] << '\n';
		return;
	}
	a2 = a1 + 1;
	ans2[a2] = 0;
	for (int i = n - 1; i > 1; i -= 2) {
		if (a[i] > a[i - 1] and a[i] > a[i + 1]) {
			--a2;
			ans2[a2] = ans2[a2 + 1];
			continue;
		}
		--a2;
		ans2[a2] = ans2[a2 + 1] + (max(a[i + 1], a[i - 1]) + 1 - a[i]);
	}
	if (n % 2 == 1) {
		cout << min(ans1[a1], ans2[1]) << '\n';
		return;
	}
	LL ans = min(ans1[a1], ans2[1]);
	for (int i = 1; i < a1; ++i) {
		ans = min(ans, ans1[i] + ans2[i + 1]);
	}
	cout << ans << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _ = 1;
	cin >> _;
	while (_--) main2();
	return 0;
}

D1 - Chopping Carrots (Easy Version)

题目链接

$n$和值域的范围很小，所以我们可以大胆地想暴力做法。

设$b[i][j]$为$i$与$j$之间是否存在关联，具体来说就是$b[i][j]=1$，则表示存在一个$x\in [1,k]$，使得$j\times x=i$。

在这个定义之下，如何判断一个区间$[l,r]$是否是可行区间？只需要将$n$个数的所有$j\in [l,r]$的所有$b[i][j]=1$的数量统计起来，如果$n$个数中所有数都在$j\in [l,r]$的范围内至少存在一个$b[i][j]=1$的$j$，那么这个区间就是可行的。

暴力枚举所有区间并不现实，考虑到我们要求的是最小区间，也就是$r-l+1$尽可能小，可以通过尺取的方式来不断获得最小可能可行的区间，若可行，则不断更新最小的$r-l+1$作为答案。

尺取是$O(n)$，更新状态和check是$O(n)$，所以整体时间复杂度是$O(n^2)$。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

int n, k;
int a[3005], b[3005][3005], cnt[3005];
int mx = 0;

bool check() {
	for (int i = 1; i <= n; ++i) {
		if (cnt[i] == 0) return false;
	}
	return true;
}

void main2() {
	cin >> n >> k;
	for (int i = 1; i <= n; ++i) {
		cnt[i] = 0;
		cin >> a[i];
		for (int j = 0; j <= 3000; ++j) {
			b[i][j] = 0;
		}
		for (int j = 1; j <= k; ++j) {
			b[i][a[i] / j] = 1;
		}
	}
	int l = 0, r = 0;
	for (int i = 1; i <= n; ++i) {
		if (b[i][0] == 1) cnt[i]++;
	}
	int ans = 3005;
	while (r < 3000) {
		++r;
		for (int i = 1; i <= n; ++i) {
			if (b[i][r]) ++cnt[i];
		}
		while (check()) {
			ans = min(ans, r - l);
			for (int i = 1; i <= n; ++i) {
				if (b[i][l]) --cnt[i];
			}
			++l;
		}
	}
	cout << ans << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _ = 1;
	cin >> _;
	while (_--) main2();
	return 0;
}

D2 - Chopping Carrots (Hard Version)

题目链接

我们尝试枚举每一个可能的最大值，去寻找可选下界中的最大值。

先考察性质。假设我们选择最大值为$6$。暂不考虑$k$的范围，只考虑对于每一个数字，除以多少才能最接近$6$。

如果是$[1,6]$，我们会选择除以$1$。因为本身小于$6$，所以保持不变是最接近$6$的。
如果是$[7,12]$，我们会选择除以$2$。这里除以$2$是下限，因为如果只是除以$1$，其结果将大于我们规定的最大值$6$。
如果是$13$，我们也会选择除以$2$，因为其结果与$6$相等。
如果是$[14,17]$，我们会除以$3$，如果除以$2$，结果将比$6$大，是不能接受的。
如果是$[18,20]$，我们会选择除以$3$，因为其结果等于$6$。
同样道理：
如果是$[21,27]$，我们会选择除以$4$。
如果是$[28,34]$，我们会选择除以$5$。
如果是$[35,41]$，我们会选择除以$6$。

是否发现了区间左右端点的规律？

假设最大值我们选取的是$v$，我们看哪些数应当除以$u$来得到我们最好的答案。我们发现，这种情况下，凡是在区间$[(u-1)\times (v+1),u\times (v+1)-1]$的所有$a_i$，都应当除以$u$。

对于每一个除以$u$的区间，我们的下界要取这个区间得到的结果的最小值，其实就是在这个区间内的$a_i$的最小值。我们可以维护一个数组$nxt[i]$，表示序列中最小的大于等于$i$的数是多少。因为数据范围只有$10^5$，可以$O(n)$维护。

然后我们就枚举所有可能的$v$：

我们枚举每一个可行的上述区间（这个区间内的所有数都除以$u$），如果存在$a_i$在这个区间内，那么取其中最小的数，用$a_i/u$来更新最小答案。判断方法是看$nxt[(u-1)\times (v+1)]\le u\times (v+1)-1$是否成立，成立则存在，并更新最小值；不成立则直接跳过这个区间。

同时我们可以缩小一下$v$的范围：如果$k\times (v+1)-1<a_n$，那么这个最大值肯定不可取，直接跳过。
我们也可以缩小一下每一个$v$中$u$的范围：如果$(u-1)\times (v+1)>a_n$，那么这个$u$一定不可取，比这个$u$更大的$u$也不可取，直接结束循环。

是一个调和级数级别的复杂度，时间复杂度$O(n\log n)$。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

LL n, k;
LL a[100005];
vector<LL> nxt; 

void main2() {
	cin >> n >> k;
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
	}
	nxt.clear();
	int npt = 0;
	for (int i = 1; i <= n; ++i) {
		while (npt <= a[i]) {
			nxt.push_back(a[i]);
			++npt;
		}
	}
	LL ans = 1e9;
	for (LL i = 1; i <= a[n]; ++i) {
		if (a[n] >= (i + 1) * k) continue;
		LL mn = 1e9;
		for (LL j = 1; j <= k; ++j) {
			if ((j - 1) * (i + 1) > a[n]) break;
			if (nxt[(j - 1) * (i + 1)] >= (i + 1) * j) continue;
			mn = min(mn, nxt[(j - 1) * (i + 1)] / j);
		}
		if (mn < 1e9) ans = min(ans, i - mn);
	}
	cout << ans << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _ = 1;
	cin >> _;
	while (_--) main2();
	return 0;
}

E - Qpwoeirut and Vertices

题目链接

不难想到，对于一个区间询问，我们只需要考量每个点与旁边的点在最早是在哪一条边上相连的，然后对区间进行一个线段树或st表或树状数组求解最大值即可。

现在的问题就是如何求得每一个点与旁边的点最早是在哪一条边上相连。

首先，我们可以将图的每一条边设权，将边的权值设为其边号。由于我们要让选取的边尽可能小，所以求得其最小生成树，接下来我们就在这个最小生成树上进行操作，因为我们要将图按照从小到大边权的顺序进行连接最后让图连通，显然是选择最小生成树上的边。

然后我们随便设置一个树根，我们现在要求解的就是相邻编号的两个结点之间的路径上的边权最大值，设两个结点分别是$u,v$，再设这两个结点的最近公共祖先为$l$。那么这个任务可以拆分成两个部分：一个是$u$到$l$的路径上边权最大值，一个是$v$到$l$的路径上边权最大值。我们可以用倍增的方式存储每一个结点到根节点的路径上距离为$2$的幂次的距离的结点的路径上的最大边权，然后一边求$l$，一边获得最大边权，最后返回两个边权中的较大的那一个。当然，如果$l$和$u$或$v$中的一个相同，那么求的只有一条路径。

现在实现了在树上求解任意两点之间的路径上的边权最大值，我们就可以直接求解每一对相邻编号的结点之间的边权最大值了，这个最大值，就是每个点与旁边的点最早是在加入哪一条边的过程中连接起来的。至于判断是否连接，用并查集搞一下就好了。

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

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

int n, m, q;
int fa[100005], rk[100005], a[100005], front[100005];

int find(int x) {
	return ((fa[x] == x) ? x : (fa[x] = find(fa[x])));
}

void merge(int i, int j) {
	int x = find(i), y = find(j);
	if (rk[x] <= rk[y]) fa[x] = y;
	else fa[y] = x;
	if (rk[x] == rk[y] && x != y) ++rk[y];
}

struct Tree {
	int l, r, x;
}t[500005];

void pu(int ni) {
	t[ni].x = max(t[ni << 1].x, t[ni << 1 | 1].x);
}

void build_tree(int ni, int l, int r) {
	t[ni].l = l; t[ni].r = r;
	if (l == r) {
		t[ni].x = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build_tree(ni << 1, l, mid);
	build_tree(ni << 1 | 1, mid + 1, r);
	pu(ni);
}

void fix(int ni, int pos, int x) {
	if (pos == t[ni].l and t[ni].r == pos) {
		t[ni].x = x;
		return;
	}
	int mid = (t[ni].l + t[ni].r) >> 1;
	if (pos <= mid) fix(ni << 1, pos, x);
	else fix(ni << 1 | 1, pos, x);
	pu(ni);
}

int query(int ni, int l, int r) {
	if (l <= t[ni].l and t[ni].r <= r) {
		return t[ni].x;
	}
	int mid = (t[ni].l + t[ni].r) >> 1;
	int ans = 0;
	if (l <= mid) ans = max(ans, query(ni << 1, l, r));
	if (mid < r) ans = max(ans, query(ni << 1 | 1, l, r));
	return ans;
}

int en = 0;

struct Edge {
	int v, w, next;
}e[200005];

void addEdge(int u, int v, int w) {
	e[++en] = {v, w, front[u]};
	front[u] = en;
}

int Fa[100005][25], val[100005][25], dep[100005], lg[100005];

void dfs(int u, int f) {
	dep[u] = dep[f] + 1;
	Fa[u][0] = f; 
	for (int i = 1; (1 << i) <= dep[u]; ++i) {
		Fa[u][i] = Fa[Fa[u][i - 1]][i - 1];
		val[u][i] = max(val[u][i - 1], val[Fa[u][i - 1]][i - 1]);
	}
	for (int i = front[u]; i; i = e[i].next) {
		int v = e[i].v, w = e[i].w;
		if (v != f) {
			val[v][0] = w;
			dfs(v, u);
		}
	}
}

int lca(int x, int y) {
	int ret = 0;
	if (dep[x] < dep[y]) swap(x, y);
	while (dep[x] > dep[y]) {
		ret = max(ret, val[x][lg[dep[x] - dep[y]]]);
		x = Fa[x][lg[dep[x] - dep[y]]];
	}
	if (x == y) return ret;
	for (int k = lg[dep[x]]; k >= 0; --k) {
		if (Fa[x][k] != Fa[y][k]) {
			ret = max({ret, val[x][k], val[y][k]});
			x = Fa[x][k]; y = Fa[y][k];
		}	
	}
	ret = max({ret, val[x][0], val[y][0]});
	return ret;
}

void main2() {
	cin >> n >> m >> q;
	dep[0] = 0;
	for (int i = 1; i <= n; ++i) {
		fa[i] = i; rk[i] = 1;
		for (int j = 0; j < 25; ++j) {
			val[i][j] = Fa[i][j] = 0;
		}
		a[i] = front[i] = dep[i] = 0;
	}
	en = 0;
	for (int i = 1; i <= m; ++i) {
		int x, y; cin >> x >> y;
		int a = find(x), b = find(y);
		if (a != b) {
			merge(x, y);
			addEdge(x, y, i);
			addEdge(y, x, i);
		}
	}
	dfs(1, 0);
	for (int i = 2; i <= n; ++i) {
		a[i] = lca(i - 1, i);
	}
	build_tree(1, 1, n);
	for (int i = 1; i <= q; ++i) {
		int x, y;
		cin >> x >> y;
		if (x == y) cout << 0 << ' ';
		else cout << query(1, x + 1, y) << ' ';
	}
	cout << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _ = 1;
	cin >> _;
	lg[1] = 0; lg[2] = 1;
	for (int i = 3; i <= 100000; ++i) {
		lg[i] = lg[i / 2] + 1;
	}
	while (_--) main2();
	return 0;
}