2021CCPC吉林省赛题解ABCEGHIKLM

2021CCPC吉林省赛题解ABCEGHIKLM

M. Sequence

题意 ($0.5\mathrm{s}$)

给定一个长度为$n(1\le n\le 1\mathrm{e}4)$的、元素范围为$[-1\mathrm{e}5,1\mathrm{e}5]$的序列$a[]$,输出$a[]$的值域乘$n$的值.

代码 -> 2021CCPC吉林省赛-M(模拟)

void solve() {
	int n; cin >> n;
	valarray<int> a(n);
	for (int i = 0; i < n; i++) cin >> a[i];

	cout << (ll)n * (a.max() - a.min());
}

int main() {
	solve();
}

---

---

A. Random Number Checker

题意 ($0.5\mathrm{s}$)

给定一个长度为$n(1\le n\le 1\mathrm{e}4)$的、元素范围为$[1,1\mathrm{e}9]$的整数序列$a[]$,若其中奇数的个数与偶数的个数相差不超过$1$,输出"Good";否则输出"Not Good".

代码 -> 2021CCPC吉林省赛-A(模拟)

void solve() {
	int n; cin >> n;

	int odd = 0, even = 0;
	while (n--) {
		int a; cin >> a;
		if (a & 1) odd++;
		else even++;
	}
	
	cout << (abs(odd - even) <= 1 ? "Good" : "Not Good");
}

int main() {
	solve();
}

---

---

B. Arithmetic Exercise

题意 ($0.5\mathrm{s}$)

给定整数$a,b(1\le a\le b\le 1000)$,求$\frac{a}{b}$,四舍五入保留小数点后$k(1\le k\le 1000)$位.

思路

显然当且仅当$a=b$时$\frac{a}{b}$的整数部分为$1$,其余情况整数部分为$0$.

注意到$\frac{a}{b}$小数点后第$1$位即$\frac{10a}{b}$的整数部分,但$k$最大为$1000$,乘$1000$次会爆掉.注意到对答案有贡献的只有$a$模$b$的余数,故每次$a\ast =10$,计算答案后$a\%=b$即可.

代码 -> 2021CCPC吉林省赛-B(思维+模拟)

void solve() {
	int a, b, k; cin >> a >> b >> k;

	if (a == b) {
		cout << "1." << string(k, '0');
		return;
	}

	string ans = "0.";
	for (int i = 0; i <= k; i++) {
		a *= 10;
		ans.push_back(a / b + '0');
		a %= b;
	}

	if (ans.back() >= '5') {
		ans.pop_back();
		char tmp = ans.back() + 1;
		ans.pop_back();
		ans.push_back(tmp);
	}
	else ans.pop_back();

	cout << ans;
}

int main() {
	solve();
}

---

---

E. Great Detective TJC

题意 ($0.5\mathrm{s}$)

有$t(1\le t\le 100)$组测试数据.每组测试数据给定一个长度为$n(1\le n\le 1\mathrm{e}5)$的序列$a_1,\cdots ,a_n(1\le a_i\le 1{\mathrm{e}}^9)$.数据保证所有测试数据的$n$之和不超过$5\mathrm{e}5$.

对每组测试数据,若存在$i,j\in [1,n],i\ne js.t.a_i\mathrm{xor}{a}_j=1$,则输出"Yes";否则输出"No".

思路

用哈希表查找是否存在元素$a_i\mathrm{xor}1$即可.

代码 -> 2021CCPC吉林省赛-E(哈希表)

void solve() {
	int n; cin >> n;

	umap<int, int> cnt;
	bool flag = false;
	while (n--) {
		int a; cin >> a;
		if (cnt.count(a ^ 1)) flag = true;
		cnt[a]++;
	}
	
	cout << (flag ? "Yes" : "No") << endl;
}

int main() {
	CaseT  // 单测时注释掉该行
	solve();
}

---

---

L. Suzuran Loves String

题意

对字符串$s$,有如下两种操作:①删除$s$的尾字符;②在$s$的尾部添加一个字符.对字符串$s$,记从下标$i(0\le i<n)$开始的后缀为$s_i$,定义后缀$s_i$与$s_j(0\le i<j<n)$间的距离$d(s_i,s_j)$为将$s_i$变为$s_j$的最小操作次数.求$d(s_i,s_j)$的最大值.

有$t$组测试数据.每组测试数据输入一个字符串$s(2\le |s|\le 1\mathrm{e}6)$.数据保证所有测试数据的$|s|$之和不超过$5\mathrm{e}6$.

对每组测试数据,输出$d(s_i,s_j)$的最大值.

思路

设$len=|s|$.

①若$s$只有一种字符,则取整个串为$s_i$,取尾字符为$s_j$,此时$d(s_i,s_j)=len-1$,显然是最大值.

②若$s$有多种字符,找到第一个与$s[0]$不同的字符$s[i](1\le i<len)$,取整个串为$s_i$,取$s[i...len-1]$为$s_j$,

​ 此时$d(s_i,s_j)=len+(len-i)=2len-i$,显然是最大值.

代码 -> 2021CCPC吉林省赛-L(思维)

void solve() {
	string s; cin >> s;

	int len = s.length();
	if (s == string(len, s[0])) cout << len - 1 << endl;
	else {
		for (int i = 1; i < len; i++) {
			if (s[i] != s[0]) {
				cout << 2 * len - i << endl;
				return;
			}
		}
	}
}

int main() {
	CaseT  // 单测时注释掉该行
	solve();
}

---

---

K. Bracket Sequence

题意 ($0.5\mathrm{s}$)

给定整数$n,k(1\le k,n\le 1\mathrm{e}5)$,求长度为$2n$的、包含$k$种括号的合法括号序列数,答案对$1\mathrm{e}9+7$取模.

思路

长度为$2n$的、包含$1$种括号的合法括号序列数即Catalan数$H_n$.

有$k$种括号时,只需考虑左括号,共$n$个,每个左括号有$k$种选择,另外$n$个右括号只能取与其对应的左括号的相同类型,方案数为$k^n$.

综上,$ans=H_n\cdot k^n$.

代码 -> 2021CCPC吉林省赛-K(Catalan数)

const int MAXN = 2e5 + 5;
const int MOD = 1e9 + 7;
int fac[MAXN], ifac[MAXN];

void init() {  // 预处理阶乘及其逆元
	fac[0] = 1;
	for (int i = 1; i < MAXN; i++) fac[i] = (ll)fac[i - 1] * i % MOD;

	ifac[MAXN - 1] = qpow(fac[MAXN - 1], MOD - 2, MOD);
	for (int i = MAXN - 1; i; i--) ifac[i - 1] = (ll)ifac[i] * i % MOD;
}

int C(int n, int m) {  // 组合数C(n,m)
	return (ll)fac[n] * ifac[m] % MOD * ifac[n - m] % MOD;
}

void solve() {
	init();

	int n, k; cin >> n >> k;

	int ans = (ll)C(2 * n, n) * qpow(n + 1, MOD - 2, MOD) % MOD * qpow(k, n, MOD) % MOD;
	cout << ans;
}

int main() {
	solve();
}

---

---

H. Visit the Park

题意 ($2\mathrm{s}$)

给定一张包含$n$个节点、$m$条边的无向图.某人的路径是$a_1,\cdots ,a_k$,他从节点$a_1$出发,严格按照路径行进.当他在节点$a_i$时,他会随机地选择一条从节点$a_i$到节点$a_{i+1}$的路径并行进到节点$a_{i+1}$.注意他可能多次经过同一节点.每条边上有一个$1\sim 9$的整数,当他通过该边时,他会将该数字从左到右地写在纸上,到达终点后纸上是一个$(k-1)$位数.求他到达终点后纸上的数字的期望,答案对$998244853$取模.

第一行输入三个整数$n,m,k(2\le n,m,k\le 3\mathrm{e}5)$.接下来$m$行每行输入三个整数$u,v,w(1\le u,v\le n,u\ne v,1\le w\le 9)$,表示存在一条从节点$u$到节点$v$的无向边,其上的数字为$w$.最后一行输入$k$个整数$a_1,\cdots ,a_k(1\le a_i\le n,a_i\ne a_{i+1})$.

若他无法到达终点,输出"Stupid Msacywy!";否则输出他到达终点后纸上的数字的期望,答案对$998244853$取模.

思路

类似于游走,求出路径路径数、边权和,更新答案即可.

注意模数不是$998244353$.

代码 -> 2021CCPC吉林省赛-H(游走)

const int MAXN = 3e5 + 5;
const int MOD = 998244853;
int n, m, k;  // 节点数、边数、路径节点数
vii edges[MAXN];
int a[MAXN];  // 路径

void get(int u, int v, int& cnt, int& sum) {  // 求从节点u到节点v的路径数cnt和边权和sum
	cnt = sum = 0;  // 注意清空

	for (auto& [nxt, w] : edges[u]) {
		if (nxt == v) {
			cnt++;
			sum += w;
		}
	}
}

void solve() {
	cin >> n >> m >> k;
	while (m--) {
		int u, v, w; cin >> u >> v >> w;
		edges[u].push_back({ v,w }), edges[v].push_back({ u,w });
	}
	for (int i = 0; i < k; i++) cin >> a[i];

	ll ans = 0;
	for (int i = 0; i < k - 1; i++) {
		int cnt = 0, sum = 0;  // 路径数、边权和
		get(a[i], a[i + 1], cnt, sum);

		if (!cnt) {
			cout << "Stupid Msacywy!";
			return;
		}

		ans = ((ll)ans * 10 + (ll)sum * qpow(cnt, MOD - 2, MOD) % MOD) % MOD;
	}
	cout << ans;
}

int main() {
	solve();
}

---

---

G. Matrix Repair

题意 $(0.5\mathrm{s})$

传输$n\times n$的$0-1$矩阵$A$的过程中有些元素可能丢失,丢失的元素用$-1$表示.原矩阵有一个行校验码、列校验码,分别是行元素的异或值、列元素的异或值,它们在传输过程中不会丢失.给定$A$和各行的行校验码、各列的列校验码,判断是否能确定原矩阵,若能则输出原矩阵;否则输出$-1$.

第一行输入一个整数$n(1\le n\le 1000)$.接下来输入一个$n\times n$的$0-1$矩阵$A$,元素范围 { − 1 , 0 , 1 } \{-1,0,1\} {−1,0,1}.接下来输入$n$个整数$r_1,\cdots ,r_n$,表示各行的行校验码.接下来输入$n$个整数$c_1,\cdots ,c_n$,表示各列的列校验码.数据保证至少存在一种$-1$的取法使得矩阵满足各行的行校验码和各列的列校验码.

思路

维护每行、列$-1$的个数$rowcnt[]$和$colcnt[]$.显然能确定填$0$还是$1$的只有$-1$的个数为$1$的行或列,填入后更新$rowcnt[]$和$colcnt[]$.用BFS完成填数过程,初始时先将只有一个$-1$的行和列入队.①对$-1$在行的情况,$-1$所在的列号$pos$当且仅当$colcnt[pos]$减到$1$时入队;②对$-1$在列的情况,$-1$所在的行号$pos$当且仅当$rowcnt[pos]$减到$1$时入队.

代码 -> 2021CCPC吉林省赛-G(思维+BFS)

const int MAXN = 1005;
int n;
int a[MAXN][MAXN];
int rowcnt[MAXN], colcnt[MAXN];  // 行、列-1的个数
int row[MAXN], col[MAXN];  // 行校验码、列校验码

void bfs() {
	qii que;  // first为-1所在的行或列,second行为1,列为2

	// 只有一个-1的行和列入队
	for (int i = 1; i <= n; i++)
		if (rowcnt[i] == 1) que.push({ i,1 });
	for (int j = 1; j <= n; j++)
		if (colcnt[j] == 1) que.push({ j,2 });

	while (que.size()) {
		auto& [idx, op] = que.front(); que.pop();

		int cnt = 0;  // 行或列中1的个数
		int pos = -1;  // 行或列中-1的位置
		if (op == 1) {  // 行
			for (int j = 1; j <= n; j++) {
				if (~a[idx][j]) cnt += a[idx][j];
				else pos = j;
			}

			if (!rowcnt[idx] || !colcnt[pos]) continue;  // 已无-1

			a[idx][pos] = row[idx] ^ (cnt & 1);  // 填数
			rowcnt[idx]--, colcnt[pos]--;  // 更新行、列-1的个数
			if (colcnt[pos] == 1) que.push({ pos,2 });  // 列-1的个数减到1时入队
		}
		else {  // 列
			for (int i = 1; i <= n; i++) {
				if (~a[i][idx]) cnt += a[i][idx];
				else pos = i;
			}

			if (!rowcnt[pos] || !colcnt[idx]) continue;  // 已无-1

			a[pos][idx] = col[idx] ^ (cnt & 1);  // 填数
			rowcnt[pos]--, colcnt[idx]--;  // 更新行、列-1的个数
			if (rowcnt[pos] == 1) que.push({ pos,1 });  // 行-1的个数减到1时入队
		}
	}
}

void solve() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> a[i][j];
			if (a[i][j] == -1) rowcnt[i]++, colcnt[j]++;
		}
	}
	for (int i = 1; i <= n; i++) cin >> row[i];
	for (int i = 1; i <= n; i++) cin >> col[i];

	bfs();

	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			if (a[i][j] == -1) {
				cout << -1;
				return;
			}
		}
	}

	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++) cout << a[i][j] << " \n"[j == n];
}

int main() {
	solve();
}

---

---

C. Random Number Generator

题意 $(0.5\mathrm{s})$

Linear Congruence Method(LCG)是产生伪随机数的经典方法,它基于递推公式$x_{n+1}=(a{x}_n+b)\mathrm{mod}m$,其中 { x n } \{x_n\} {xn​}是产生的伪随机数,$a,b,m,x_0$是给定的常数.给定数$x$,判断它能否由上述的LCG产生.

第一行输入五个整数$a,b,m,x_0,x(0\le a,b,x_0,x<m\le 1\mathrm{e}9,m\in primes)$.

若$x$能由上述的LCG产生,输出"YES";否则输出"NO".

思路

本题是https://www.luogu.com.cn/problem/P3306的弱化版.

已知条件是$x_0$,不方便,先特判$x_0=x$的情况,其余情况求出$x_1$,转化为已知$x_1$.

下面要判断的数$x$用$t$表示,模数$m$用$p$表示.

特判$a=0,1;b=0$的情况,下面讨论$a\ge 2,b\ge 1$的情况:

先求$x_n=(a{x}_{n-1}+b)(\mathrm{mod}p)$的通项,可先求出$x_n=a{x}_{n-1}+b$的通项,再$\mathrm{mod}p$.由不动点法知:$x_n+\frac{b}{a-1}=a\left(x_{n-1}+\frac{b}{a-1}\right)=\cdots =a^{n-1}\left(x_1+\frac{b}{a-1}\right)$.

考虑求同余方程$t+\frac{b}{a-1}\equiv a^{n-1}\left(x_1+\frac{b}{a-1}\right)(\mathrm{mod}p)$的非负整数解,其中只有$n$是变量,整理得$a^{n-1}\equiv \frac{t+\frac{b}{a-1}}{x_1+\frac{b}{a-1}}(\mathrm{mod}p)$.因$1\le a-1\le p-2$,则$\gcd (a-1,p)=1$,可用Fermat小定理求$a-1$模$p$的逆元.特判$x_1+\frac{b}{a-1}$是$p$的倍数的情况,此时$x_n=-\frac{b}{a-1}$,其余情况RHS是整数,转化为求$a^{n-1}\equiv b^{\prime }(\mathrm{mod}p)$的解,用BSGS算法.

特判:

(1)$a=0$时,①若$x_1=t$,则输出$1$;②若$b=t$,则输出$2$;③其余情况无解.

(2)$a=1$时,

​ ①若$b=0$,则$x_n=x_{n-1}$.若$x_1=t$,则输出$1$,其余情况无解.

​ ②通项为$x_n=x_1+(n-1)b$,转化为解不定方程$(n-1)b+x_1\equiv t(\mathrm{mod}p)$,即求不定方程$(n-1)b+mp=t-x_1$最小正整数解,用扩展Euclid算法.

代码 -> 2021CCPC吉林省赛-C(BSGS)

int exgcd(int a, int b, int& x, int& y) {
	if (!b) {
		x = 1, y = 0;
		return a;
	}

	int d = exgcd(b, a % b, y, x);
	y -= a / b * x;
	return d;
}

ll bsgs(int a, int b, int p) {
	if (1 % p == b % p) return 0;  // 特判t=0,因p可能为1,故写1%p

	int k = sqrt(p) + 1;  // 分块数

	// 预处理出所有b * a^y (mod p)
	umap<int, int> hash;
	for (int i = 0, j = b % p; i < k; i++) {
		hash[j] = i;  // 记录值的同时记录对应的y,较大的y会覆盖较小的y
		j = (ll)j * a % p;
	}

	// 预处理出a^k
	int ak = 1;
	for (int i = 0; i < k; i++) ak = (ll)ak * a % p;

	// 遍历x∈[1,k],在哈希表中查找是否存在满足的y
	for (int i = 1, j = ak; i <= k; i++) {  // j记录(a^k)^x
		if (hash.count(j)) return (ll)i * k - hash[j];  // 返回t值

		j = (ll)j * ak % p;
	}

	return -1;  // 无解
}

void solve() {
	int a, b, m, x0, x; cin >> a >> b >> m >> x0 >> x;

	if (x0 == x) {
		cout << "YES";
		return;
	}

	int x1 = ((ll)a * x0 + b) % m;

	if (a == 0) {  // 特判
		if (x1 == x || b == x) cout << "YES";
		else cout << "NO";
	}
	else if (a == 1) {  // 特判
		if (!b) cout << (x == x1 ? "YES" : "NO");
		else {
			// 求不定方程(n-1)b + mp = t - X0的最小正整数解
			int x, y;
			exgcd(b, m, x, y);
			x = ((ll)x * (x - x1) % m + m) % m;  // 保证x是正数
			cout << (~x ? "YES" : "NO");
		}
	}
	else {
		int C = (ll)b * qpow(a - 1, m - 2, m) % m;  // b/(a-1)
		int A = (x1 + C) % m;  // 分母
		if (!A) {  // 特判A=0
			int ans = (-C + m) % m;
			cout << (ans == x ? "YES" : "NO");
		}
		else {
			int B = (x + C) % m;  // 分子
			int ans = bsgs(a, (ll)B * qpow(A, m - 2, m) % m, m);
			cout << (~ans ? "YES" : "NO");
		}
	}
}

int main() {
	solve();
}

---

---

I. Nim Game

题意

有$n$堆石头,其中第$i$堆有$a_i$个.每轮A和B选择一个区间$[l,r]$在其上做Nim游戏,A先手.每个玩家每次可从任一堆中取走任意数量的石头,无法操作者败.两人都采取最优策略.现有操作:选择一个区间$[l,r]$,令其中每堆的石头数$+=x$.

第一行输入两个整数$n,m(1\le n\le 1\mathrm{e}5,1\le m\le 1\mathrm{e}5)$,分别表示石头堆数、操作数.第二行输入$n$个整数$a_1,\cdots ,a_n(1\le a_i\le 1\mathrm{e}9)$.接下来$m$行每行输入一个操作,格式如下:①$1lrx$,表示令区间$[l,r]$中每堆的石头数$+=x$;②$2lr$,表示询问选择$[l,r]$做Nim游戏,B是否必胜,若是则输出"Yes";否则输出"No".数据保证操作中$1\le l\le r\le n,1\le x\le 1\mathrm{e}4$.

思路

显然可用BIT实现区间修改和区间查询.因选择区间$[l,r]$做Nim游戏时,若其中石头数的异或和为$0$,先手必败,即后手必胜,故操作②只需考察$[l,r]$中石头数的异或和,但这无法用BIT快速查询.

考虑线性基.注意到若能不将$a[i]$插入线性基,则$a[i]$与线性基中某些元素异或和为零,可检查$[l,r]$中的元素是否都能插入线性基,若至少存在一个元素不能插入线性基,则后手必胜;否则后手必败.

代码 -> 2021CCPC吉林省赛-I(树状数组+线性基+Nim游戏)

const int MAXN = 1e5 + 5;

struct FenwickTree {
	int n;  // 数组长度
	ll a[MAXN];  // 原数组,下标从1开始
	ll BIT1[MAXN];  // 维护差分数组diff[]的前缀和
	ll BIT2[MAXN];  // 维护i*diff[i]的前缀和

	int lowbit(int x) { return x & (-x); }

	void add(ll BIT[], int x, ll c) {  // BIT[x]+=c
		for (int i = x; i <= n; i += lowbit(i)) BIT[i] += c;
	}

	ll sum(ll BIT[], int x) {  // 求[1...x]的前缀和
		ll res = 0;
		for (int i = x; i; i -= lowbit(i)) res += BIT[i];
		return res;
	}

	ll get_pre(int x) {  // 求a[1...x]的前缀和
		return sum(BIT1, x) * (x + 1) - sum(BIT2, x);
	}

	void modify(int l, int r, ll c) {  // 区间修改:a[l...r]+=c
		add(BIT1, l, c), add(BIT2, l, c * l);
		add(BIT1, r + 1, -c), add(BIT2, r + 1, -c * (r + 1));
	}

	ll query(int l, int r) {  // 区间查询:求a[l...r]的和
		return get_pre(r) - get_pre(l - 1);
	}

	void build() {  // 对原数组建BIT
		for (int i = 1; i <= n; i++) {
			ll diff = a[i] - a[i - 1];
			add(BIT1, i, diff), add(BIT2, i, diff * i);
		}
	}
}bit;

bool insert(int x, vi& base) {  // 将数x插入线性基base,返回插入是否成功
	for (int i = 31; i >= 0; i--) {
		if (x >> i & 1) {
			if (base[i]) x ^= base[i];
			else {
				base[i] = x;  // 插入线性基
				return true;  // 插入成功
			}
		}
	}
	return false;  // 插入失败
}

void solve() {
	int m; cin >> bit.n >> m;
	for (int i = 1; i <= bit.n; i++) cin >> bit.a[i];
	bit.build();

	while (m--) {
		int op, l, r; cin >> op >> l >> r;
		if (op == 1) {
			int x; cin >> x;
			bit.modify(l, r, x);
		}
		else {
			vi base(35);  // 线性基
			bool ok = false;
			for (int i = l; i <= r; i++) {
				int a = bit.query(i, i);  // a[i]
				if (!insert(a, base)) {  // 注意是后手必胜
					ok = true;
					break;
				}
			}

			cout << (ok ? "Yes" : "No") << endl;
		}
	}
}

int main() {
	solve();
}

---

---