CF1398F

最新推荐文章于 2024-11-18 20:06:38 发布

原创最新推荐文章于 2024-11-18 20:06:38 发布 · 163 阅读

CC 4.0 BY-SA版权

本文详细介绍了如何使用动态规划和区间线段树解决CF1398F问题，提出两种方法，一种时间复杂度为O(nlnnlogn)，另一种优化后达到O(nlogn)。通过预处理最长不含01后缀，实现快速查询和跳转，降低了复杂度并提高了效率。更新后的代码在全1数据下表现更优。

CF1398F

Solution

我又来贡献暴力做法了。。。~~听说两只log不可能过1e6?~~

有一个显然的想法是：

我们先预处理一个 $a_i$ 表示第 $i$ 个位置的最长后缀长度，满足该后缀中不同时存在0和1。

假设我们要求 $x = i$ 的答案，那么一个位置 $j$ 可以作为一轮的结束点当且仅当 $aj≥ia_j\geq i$ ，而一个结束位置序列 $p_1<p_2<...<p_k$ 合法当且仅当每一个 $p_j$ 都是合法结束点并且相邻两个元素的差至少为 $i$ （保证不重合）。

因此我们会贪心地从第一个满足 $aj≥ia_j\geq i$ 的 $j$ 开始，每次找一个最小的 $j^{'}$ ，满足 $j′≥j+ij'\geq j+i$ 且 $aj′≥ia_{j'}\geq i$ ，然后从 $j$ 跳到 $j^{'}$ ，最终的答案就是跳的步数。

这显然可以直接对 $a_i$ 建区间线段树，维护区间内的 $m a x$ ，线段树上二分求出 $j^{'}$ 。

这个方法的时间复杂度为 $log⁡n)O(\sum ans_i\;\log n)$ ，而 $ansi≤⌊ni⌋ans_i\leq \lfloor\frac{n}{i}\rfloor$ ，因此总时间复杂度 $O(nln⁡nlog⁡n)O(n\ln n\log n)$ ，注意常数即可。

（PS：别用偷懒用set维护，常数起飞，实测接近线段树的三倍）。

Code

char st[MAXN];
int mx[MAXN << 2], a[MAXN];
void build(int x, int l, int r) {
	if (l == r) { mx[x] = a[l]; return; }
	int mid = (l + r) >> 1;
	build(x << 1, l, mid);
	build(x << 1 | 1, mid + 1, r);
	mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
}
int query(int x, int l, int r, int L, int y) {
	if (mx[x] < y) return -1;
	if (l == r) return l;
	int mid = (l + r) >> 1;
	if (L > mid) return query(x << 1 | 1, mid + 1, r, L, y);
	else {
		int t = query(x << 1, l, mid, L, y);
		if (t != -1) return t;
		return query(x << 1 | 1, mid + 1, r, mid + 1, y);
	}
}
signed main() {
#ifndef ONLINE_JUDGE
	freopen("a.in", "r", stdin);
#endif
	int n, cnt0 = 0, cnt1 = 0;
	read(n), reads(st);
	for (int i = 1, l = 1; i <= n ; ++ i) {
		auto add = [&](char x, int y) {
			if (x == '0') cnt0 += y; 
			if (x == '1') cnt1 += y;
		};
		add(st[i], 1);
		while (cnt0 && cnt1) add(st[l ++], -1);
		a[i] = i - l + 1;
	}
	build(1, 1, n);
	for (int i = 1; i <= n ; ++ i) {
		int cnt = 0, r = 1;
		for (; r <= n ;) {
			r = query(1, 1, n, r, i);
			if (r == -1) break;
			r += i;
			++ cnt;
		}
		print(cnt), putc(' ');
	}
	return 0;
}

Update 4.5 23:30

上面的代码跑了 $1890 m s$ ，我们觉得它不够优秀，于是冷静分析一下它慢在哪里，发现全1的数据就可以把它卡满，这是为什么呢？这是因为我们在长长的没有0的段里面做了很多次query，这其实是不必要的，我们同样可以预处理以每个位置开始的最长段。这样就可以 $O (1)$ 计算整个段的贡献。

我们提交后发现它只跑了 $249 m s$ ！

理性分析一下它的时间复杂度，相当于整个序列被01分割为若干段，跳到一个段就可以 $O (1)$ 计算答案并且 $O(log⁡n)O(\log n)$ 跳到下一个段，这样每一段会有 $O (l e n)$ 次贡献（因为每一个长度大于 $i$ 的段才可能产生贡献），每次贡献为 $O(log⁡n)O(\log n)$ ，因此总时间复杂度为 $O(nlog⁡n)O(n\log n)$ ！

Updated code

//线段树部分同上
signed main() {
#ifndef ONLINE_JUDGE
	freopen("a.in", "r", stdin);
#endif
	int n, cnt0 = 0, cnt1 = 0;
	read(n), reads(st);
	for (int i = 1, l = 1; i <= n ; ++ i) {
		auto add = [&](char x, int y) {
			if (x == '0') cnt0 += y; 
			if (x == '1') cnt1 += y;
		};
		add(st[i], 1);
		while (cnt0 && cnt1) add(st[l ++], -1);
		a[i] = i - l + 1;
	}
	cnt0 = 0, cnt1 = 0;
	for (int i = n, r = n; i >= 1 ; -- i) {
		auto add = [&](char x, int y) {
			if (x == '0') cnt0 += y; 
			if (x == '1') cnt1 += y;
		};
		add(st[i], 1);
		while (cnt0 && cnt1) add(st[r --], -1);
		b[i] = r - i;
	}
	build(1, 1, n);
	for (int i = 1; i <= n ; ++ i) {
		int cnt = 0, r = 1;
		for (; r <= n ;) {
			r = query(1, 1, n, r, i);
			if (r == -1) break;
			int p = b[r] / i;
			cnt += p + 1, r += i * (p + 1);
		}
		print(cnt), putc(' ');
	}
	return 0;
}