Codeforces Round 905（div3）解题报告

A. Morning

打的时候没看懂题面跳了

题目大意

你有一个光标初始值为1 对于1234567890 你每次可以花费1时间将光标上的数切换成相邻的数
也可以花费1时间将当前光标上的数推入一个队列里
T次询问每次求构造出一个长度为4的指定队列的最小花费

Solution

首先4次显示一定要花费4的时间
如果把所有0都替换为10 那么切换到第一个数的花费就是 $| a_{1} - 1 |$
否则切换到该数的花费就是 $| a_{i} - a_{i - 1} |$
时间复杂度 $O (4 T)$

点击查看代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;

inline int read() {
    int xr = 0, F = 1; 
	char cr;
    while (cr = getchar(), cr < '0' || cr > '9') if (cr == '-') F = -1;
    while (cr >= '0' && cr <= '9') 
        xr = (xr << 3) + (xr << 1) + (cr ^ 48), cr = getchar();
    return xr * F;
}

inline void write(ll x) {
	int wtop = 0;
	char stk[51];
	if (x < 0) putchar('-'), x = -x;
	do {
		stk[++wtop] = x % 10 + '0';
		x /= 10;
	} while (x);
	for (int i = wtop; i; --i) putchar(stk[i]);
}


namespace steven24 {

const int N = 5;
int T;
int a[N];
char s[N];	

void main() {
	T = read();
	while (T--) {
		scanf("%s", s);
		for (int i = 1; i <= 4; ++i) a[i] = s[i - 1] - '0';
		for (int i = 1; i <= 4; ++i) if (!a[i]) a[i] = 10;
		int ans = 0;
		ans += abs(a[1] - 1);
		for (int i = 2; i <= 4; ++i) ans += abs(a[i] - a[i - 1]);
		write(ans + 4), putchar('\n');
	}
}
	
}

int main() {
	steven24::main();
	return 0;
}

B.Chemistry

题目大意

给定一个长度为 $n (1 \leq n \leq 10^{5})$ 的字符串给定一个 $k (0 \leq k \leq n)$
你需要在这个字符串里删除恰好 $k$ 个字符并且把剩余字符重新排列成一个回文串
问是否可以做到

Solution

因为字符串可以重新排列所以我们关心的只是剩余每个字符的出现次数

首先 $n - k$ 可以求得剩余字符串的长度
如果剩余长度为奇数那么每个字符出现的数量一定是一个字符为奇数剩余的都为偶数
否则所有字符的出现次数都应该为偶数

所以我们直接关心原串中出现次数为奇数的字符有多少个并且能否用 $k$ 次删除操作把它们变成目标状态
具体的假设我们要求删完后有 $s$ 个字符出现次数为奇数原串中有 $t$ 个字符出现次数为奇数
那么我们比较 $t - s$ 与 $k$ 的大小关系即可至于多出来的一部分直接两个两个删除消耗掉即可

时间复杂度 $O (\sum n)$

点击查看代码

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

inline int read() {
	int xr = 0, F = 1;
	char cr;
	while (cr = getchar(), cr < '0' || cr > '9') if (cr == '-') F = -1;
	while (cr >= '0' && cr <= '9')
		xr = (xr << 3) + (xr << 1) + (cr ^ 48), cr = getchar();
	return xr * F;
}

namespace steven24 {

int c[31];
int T, n, k; 

void main() {
	T = read();
	while (T--) {
		memset(c, 0, sizeof c);
		n = read(), k = read();
		for (int i = 1; i <= n; ++i) {
			char cc;
			scanf(" %c", &cc);
			++c[cc - 'a'];
		}
		
		int cnt = 0;
		for (int i = 0; i <= 25; ++i) if (c[i] & 1) ++cnt;
		
		if ((n - k) & 1) {
			if (cnt - 1 <= k) puts("YES\n");
			else puts("NO\n");
		} else {
			if (cnt <= k) puts("YES\n");
			else puts("NO\n");
		}
	}
}

}

int main() {
	steven24::main();
	return 0;
}

C.Raspberries

product 竟然还有乘积的意思

题目大意

给定一个长度为 $n (2 \leq n \leq 10^{5})$ 的序列
再给定一个 $k (2 \leq k \leq 5)$
每次操作可以选择序列中的一个数并把它+1
问使这个序列中所有数的乘积为 $k$ 的倍数最少需要操作多少次

Solution

考虑构造显然要让这个序列中的每个数都拿出来一个因数然后乘起来恰好为 $k$
发现 $k$ 只有2,3,4,5四种取值其中2,3,5均为质数
这也就意味着在这种情况下如果序列中存在一个数为 $k$ 的倍数那么答案就为0
否则就找一个能达到 $k$ 的倍数所需要操作的最少的一个数即可操作步数为 $k - (x \mod k)$

我们单独考虑 $k = 4$ 的情况

如果存在一个为4的倍数答案就为0
否则如果存在两个为2的倍数答案也为0
否则如果存在一个为2的倍数答案就为达到2的倍数需要操作最少的数
否则如果一个为2的倍数的数都没有答案就为使两个数变为2的倍数/使一个数变为4的倍数取 $min$

时间复杂度 $O (\sum n)$

点击查看代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;

inline int read() {
	int xr = 0, F = 1;
	char cr;
	while (cr = getchar(), cr < '0' || cr > '9') if (cr == '-') F = -1;
	while (cr >= '0' && cr <= '9')
		xr = (xr << 3) + (xr << 1) + (cr ^ 48), cr = getchar();
	return xr * F;
}

void write(ll x) {
	char ws[51];
	int wt = 0;
	if (x < 0) putchar('-'), x = -x;
	do {
		ws[++wt] = x % 10 + '0';
		x /= 10;
	} while (x);
	for (int i = wt; i; --i) putchar(ws[i]);
}

namespace steven24 {

const int N = 2e5 + 0721;
int step[N], a[N];
int T, n, k; 

void main() {
	T = read();
	while (T--) {
		n = read(), k = read();
		if (k != 4) {
			for (int i = 1; i <= n; ++i) {
				int x = read();
				step[i] = (k - x % k) % k;
			}
			int ans = *min_element(step + 1, step + 1 + n);
			write(ans), putchar('\n');
		} else {
			int cnt = 0;
			for (int i = 1; i <= n; ++i) {
				a[i] = read();
				while (!(a[i] & 1)) ++cnt, a[i] >>= 1;
			}
			if (cnt >= 2) puts("0\n");
			else if (cnt == 1) puts("1\n");
			else {
				bool flag = 1;
				for (int i = 1; i <= n; ++i) {
					if ((a[i] + 1) % 4 == 0) {
						puts("1\n");
						flag = 0;
						break;
					}
				}
				if (flag) puts("2\n");
			}
		}
	}
}

}

int main() {
	steven24::main();
	return 0;
}

D.In Love

做的比B和C快多了

题目大意

维护一个可重集合有 $q$ 次操作每次操作为以下两种之一

加入一个区间 $[l, r]$
删除一个区间 $[l, r]$ 保证至少存在一个该区间

每次操作后你需要回答是否存在两个区间使它们不相交

$1 \leq q \leq 10^{5}, 1 \leq l \leq r \leq 10^{9}$

Solution

考虑维护一棵线段树
对于每次加入操作执行区间+1
对于每次删除操作执行区间-1
再记录一下当前一共有多少个区间
查询全局最大值是否为区间总数即可
记得先全存下来然后离散化
时间复杂度 $O (2 q \log V + q \log 2 q)$

点击查看代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;

inline int read() {
	int xr = 0, F = 1;
	char cr;
	while (cr = getchar(), cr < '0' || cr > '9') if (cr == '-') F = -1;
	while (cr >= '0' && cr <= '9')
		xr = (xr << 3) + (xr << 1) + (cr ^ 48), cr = getchar();
	return xr * F;
}

void write(ll x) {
	char ws[51];
	int wt = 0;
	if (x < 0) putchar('-'), x = -x;
	do {
		ws[++wt] = x % 10 + '0';
		x /= 10;
	} while (x);
	for (int i = wt; i; --i) putchar(ws[i]);
}

namespace steven24 {

const int N = 2e5 + 0721;
int b[N];
int q, n, sum;

struct node {
	int l, r;
	char opt;
} a[N]; 

void discretization() {
	int cnt = 0;
	for (int i = 1; i <= q; ++i) {
		b[++cnt] = a[i].l;
		b[++cnt] = a[i].r;
	}
	sort(b + 1, b + 1 + cnt);
	n = unique(b + 1, b + 1 + cnt) - b - 1;
	for (int i = 1; i <= q; ++i) {
		a[i].l = lower_bound(b + 1, b + 1 + n, a[i].l) - b;
		a[i].r = lower_bound(b + 1, b + 1 + n, a[i].r) - b;
	}
}

struct segment_tree {
	
#define ls (k << 1)
#define rs (k << 1 | 1)
#define mid ((l + r) >> 1)	
	
int tr[N << 2], lazy[N << 2];

inline void add(int k, int val) {
	tr[k] += val;
	lazy[k] += val;
}	

void pushdown(int k) {
	add(ls, lazy[k]);
	add(rs, lazy[k]);
	lazy[k] = 0;
}

inline void pushup(int k) {
	tr[k] = max(tr[ls], tr[rs]);
}

void modify(int k, int l, int r, int u, int v, int val) {
	if (u <= l && v >= r) {
		add(k, val);
		return;
	}
	if (lazy[k]) pushdown(k);
	if (u <= mid) modify(ls, l, mid, u, v, val);
	if (v > mid) modify(rs, mid + 1, r, u, v, val);
	pushup(k);
}
	
} seg;

void main() {
	q = read();
	for (int i = 1; i <= q; ++i) scanf(" %c", &a[i].opt), a[i].l = read(), a[i].r = read();
	discretization();
	
	for (int i = 1; i <= q; ++i) {
		if (a[i].opt == '+') seg.modify(1, 1, n, a[i].l, a[i].r, 1), ++sum;
		else seg.modify(1, 1, n, a[i].l, a[i].r, -1), --sum;
		if (seg.tr[1] == sum) puts("NO\n");
		else puts("YES\n");
	}
}

}

int main() {
	steven24::main();
	return 0;
}

E.Look Back

怎么赛时会被这题卡

题目大意

给定一个长度为 $n (1 \leq n \leq 10^{5})$ 每次操作可以选择一个数并把它 $\times 2$
问将原序列变为一个单调不降序列的最小操作次数
$\sum n \leq 2 \times 10^{5}, 1 \leq a_{i} \leq 10^{9}$

Solution

首先有一个比较显然的贪心：从第2个数开始从前往后考虑每一位每次把一个数变为 $\times 2$ 以后刚刚好不小于前一个数的样子
证明：

如果此时再将它扩大一倍那么后一个数可能需要额外扩大一倍可能不需要但这样一定不优

这样看起来复杂度是 $O (n \log V)$ 的但是真正模拟起来会因为每次扩大而导致的值域扩大二倍让这个复杂度假掉甚至会直接炸 long long

我们考虑优化这个过程仅记录上一位扩大了多少次那么对于当前位我们只需要计算偏移值即可
具体地设上一位操作的次数为 $g_{i - 1}$
如果 $a_{i} < a_{i - 1}$ 算出将 $a_{i}$ 扩大至不小于 $a_{i - 1}$ 需要 $x$ 次操作则 $g_{i} = g_{i - 1} + x$
如果 $a_{i} > a_{i - 1}$ 那么我们或许有可能能少扩大几次所以此事算出将 $a_{i - 1}$ 扩大至刚好不大于 $a_{i}$ 需要 $x$ 次操作则 $g_{i} = g_{i - 1} - x$
注意至少要扩大0次否则会干扰后续计算所以算完 $g_{i}$ 还要和0取个 $max$
答案即为 $\sum_{i = 1}^{n} g_{i}$
时间复杂度就是一个真正的 $O (n \log V)$

点击查看代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;

inline ll read() {
	ll xr = 0, F = 1;
	char cr;
	while (cr = getchar(), cr < '0' || cr > '9') if (cr == '-') F = -1;
	while (cr >= '0' && cr <= '9')
		xr = (xr << 3) + (xr << 1) + (cr ^ 48), cr = getchar();
	return xr * F;
}

void write(ll x) {
	char ws[51];
	int wt = 0;
	if (x < 0) putchar('-'), x = -x;
	do {
		ws[++wt] = x % 10 + '0';
		x /= 10;
	} while (x);
	for (int i = wt; i; --i) putchar(ws[i]);
}

namespace steven24 {

const int N = 1e5 + 0721;
ll a[N], g[N];
int n, T;
ll ans;

void main() {
	T = read();
	while (T--) {
		n = read();
		for (int i = 2; i <= n; ++i) g[i] = 0;
		for (int i = 1; i <= n; ++i) a[i] = read();
		ans = 0;
		for (int i = 2; i <= n; ++i) {
			ll tmp = a[i];
			while (tmp < a[i - 1]) {
				tmp <<= 1;
				++g[i];
//				cout << i << " " << tmp << " " << g[i] <<"\n";
			}
			tmp = a[i - 1];
			while ((tmp << 1) <= a[i]) {
				tmp <<= 1;
				--g[i];
			}
			g[i] += g[i - 1];
			g[i] = max(0ll, g[i]);
			ans += g[i];
//			cout << i << " " << g[i] << "\n";
		}
		write(ans), putchar('\n');
	}
}

}

int main() {
	steven24::main();
	return 0;
}

F.You are so beautiful

卡div2 C.jpg

题目大意

给定一个长度为 $n (1 \leq n \leq 10^{5})$ 的序列
询问有多少子区间 $b = [a_{l}, a_{l + 1}, . . ., a_{r}]$ 满足不存在任何一个其他的 $a$ 的子序列 $c$ 与 $b$ 相同
$\sum n \leq 2 \times 10^{5}, 1 \leq a_{i} \leq 10^{9}$

Solution

注意到每个对于每个合法的 $b$ 而言 $l$ 一定是 $a_{l}$ 出现的最左的位置而 $r$ 一定是 $a_{r}$ 出现的最右的位置这样就不会再存在在 $[l, r]$ 以外的 $(i, j)$ 使得 $a_{i} = a_{l}, a_{j} = a_{r}$ 进而使得 $c = [a_{i}, a_{l + 1}, . . ., a_{j}] = b$

所以我们直接开一个数组记录这个位置是否为该值出现的最左的位置
然后我们枚举右端点对于每个合法的右端点合法的左端点数量就是一段前缀和
该过程可以用 set 配合 BIT 来实现

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

点击查看代码

#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define ll long long
using namespace std;

inline ll read() {
	ll xr = 0, F = 1;
	char cr;
	while (cr = getchar(), cr < '0' || cr > '9') if (cr == '-') F = -1;
	while (cr >= '0' && cr <= '9')
		xr = (xr << 3) + (xr << 1) + (cr ^ 48), cr = getchar();
	return xr * F;
}

void write(ll x) {
	char ws[51];
	int wt = 0;
	if (x < 0) putchar('-'), x = -x;
	do {
		ws[++wt] = x % 10 + '0';
		x /= 10;
	} while (x);
	for (int i = wt; i; --i) putchar(ws[i]);
}

namespace steven24 {

const int N = 1e5 + 0721;
set<int> s1, s2;
int a[N];
int T, n;
ll ans;

struct BIT {

int tr[N];

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

void update(int x, int val) {
	while (x <= n) {
		tr[x] += val;
		x += lowbit(x);
	}
}

int query(int x) {
	int ret = 0;
	while (x) {
		ret += tr[x];
		x -= lowbit(x);
	}
	return ret;
}
	
} bit;

void init() {
	for (int i = 1; i <= n; ++i) bit.tr[i] = 0;
	s1.clear();
	s2.clear();
	ans = 0;
}

void main() {
	T = read();
	while (T--) {
		n = read();
		init();
		for (int i = 1; i <= n; ++i) a[i] = read();
		for (int i = 1; i <= n; ++i) {
			if (s1.find(a[i]) == s1.end()) {
				s1.insert(a[i]);
				bit.update(i, 1);
			}
		}
		for (int i = n; i >= 1; --i) {
			if (s2.find(a[i]) == s2.end()) {
				s2.insert(a[i]);
				ans += bit.query(i);
			}
		}
		write(ans), putchar('\n');
	}
}

}

int main() {
	steven24::main();
	return 0;
}

posted @ 2023-10-23 18:24 Steven24 阅读(1018) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Codeforces Round 666 (Div. 2) 解题报告

· Codeforces Round 419 (Div. 2) 解题报告

· Codeforces Round 905 (Div. 3)

· 4.5Codeforces Round 905 (Div. 3)

公告

昵称： Steven24
园龄： 2年2个月
粉丝： 22
关注： 23

+加关注

2025年3月

日

一

二

三

四

五

六

Steven24

Codeforces Round 905（div3）解题报告

A. Morning

题目大意

Solution

B.Chemistry

题目大意

Solution

C.Raspberries

题目大意

Solution

D.In Love

题目大意

Solution

E.Look Back

题目大意

Solution

F.You are so beautiful

题目大意

Solution

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

一言（ヒトコト）