2022NOIP A层联测14

陈叔叔到底喜欢什么

A. 陈叔叔（uncle）

陈叔叔假了，我也假了，这题的正解被 $hack$ 了。

做法假了，但是还是说一下，记录每个字母出现的次数，在 $t$ 中连续出现的某一字母长度记来

根据乘法原理，我们要求 $\Pi C_{len_i}^{c_i}$ 问题是如何分配

考虑一个一个分，那么对答案相当于乘上 $C_n^i/C_{n - 1}^i$ 的系数

推一下变成 $(x + 1) / (x + 1 - i)$

用堆维护，每次取最大

为啥假了，因为我们做法限定了只能在出现字母的位置连续放，其实我们可以在后面新开一段吗，每次可以选择不同的段

如 $abab aaabbb$ 最优应该为 $ababab$

code

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

int read(){
	int x = 0; char c = getchar();
	while(!isdigit(c))c = getchar();
	do{x = x * 10 + (c ^ 48); c = getchar();}while(isdigit(c));
	return x;
}

const int maxn = 550003;
const int mod = 998244353;
char a[maxn], b[maxn];
int n, m;
int cnt[35], ans;
int inv[maxn];
vector<int>len[35];
struct node{
	ll fz, fm;
	friend bool operator < (const node &x, const node &y){
		ll g = x.fm * y.fm / __gcd(x.fm, y.fm);
		ll f1 = x.fz * (g / x.fm);
		ll f2 = y.fz * (g / y.fm);
		return f1 < f2;
	}
};
priority_queue<node>q;
void sol(){
	for(int i = 1; i <= 26; ++i)if(cnt[i] < 0)return;
	ans = 1;
	for(int i = 1; i <= m; ++i){
		int j = i;
		while(b[j + 1] == b[i] && j < m)++j;
		len[b[i] - 'a' + 1].push_back(j - i + 1);
		i = j;
	}
	for(int i = 1; i <= 26; ++i)if(len[i].size())sort(len[i].begin(), len[i].end());
	inv[1] = 1;
	for(int i = 2; i <= n + 100; ++i)inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
	for(int i = 1; i <= 26; ++i){
		while(!q.empty())q.pop();
		for(int v : len[i]){
			node fs; fs.fz = v + 1; fs.fm = 1;
			q.push(fs);
		}
		if(q.empty())continue;
		for(int j = 1; j <= cnt[i]; ++j){
			node fs = q.top(); q.pop();
			ans = 1ll * ans * fs.fz % mod * inv[fs.fm] % mod;
			++fs.fz; ++fs.fm;
			q.push(fs);
		}
	}

}

int main(){
	// freopen("uncle.in","r",stdin);
	// freopen("uncle.out","w",stdout);
	scanf("%s%s",a + 1, b + 1);
	n = strlen(a + 1), m = strlen(b + 1);
	for(int i = 1; i <= n; ++i)++cnt[a[i] - 'a' + 1];
	for(int i = 1; i <= m; ++i)--cnt[b[i] - 'a' + 1];
	sol();
	printf("%d\n",ans);
	return 0;
}

B. 之后（next）

考虑选出一个点我们就选出一条边，这样保证边数与点数的限制

那么我们至少需要找到类似环的东西，思考可以发现找欧拉回路是可以的

现在考虑如何划分为两个集合，使得每个点在两个集合都出现，发现按照经过边顺序的奇偶性分组是可以的，于是对边按照遍历顺序染色

于是在处理时，我们可以把每个点的度数限制到 $4$， 也可以直接将度数为奇数的点建一条虚边到虚点，便于处理，这样对于每个点最终度数为偶数，一定存在欧拉回路

只能编到这里了，思路完全不自然，我还是太菜了 。 如果您有比较自然的思路的话，可否交流一下

code

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

int read(){
	int x = 0; char c = getchar();
	while(!isdigit(c))c = getchar();
	do{x = x * 10 + (c ^ 48); c = getchar();}while(isdigit(c));
	return x;
}

const int maxn = 2000005;
int n, m;
int head[maxn], tot;
struct edge{int to, net, id;}e[maxn << 1 | 1];
int ans[maxn];
int deg[maxn];
void add(int u, int v, int id){
	e[++tot].net = head[u];
	head[u] = tot;
	e[tot].to = v;
	e[tot].id = id;
	++deg[u];
}
int rh[maxn];
int vis[maxn + maxn], col[maxn + maxn], flag[maxn];
int sta[maxn + maxn], top;
void find(int x){
	for(int &i = head[x]; i; i = e[i].net){
		int v = e[i].to;
		if(vis[e[i].id])continue;
		vis[e[i].id] = 1;
		int ri = i;
		find(v);
		sta[++top] = e[ri].id;
	}
}
int cnt;
void sol(int x, int cl){
	flag[x] = cl + 1;
	for(int i = head[x]; i; i = e[i].net){
		int v = e[i].to;
		if(col[e[i].id] == cl){
			ans[e[i].id] = cnt;
			if(flag[v] < flag[x])sol(v, cl);
		}
	}
}
int main(){
	freopen("next.in","r",stdin);
	freopen("next.out","w",stdout);
	n = read(), m = read();
	for(int i = 1; i <= m; ++i){
		int u = read(), v = read();
		add(u, v, i); add(v, u, i);
	}
	for(int i = 1; i <= n; ++i)rh[i] = head[i];
	for(int i = 1; i <= n; ++i)if(deg[i] & 1){add(i, n + 1, i + m); add(n + 1, i, i + m);}
	for(int i = 1; i <= n; ++i)find(i);
	for(int i = 1; i <= top; ++i)col[sta[i]] = i & 1;
	for(int i = 1; i <= n; ++i)head[i] = rh[i];
	for(int i = 1; i <= n; ++i)if(flag[i] == 0)++cnt, sol(i, 0);
	for(int i = 1; i <= n; ++i)if(flag[i] == 1)++cnt, sol(i, 1);
	printf("1\n");
	printf("%d\n",cnt);
	for(int i = 1; i <= m; ++i)printf("%d ",ans[i]);printf("\n");
	return 0;
}

C. 会是（willbe）

一个思路就是每个点分开算贡献，发现答案可以表示成子树层数，那么按顺序考虑每个点，我们让他贡献到没有该层节点在子树内的祖先，即他的祖先去掉和他同层点的 $lca$

那么考虑询问相邻两个点，我们可以根据距离的奇偶性确定是否在同一层，也就能确定深度

如果是同层点，我们还可以通过距离算出他们 $lca$ 的深度，那么这个问题就解决了

code

#include<bits/stdc++.h>
#include "willbe.h"

using namespace std;

typedef long long ll;
typedef unsigned long long ull;


const int MAXN = 2005;
typedef pair<int, int> pii;
vector<pii> que;
vector<int> ret;
int ans;
int solve(const int n,const int m,const int k){
	for(int i = 2; i <= n; ++i)que.push_back(pii(i - 1, i));
	ret = query(que);
	ans = 1; int dep = 1;
	for(int i = 2; i <= n; ++i){
		int now = ret[i - 2];
		if(now & 1){
			ans += dep + now / 2 - 1;
		}else{
			++dep;
			ans += dep + dep - 1;
		}
	}
	return ans;
}

D. 谁（who）

寄了寄了，

说一下 $tire$ 树暴力，考虑像线段树一样在每个节点维护子树内答案

那么在每个点维护节点内是否为同一颜色，如果存在，那么直接取两个子树答案的 $min$

否则考虑两棵子树是否同色，如果同色那么答案为 $inf$， 否则可以通过预处理得出跨越该点的最小答案

预处理就是在插入的时候在邻接子树（兄弟子树）内查询最值

然后这题卡常，我卡不过去。。

$\huge \text{UPD: 我卡过去了！！！！！！！！！！！！！！！！！！！！！}$

好像是因为之前开的 $map$ 太多，于是虽然用到的很少，但是需要初始化的时间，所以开数组进行映射，减少 $map$ 的使用量

所以 $chino$ 说的手写哈希表/平衡树大概会有用

我一个人在这个题贡献了六十多次提交。。。。。

你可以看到一共三页

code

#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<iostream>
#include<cctype>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

char buf[1<<21],*p1,*p2;
char gc(){return p1==p2&&(p2=buf+fread(p1=buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;}
int read(){
	int x=0;char c=gc();
	while(!isdigit(c)){c=gc();}
	while(isdigit(c))x=x*10+(c^48),c=gc();
	return x;
}
const int maxn = 2e5 + 5;
const int inf = 2147483647;
int n, m, a[maxn], col[maxn];
const int mx = 29;
const int MAXN = 4500000;
map<int, int> mp[maxn], id;
void Ckmi(int &x, int y){x = x > y ? y : x;}
int Rmin(int x, int y){return x > y ? y : x;}
struct tire{
	struct node{
		int son[2], mi, cl, cmi, fa;
	}d[MAXN];
	int Id[MAXN];
	int root = 1, cnt = 1;
	inline int ckmi(int x, int now, int i){
		int ans = 0;
		for(i = i - 1; i >= 0; --i){
			int k = (x >> i) & 1;
			if(d[now].son[k])now = d[now].son[k];
			else ans |= (1 << i), now = d[now].son[k ^ 1];
		}
		return ans;
	}
	inline void push_up(int x){
		int ls = d[x].son[0], rs = d[x].son[1];
		if(d[ls].cl == -1 || d[rs].cl == -1){
			d[x].cl = -1;
			d[x].mi = Rmin(d[ls].mi, d[rs].mi);
			return;
		}
		if(d[ls].cl == 0 || d[rs].cl == 0){
			d[x].mi = inf;
			if(d[ls].cl)d[x].cl = d[ls].cl;
			else d[x].cl = d[rs].cl;
			return;
		}
		if(d[ls].cl == d[rs].cl){
			d[x].mi = inf;
			d[x].cl = d[ls].cl;
			return;
		}
		d[x].cl = -1;
		d[x].mi = d[x].cmi;
	}
	inline void insert(int x, int col){
		int now = root;
		for(register int i = mx; i >= 0; --i){
			if((x >> i) & 1){
				if(!d[now].son[1])d[now].son[1] = ++cnt, d[cnt].cmi = inf, d[cnt].fa = now;
				if(d[now].son[0]) Ckmi(d[now].cmi, ckmi(x, d[now].son[0], i) | (1 << i));
				now = d[now].son[1];
			}else{
				if(!d[now].son[0])d[now].son[0] = ++cnt, d[cnt].cmi = inf, d[cnt].fa = now;
				now = d[now].son[0];
			}
		}
		if(!Id[now])Id[now] = ++Id[0]; 
		++mp[Id[now]][col];
		id[x] = now;
	}
	inline void built(int now, int dep){
		if(dep == 0){
			d[now].mi = inf;
			if(mp[Id[now]].size() > 1) d[now].cl = -1, d[now].mi = 0;
			else d[now].cl = (*mp[Id[now]].begin()).first;
			return;
		}
		if(d[now].son[0])built(d[now].son[0], dep - 1);
		if(d[now].son[1])built(d[now].son[1], dep - 1);
		push_up(now);
	}
	inline void modify(int x, int las, int ncl){
		int idx = id[x], Idx = Id[idx];
		auto it = mp[Idx].find(las);
		--(*it).second;
		if((*it).second == 0)mp[Idx].erase(it);
		++mp[Idx][ncl];
		
		d[idx].mi = inf;
		if(mp[Idx].size() > 1)d[idx].cl = -1, d[idx].mi = 0;
		else d[idx].cl = (*mp[Idx].begin()).first;
		
		x = id[x];
		while(d[x].fa){
			x = d[x].fa;
			push_up(x);
		}
	}
}t;
int out[35];
inline void print(int x){
	int top = 0;
	while(x)out[++top] = x % 10, x /= 10;
	if(top == 0)out[++top] = 0;
	for(register int i = top; i >= 1; --i)putchar('0' + out[i]);
}
int main(){
	freopen("who.in","r",stdin);
	freopen("who.out","w",stdout);
	n = read(), m = read();
	for(register int i = 1; i <= n; ++i)a[i] = read();
	for(register int i = 1; i <= n; ++i)col[i] = read();
	for(register int i = 1; i <= n; ++i)t.insert(a[i], col[i]);
	t.d[0].cmi = t.d[0].mi = inf;
	t.built(1, mx + 1);
	for(register int i = 1; i <= m; ++i){
		int x = read(), y = read();
		t.modify(a[x], col[x], y);
		col[x] = y;
		print(t.d[1].mi); putchar('\n');
	}
	return 0;
}