2021CCPC山东省赛题解BCDFGHM

2021CCPC山东省赛题解BCDFGHM

G. Grade Point Average

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

给定$n(1\le n\le 1\mathrm{e}5)$门课的成绩(整数)$a_1,\cdots ,a_n(0\le a_i\le 100)$,求GPA,下取整保留到小数点后$k(1\le k\le 1\mathrm{e}5)$位.

思路

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

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

代码 -> 2021CCPC山东省赛-G(思维+模拟)

void solve() {
	int n, k; cin >> n >> k;
	ll sum = 0;
	for (int i = 0; i < n; i++) {
		int a; cin >> a;
		sum += a;
	}

	cout << sum / n << '.';
	sum %= n;
	for (int i = 0; i < k; i++) {
		sum *= 10;
		cout << sum / n;
		sum %= n;
	}
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

---

---

H. Adventurer’s Guild

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

有编号$1\sim n$的$n$个任务,其中第$i(1\le i\le n)$个任务消耗$h_i$点生命和$s_i$点耐力,可获得$w_i$的金币.初始时生命为$H$,耐力为$S$.当玩家生命$\le 0$时死亡.玩家耐力$<0$时,可用生命填补耐力的透支,如玩家耐力为$-3$且生命要减$3$时,耐力会被置为$0$,若玩家的生命不足以填补耐力的透支,玩家死亡.问玩家不死亡的前提下最多能获得多少金币.

第一行输入三个整数$n,H,S(1\le n\le 1000,1\le H\le 300,0\le S\le 300)$.接下来$n$行每行输入三个整数$h,s,w(0\le h,s\le 300,1\le w\le 1\mathrm{e}9)$.

思路

$dp[i][j][k]$表示只考虑前$i$个任务、当前血量为$j$、耐力为$k$时的最大收益,压第一维,最终答案为$dp[H][S]$.

状态转移方程: d p [ j ] [ k ] = max ⁡ 1 ≤ i ≤ n d p [ j − h [ i ] + min ⁡ { 0 , k − s [ i ] } ] [ max ⁡ { 0 , k − s [ i ] } ] + w [ i ] \displaystyle dp[j][k]=\max_{1\leq i\leq n}dp[j-h[i]+\min\{0,k-s[i]\}][\max\{0,k-s[i]\}]+w[i] dp[j][k]=1≤i≤nmax​dp[j−h[i]+min{0,k−s[i]}][max{0,k−s[i]}]+w[i].

代码 -> 2021CCPC山东省赛-H(二维费用背包)

const int MAXN = 1005;
int n, H, S;
int h[MAXN], s[MAXN], w[MAXN];  // 消耗生命、消耗耐力、获得收益
ll dp[MAXN][MAXN];  // dp[i][j][k]表示只考虑前i个任务、当前血量为j、耐力为k时的最大收益

void solve() {
	cin >> n >> H >> S;
	for (int i = 1; i <= n; i++) cin >> h[i] >> s[i] >> w[i];

	for (int i = 1; i <= n; i++) {  // 枚举任务
		for (int j = H; j; j--) {  // 枚举生命,注意j≥1
			for (int k = S; k >= 0; k--) {  // 枚举耐力
				if (j > h[i] && j + k > h[i] + s[i])
					dp[j][k] = max(dp[j][k], dp[j - h[i] + min(0, k - s[i])][max(0, k - s[i])] + w[i]);
			}
		}
	}
	cout << dp[H][S];
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

---

D. Dyson Box

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

某盒子中重力场的方向在打开它之前不确定,盒子内部可视为一个二维网格,左下角的坐标为$(0,0)$,右上角的坐标为$(2\mathrm{e}5,2\mathrm{e}5)$.现有$n$个事件,其中第$i(1\le i\le n)$个事件$(x_i,y_i)$表示在盒子中添加一个方块,其左下角坐标为$(x_i-1,y_i-1)$,右上角坐标为$(x_i,y_i)$.每个盒子中重力场的方向有$\frac{1}{2}$的概率为水平的,有$\frac{1}{2}$的概率为竖直的,水平的重力场会将所有方块推到盒子的左边,竖直的重力场会将所有方块推到盒子的下边.问每次打开一个盒子后所有方块构成的图形的周长.

第一行输入一个整数$n(1\le n\le 2\mathrm{e}5)$,表示事件数.接下来$n$行每行输入两个整数$x,y(1\le x,y\le 2\mathrm{e}5)$,表示方块的坐标.数据保证任意两个方块坐标相异.

对每个事件输出两个整数,分别表示该盒子中重力场方向是竖直、水平时所有方块构成的图形的周长.

思路

以竖直的重力场为例,水平同理.

(1)若新方块(红色,下同)所在列无其他方块,则$ans+=2$,即方块上下两条边的长度.

(2)若新方块所在列的左边有方块(蓝色,下同),且原有的方块的高度之和不超过新方块的高度,则$ans++$,即新方块右边的长度.

(3)若新方块所在列的左边有方块,且原有的方块高度之和超过新方块的高度,则$ans--$,即新方块左边的长度.

(4)新方块所在列的右边有方块的情况同理.

注意答案可能爆int.

代码 -> 2021CCPC山东省赛-D(思维)

const int MAXN = 2e5 + 5;
int hor[MAXN], ver[MAXN];  // 水平、竖直方向每个坐标的方块数

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

	ll anshor = 0, ansver = 0;
	while (n--) {
		int x, y; cin >> x >> y;

		if (!hor[x]) anshor += 2;
		if (hor[x - 1] <= hor[x]) anshor++;
		else anshor--;
		if (hor[x + 1] <= hor[x]) anshor++;
		else anshor--;
		hor[x]++;

		if (!ver[y]) ansver += 2;
		if (ver[y - 1] <= ver[y]) ansver++;
		else ansver--;
		if (ver[y + 1] <= ver[y]) ansver++;
		else ansver--;
		ver[y]++;

		cout << anshor << ' ' << ansver << endl;
	}
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

---

---

M. Matrix Problem

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

给定两$n\times m$的$0-1$矩阵$A$和$B$,两个矩阵中的$1$各自连通(四连通),由它们得到一个$n\times m$的$0-1$矩阵$C$，使得$C$中的元素为$1$当且仅当$A$和$B$的对应位置元素都为$1$;否则$C$中的元素为$0$.现给定$n\times m(3\le n,m\le 500)$的$0-1$矩阵$C$,构造两个满足上述要求的$0-1$矩阵$A$和$B$,若有多组解,输出任一组.数据保证$C$的外边界元素都为$0$.

思路

以如下图所示的矩阵为框架即可,其中红色、蓝色方格分别表示矩阵$A$、$B$中$1$的位置

先将矩阵$A$和$B$中矩阵$C$中为$1$的位置置$1$,对矩阵$C$中为$0$的位置保证$A$与$B$相反即可.

代码 -> 2021CCPC山东省赛-M(构造)

const int MAXN = 505;
int n, m;
int a[MAXN][MAXN], b[MAXN][MAXN], c[MAXN][MAXN];

void solve() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			char ch; cin >> ch;
			c[i][j] = ch - '0';
			if (c[i][j]) a[i][j] = b[i][j] = 1;
		}
	}

	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m - 1; j++) 
			if (j == 1 || i & 1) a[i][j] = 1;
	}

	for (int i = 1; i <= n; i++) {
		for (int j = m; j >= 2; j--)
			if (j == m || (i % 2 == 0 && !a[i][j])) b[i][j] = 1;
	}

	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) cout << a[i][j];
		cout << endl;
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) cout << b[i][j];
		cout << endl;
	}
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

---

---

C. Cat Virus

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

给一棵有根树的节点染黑色或白色,要求若一个节点染成黑色,则以它为根节点的子树中的节点也要染成黑色.给定整数$k(2\le k\le 2\mathrm{e}18)$,构造一棵以节点$1$为根节点的有根树,使得它的染色方案恰有$k$种,先输出节点数$n(1\le n\le 1\mathrm{e}5)$,再输出它的$(n-1)$条边.数据保证有解.若有多组解,输出任一组.

思路

设节点$u$有$n$个子节点$v_1,\cdots ,v_n$.若$u$染黑色,则所有$v_i(1\le i\le n)$只能染黑色,有$1$种方案;若$u$染白色,则所有$v_i(1\le i\le n)$可染黑色或白色,有$2^n$种方案,故每个这样的单元的方案数为$2^n+1$.$dp[u]$表示以$u$为根节点的子树的方案数,显然$dp[u]=\prod _{v\in so{n}_u}dp[v]+1$,则最后整棵树染色的方案数有形式$k=(2^{n_1}+1)(2^{n_2}+1)\cdots$.

由$2$的幂次想到构造二叉树.考察如下四种单元的方案数(每个单元最上方的节点为子树的根节点):

(1)孤立的节点,方案数为$2$.

(2)两个节点,方案数为$3$.

(3)三个节点成链,方案数为$4$.

(4)三个节点成树,方案数为$5$.

综上,特判方案数为$2$和$3$的情况,二叉树不分叉的染色方案数为偶数,二叉树分叉的染色方案数为奇数,据此构造即可.

代码I -> 2021CCPC山东省赛-C(构造) By : 莫说啥

void solve() {
	ll k; cin >> k;

	vii ans;
	int n = 1;  // 当前用到的节点编号
	while (k) {
		if (k == 2) break;  // 特判
		if (k == 3) {  // 特判
			ans.push_back({ n,n + 1 });
			n++;
			break;
		}

		if (k & 1) {
			ans.push_back({ n,n + 1 }), ans.push_back({ n,n + 2 });  // 分叉
			n += 2;
			k >>= 1;
		}
		else {
			ans.push_back({ n,n + 1 });  // 不分叉
			n++;
			k--;
		}
	}

	cout << n << endl;
	for (auto& [u, v] : ans) cout << u << ' ' << v << endl;
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

---

代码II -> 2021CCPC山东省赛-C(构造+DFS) By : LZVSDY

const int MAXN = 1e5 + 5;
ll k;
int n = 1;  // 当前用到的节点编号
vi edges[MAXN];

void dfs(int u, ll cur) {  // 当前节点、所需方案数
	ll tmp = cur - 1;  // 注意-1'
	while (tmp % 2 == 0) {
		edges[u].push_back(++n);
		tmp >>= 1;
	}
	
	if (tmp == 1) return;  // 只差全部染黑的情况

	edges[u].push_back(++n);
	dfs(n, tmp);
}

void solve() {
	cin >> k;

	dfs(1, k);
	cout << n << endl;
	for (int u = 1; u <= n; u++)
		for (auto v : edges[u]) cout << u << ' ' << v << endl;
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

---

---

B. Build Roads

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

有编号$1\sim n$的$n$个城市,城市$i(1\le i\le n)$处有一个经验值为$a_i$的施工队.现要建造$(n-1)$条路连接这些城市,连接城市$i$与城市$j$时的花费为$\gcd (a_i,a_j)$.求连接$n$个城市的最小代价.

$a_1,\cdots ,a_n$由如下代码产生:

第一行输入四个整数$n,L,R,seed(2\le n\le 2\mathrm{e}5,1\le L\le R\le 2\mathrm{e}5,1\le seed\le 1\mathrm{e}18)$.

思路

显然MST,但节点数最大为$2\mathrm{e}5$,用Prim算法会TLE;图是$n$阶无向完全图,边数为$\frac{n(n-1)}{2}$,最大约$2\mathrm{e}10$,用Kruskal算法会TLE.考察Kruskal算法最多能跑几阶无向完全图.令$m\log m=1\mathrm{e}8$,解得$m={\mathrm{e}}^{W(1\mathrm{e}8)}\approx 6.4\mathrm{e}6$.令$\frac{n(n-1)}{2}=6.4\mathrm{e}6$,解得$n\approx 3758$,此时求出各边边权的时间复杂度为$\frac{n(n+1)}{2}\approx 7\mathrm{e}6$.故$n\le 3758$的情况可用Kruskal算法求解.

考察$n>3758$的情况:

(1)$L=R$时,显然答案为$(n-1)L$.

*以下的解释不严谨,甚至可能错误,但代码可以AC.

(2)$L\ne R$时,答案为$(n-1)$,因为$n$较大时,元素间的$\frac{n(n-1)}{2}$对$\gcd$中至少有$(n-1)$个为$1$,

​ 而数组$a[]$随机,可认为这$(n-1)$个$1$即构成MST的边的边权.

​ 可以证明这样发生错误的概率足够小.

代码 -> 2021CCPC山东省赛-B(思维+Kruskal)

const int MAXN = 2e5 + 5, MAXM = MAXN << 2;
int L, R;
ull seed;
int a[MAXN];

ull xorshift64() {
	ull x = seed;
	x ^= x << 13, x ^= x >> 7, x ^= x << 17;
	return seed = x;
}

int gen() { return xorshift64() % (R - L + 1) + L; }

namespace Kruskal {
	int n, m;  // 节点数、边数
	struct Edge {
		int u, v;
		ll w;

		bool operator<(const Edge& B) { return w < B.w; }
	}edges[MAXM];
	int fa[MAXN];  // 并查集的fa[]数组

	void init() {  // 初始化fa[]
		for (int i = 1; i <= n; i++) fa[i] = i;
	}

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

	ll kruskal() {  // 返回最小生成树的最长边,图不连通时返回INFF
		sort(edges, edges + m);  // 按边权升序排列

		ll res = 0;  // 最小生成树的边权和
		int cnt = 0;  // 当前连的边数
		for (int i = 0; i < m; i++) {
			auto [u, v, w] = edges[i];
			u = find(u), v = find(v);
			if (u != v) {
				fa[u] = v;
				res += w;
				cnt++;
			}
		}

		if (cnt < n - 1) return INFF;  // 图不连通
		else return res;
	}
}
using namespace Kruskal;

void solve() {
	cin >> n >> L >> R >> seed;
	for (int i = 1; i <= n; i++) a[i] = gen();

	if (L == R) {
		cout << (ll)L * (n - 1);
		return;
	}

	if (n > 3758) {
		cout << n - 1;
		return;
	}

	for (int i = 1; i <= n; i++) {
		for (int j = i + 1; j <= n; j++)
			edges[m++] = { i,j,gcd(a[i], a[j]) }, edges[m++] = { j,i,gcd(a[i], a[j]) };
	}
	
	init();
	cout << kruskal();
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

---

---

F. Birthday Cake

题意

给定$n(1\le n\le 4\mathrm{e}5)$个长度不超过$4\mathrm{e}5$的字符串,问其中有多少对不同的字符串使得将两个字符串首尾相连并从中间切开后可得到两个相同的字符串.数据保证所有字符串的长度之和不超过$4\mathrm{e}5$.

思路

显然两个相同的字符串符合要求.

对不同的字符串,显然符合要求的只有上图中的情况,其中蓝色部分为串的公共前后缀,该长度的公共前后缀对答案的贡献即红色部分出现的次数.

用map对哈希值计数即可.

代码 -> 2021CCPC山东省赛-F(字符串哈希+map)

const int MAXN = 4e5 + 5;

namespace StringHash {
	int n;  // 字符串长度
	char str[MAXN];  // 下标从1开始
	const ll Base1 = 29, MOD1 = 1e9 + 7;
	const ll Base2 = 131, MOD2 = 1e9 + 9;
	ll ha1[MAXN], ha2[MAXN];  // 正着的哈希值
	ll rha1[MAXN], rha2[MAXN];  // 反着的哈希值
	ll pow1[MAXN], pow2[MAXN];  // Base1和Base2的乘方

	void init() {  // 预处理pow1[]、pow2[]
		pow1[0] = pow2[0] = 1;
		for (int i = 1; i <= n; i++) {
			pow1[i] = pow1[i - 1] * Base1 % MOD1;
			pow2[i] = pow2[i - 1] * Base2 % MOD2;
		}
	}

	void pre() {  // 预处理ha1[]、ha2[]
		for (int i = 1; i <= n; i++) {
			ha1[i] = (ha1[i - 1] * Base1 + str[i]) % MOD1;
			ha2[i] = (ha2[i - 1] * Base2 + str[i]) % MOD2;
			rha1[i] = (rha1[i - 1] * Base1 + str[n - i + 1]) % MOD1;
			rha2[i] = (rha2[i - 1] * Base2 + str[n - i + 1]) % MOD2;
		}
	}

	pll get_hash(int l, int r) {  // 求子串str[l...r]正着的哈希值
		ll res1 = ((ha1[r] - ha1[l - 1] * pow1[r - l + 1]) % MOD1 + MOD1) % MOD1;
		ll res2 = ((ha2[r] - ha2[l - 1] * pow2[r - l + 1]) % MOD2 + MOD2) % MOD2;
		return pll(res1, res2);
	}

	pll get_rhash(int l, int r) {  // 求子串str[l...r]反着的哈希值
		ll res1 = ((rha1[n - l + 1] - rha1[n - r] * pow1[r - l + 1]) % MOD1 + MOD1) % MOD1;
		ll res2 = ((rha2[n - l + 1] - rha2[n - r] * pow2[r - l + 1]) % MOD2 + MOD2) % MOD2;
		return pll(res1, res2);
	}

	bool IsPalindrome(int l, int r) {  // 判断子串str[l...r]是否是回文串
		return get_hash(l, r) == get_rhash(l, r);
	}

	pll add(pll a, pll b) {
		ll res1 = (a.first + b.first) % MOD1;
		ll res2 = (a.second + b.second) % MOD2;
		return pll(res1, res2);
	}

	pll mul(pll& a, ll k) {  // a *= Base的k次方
		ll res1 = a.first * pow1[k] % MOD1;
		ll res2 = a.second * pow2[k] % MOD2;
		return pll(res1, res2);
	}
};
using namespace StringHash;

map cnt1, cnt2;  // 整个字符串出现的次数、字符串在其他字符串的内部出现的次数

void solve() {
	n = MAXN - 1;
	init();

	ll ans = 0;
	CaseT{
		cin >> str + 1;
		n = strlen(str + 1);
		pre();

		auto tmp = get_hash(1, n);
		ans += cnt1[tmp]++;  // 相同串出现的次数对答案的贡献,注意++的顺序
		ans += cnt2[tmp];  // 该字符串在其他串的内部对答案的贡献

		for (int len = 1; len * 2 <= n; len++) {  // 枚举公共前后缀长度
			auto pre = get_hash(1, len), suf = get_hash(n - len + 1, n);
			if (pre == suf) {
				auto mid = get_hash(len + 1, n - len);  // 中间部分
				ans += cnt1[mid];  // 与中间部分相同的串对答案的贡献
				cnt2[mid]++;  // 更新该字符串在其他串的内部出现的次数
			}
		}
	}
	cout << ans;
}

int main() {
	solve();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

---

---