"蔚来杯"2022牛客暑期多校训练营3

比赛链接：

https://ac.nowcoder.com/acm/contest/33188

A.Ancestor

题意：

已知两棵有 $n$ 个节点的树 $A$ 和 $B$，每个节点都有自己对应的权重，有一个长为 $k$ 的序列 $x$，表示树中的关键节点，第 $i$ 轮删除 $x_i$ 这个关键节点，问 $A$ 树中剩余关键节点的最近公共祖先的权重是否大于 $B$ 树种剩余关键节点的最近公共祖先的权重。

思路：

删除了第 $i$ 个节点，剩余节点的 $lca$ 其实就是 $lca(lca(a_1, a_2, ..., a_{i - 1}), lca(a_{i + 1}, ..., a_n))$。所以先处理所有关键节点的一个前缀的 $lca$，和一个后缀的 $lca$，然后比较权重即可。

代码：

#include <bits/stdc++.h>
using namespace std;
#define LL long long
struct Tree{
	vector <int> top, son, dep, parent, sz;
	vector < vector<int> > e;
	Tree(int n) : top(n + 1), son(n + 1), dep(n + 1), parent(n + 1), sz(n + 1), e(n + 1) {}
	void add(int u, int v){
		e[u].push_back(v);
		e[v].push_back(u);
	}
	void init(int s){
		dfs1(s);
		dfs2(s, s);
	}
	void dfs1(int u){  //计算子树大小、深度、父亲和重儿子
		sz[u] = 1;
		dep[u] = dep[parent[u]] + 1;
		for (auto v : e[u]){
			if (v == parent[u]) continue;
			parent[v] = u;
			dfs1(v);
			sz[u] += sz[v];
			if (!son[u] || sz[son[u]] < sz[v]){
				son[u] = v;
			}
		}
	}
	void dfs2(int u, int up){  //计算链的头部节点
		top[u] = up;
		if (son[u]) dfs2(son[u], up);
		for (auto v : e[u]){
			if (v == parent[u] || v == son[u]) continue;
			dfs2(v, v);
		}
	}
	int lca(int u, int v){
		while(top[u] != top[v]){
			if (dep[top[u]] >= dep[top[v]]){
				u = parent[top[u]];
			}
			else{
				v = parent[top[v]];
			}
		}
		return (dep[u] < dep[v] ? u : v);
	}
};
int main(){
	ios::sync_with_stdio(false);cin.tie(0);
	LL n, k;
	cin >> n >> k;
	vector <LL> x(k), a(n + 1), b(n + 1);
	for (int i = 0; i < k; i ++ )
		cin >> x[i];
	Tree A(n), B(n);
	for (int i = 1; i <= n; i ++ )
		cin >> a[i];
	for (int u = 2; u <= n; u ++ ){
		LL v;
		cin >> v;
		A.add(u, v);
	}
	for (int i = 1; i <= n; i ++ )
		cin >> b[i];
	for (int u = 2; u <= n; u ++ ){
		LL v;
		cin >> v;
		B.add(u, v);
	}
	A.init(1);
	B.init(1);
	vector <LL> preA(k), preB(k);
	for (int i = 0; i < k; i ++ ){  //处理前缀
		if (!i){
			preA[i] = x[i];
			preB[i] = x[i];
		}
		else{
			preA[i] = A.lca(preA[i - 1], x[i]);
			preB[i] = B.lca(preB[i - 1], x[i]);
		}
	}
	vector <LL> sufA(k), sufB(k);
	for (int i = k - 1; i >= 0; i -- ){  //处理后缀
		if (i == k - 1){
			sufA[i] = x[i];
			sufB[i] = x[i];
		}
		else{
			sufA[i] = A.lca(sufA[i + 1], x[i]);
			sufB[i] = B.lca(sufB[i + 1], x[i]);
		}
	}
	LL ans = 0;
	for (int i = 0; i < k; i ++ ){
		if (!i){
			if (a[sufA[1]] > b[sufB[1]]){
				ans ++ ;
			}
		}
		else if (i == k - 1){
			if (a[preA[k - 2]] > b[preB[k - 2]]){
				ans ++ ;
			}
		}
		else{
			if (a[A.lca(preA[i - 1], sufA[i + 1])] > b[B.lca(preB[i - 1], sufB[i + 1])]){
				ans ++ ;
			}
		}
	}
	cout << ans << "\n";
	return 0;
}

C.Concatenation

题意：

给定 $s$ 个字符串，输出将它们拼接起来后字典序最小的字符串。

思路：

直接 $sort$，stable_sort 较稳定。

代码：

#include <bits/stdc++.h>
using namespace std;
#define LL long long
int main(){
	ios::sync_with_stdio(false);cin.tie(0);
	LL n;
	cin >> n;
	vector <string> s(n);
	for (int i = 0; i < n; i ++ )
		cin >> s[i];
	sort(s.begin(), s.end(), [](string a, string b){
		return a + b < b + a;
	});
	for (int i = 0; i < n; i ++ )
		cout << s[i];
	return 0;
}

H.Hacker

题意：

给定长为 $n$ 的模式串 $A$，$k$ 次询问，每次给定一个长为 $m$ 的字符串 $B$，第 $i$ 位对应一个权值 $v$，如果某个子串是 $A$ 和 $B$ 的公共子串，可以得到该子串对应的权重之和，问最大能得到的权重之和为多少。

思路：

本质就是找 $B$ 的哪些子串是 $A$ 的子串，先按照模式串 $A$ 构建后缀自动机，然后将 $B$ 的每个后缀放进去匹配，最后可以得到它们的公共子串长度。
现在已知左右端点了，为了使权值最大，因为放的是后缀，即固定了右端点，对权值进行一次前缀和，那么只需要找到这个区间中前缀和最小的，用右端点减去它就是答案了。

代码：

#include <bits/stdc++.h>
using namespace std;
#define LL long long
const int N = 1e5 + 10;
struct SAM{
	struct node{
		int len, fa;
		int to[26];
	}nd[N << 1];
	int tot, last;
	SAM(){
		nd[0].len = 0;
		nd[0].fa = -1;
		tot = last = 0;
	}
	void extend(int x){
		int cur = ++ tot;
		nd[cur].len = nd[last].len + 1;
		int p = last;
		while(p != -1 && !nd[p].to[x]){
			nd[p].to[x] = cur;
			p = nd[p].fa;
		}
		if (p == -1){
			nd[cur].fa = 0;
		}
		else{
			int q = nd[p].to[x];
			if (nd[p].len + 1 == nd[q].len){
				nd[cur].fa = q;
			}
			else{
				int clone = ++ tot;
				nd[clone] = nd[q];
				nd[clone].len = nd[p].len + 1;
				while(p != -1 && nd[p].to[x] == q){
					nd[p].to[x] = clone;
					p = nd[p].fa;
				}
				nd[q].fa = nd[cur].fa = clone;
			}
		}
		last = cur;
	}
}sam;
LL s[N];
struct Segt{
	struct node{
		LL l, r, mn;
	}tr[N << 2];
	void pushup(LL u){
		tr[u].mn = min(tr[u << 1].mn, tr[u << 1 | 1].mn);
	}
	void build(LL u, LL l, LL r){
		if (l == r){
			tr[u] = {l, r, s[r]};
			return;
		}
		tr[u] = {l, r};
		LL mid = l + r >> 1;
		build(u << 1, l, mid);
		build(u << 1 | 1, mid + 1, r);
		pushup(u);
	}
	LL query(LL u, LL l, LL r){
		if (tr[u].l >= l && tr[u].r <= r) return tr[u].mn;
		LL mid = tr[u].l + tr[u].r >> 1, mn = 1e18;
		if (l <= mid) mn = min(mn, query(u << 1, l, r));
		if (r > mid) mn = min(mn, query(u << 1 | 1, l, r));
		return mn;
	}
}segt;
int main(){
	ios::sync_with_stdio(false);cin.tie(0);
	int n, m, k;
	cin >> n >> m >> k;
	string A;
	cin >> A;
	for (auto c : A)
		sam.extend(c - 'a');
	vector <int> v(m + 1);
	for (int i = 1; i <= m; i ++ )
		cin >> v[i];
	for (int i = 1; i <= m; i ++ )
		s[i] = s[i - 1] + v[i];
	segt.build(1, 0, m);  //因为是前缀和放到线段树中，所以要 0 到 m
	while(k -- ){
		string B;
		cin >> B;
		int p = 0, len = 0;
		LL ans = 0;
		for (int i = 0; i < m; i ++ ){
			while(p && !sam.nd[p].to[B[i] - 'a']){
				p = sam.nd[p].fa;
				len = sam.nd[p].len;
			}
			if (!sam.nd[p].to[B[i] - 'a']) continue;
			p = sam.nd[p].to[B[i] - 'a'];
			len ++ ;
			ans = max(ans, s[i + 1] - segt.query(1, i + 1 - len, i + 1));
		}
		cout << ans << "\n";
	}
	return 0;
}