AtCoder Beginner Contest 380 A - E

link

赛时是 ABC，D 一眼要找规律，跳了，E 题思路想了接近半个小时，然后发现假了，最后没调出来，

问一下 dalao 发现其实很简单维护。。。基础线段树没切掉，哎呦

不过发现比赛打多了，理解速度和手速都有些提高，幸好前三题秒掉了，要不然 rating 又会是一坨

---

A - 123233

B - Hurdle Parsing

C - Move Segment

D - Strange Mirroring

一道简单递归。

发现字符串是成倍增长的，显然考虑找规律，

手摸一下会发现，要找的字母其实是由之前的 相反的 字母转换过来的，而这条转换链也很有规律，

比如样例 1，找 30 位置，理解为 2 ^ 5 - 2，是由 14（2 ^ 4 - 2）大小写取反转换，又由 6（2 ^ 3 - 2）...... 最后将规模转化为原长字符串中。

显然递归是 $\log$ 的，还有，每次找位置的规模是随递归减小的，所以达不到 ${\log }^{2}n$ 吧

code

#include <bits/stdc++.h>
#define re register int 
#define int long long
 
using namespace std;
const int N = 2e5 + 10;
 
string s;
int q;
 
inline char change(char x)
{
	if ('a' <= x && x <= 'z') return x - 'a' + 'A';
	else return x - 'A' + 'a';
}
 
inline char find(int x, bool flag)
{
	if (x <= s.size())
	{
		if (flag) return change(s[x - 1]);
		else return s[x - 1];
	}
	int k = s.size();
	while ((k << 1ll) < x) k <<= 1ll;
	find(x - k, !flag);
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	cin >> s;
	cin >> q;
	while (q --)
	{
		int x; cin >> x;
		cout << find(x, false) << ' ';
	}
	cout << '\n';
	return 0;
}

E - 1D Bucket Tool

维护序列的全相等联通块，感觉是个很常见的东西，确实做法很多，set，dsu 都可以，

原谅我只想到复杂度更劣的 线段树 + 二分 qwq

一眼看上去，是个很可以用线段树维护的 ds 题

区间修改很简单

主要是如何维护，给定一个位置，找该位置的颜色的最大连通块，还要是 $\log$ 级别的时间

一开始是想倍增跳，但是发现不好维护 连续相同

最后只能是从线段树直接维护的角度想，突然注意到，找连通块的左右界，是可以二分的。这是显然的，可以简单考虑为区间长度越长，越更可能 不连续相同，也就是说如果长度更短的区间都不能连续，那么更长的不可能更优

然后考虑区间连续相同是不是等价于 $\bigcap _{i=l}^r{a}_i=a_k(k\in [l,r])$ 呢？然后 wa 了一大堆。。。

赛后发现随便举出反例 10 & 11 & 10 = 10

其实是可以直接维护这个逻辑的，，，子区间相同或否，pushup 维护一个标志值就可以了。最后区间查询，发现数据范围比较小，直接开个颜色的桶就可以了。

复杂度 $O(n{\log }^{2}n)$

code

#include <bits/stdc++.h>
#define re register int 
#define lp p * 2
#define rp p * 2 + 1
#define int long long
 
using namespace std;
typedef pair<int, int> PII;
const int N = 5e5 + 10;
 
struct Tree { int l, r, sum, tag, flag; } t[N << 2];
int n, q, num[N];
 
inline void push_up(int p)
{
	t[p].sum = t[lp].sum + t[rp].sum;
	t[p].flag = ((t[lp].flag == t[rp].flag && t[lp].flag) ? t[lp].flag : 0);
}
 
inline void push_down(int p)
{
	if (t[p].tag)
	{
		t[lp].sum = (t[lp].r - t[lp].l + 1) * t[p].tag;
		t[rp].sum = (t[rp].r - t[rp].l + 1) * t[p].tag;
		t[lp].flag = t[rp].flag = t[p].tag;
		t[lp].tag = t[p].tag;
		t[rp].tag = t[p].tag;
		t[p].tag = 0;
	}
}
 
inline void build(int p, int l, int r)
{
	t[p].l = l, t[p].r = r;
	if (l == r)
	{
		t[p].sum = t[p].flag = l;
		return;
	}
	int mid = (l + r) >> 1;
	build(lp, l, mid); build(rp, mid + 1, r);
	push_up(p);
}
 
inline void update(int p, int l, int r, int k)
{
	if (l <= t[p].l && t[p].r <= r)
	{
		t[p].sum = (t[p].r - t[p].l + 1) * k;
		t[p].flag = k;
		t[p].tag = k;
		return;
	}
	push_down(p);
	int mid = (t[p].l + t[p].r) >> 1;
	if (l <= mid) update(lp, l, r, k);
	if (r > mid) update(rp, l, r, k);
	push_up(p);
}
 
inline int query(int p, int l, int r)
{
	if (l <= t[p].l && t[p].r <= r) return t[p].sum;
	push_down(p);
	int res = 0;
	int mid = (t[p].l + t[p].r) >> 1;
	if (l <= mid) res += query(lp, l, r);
	if (r > mid) res += query(rp, l, r);
	
	return res;
}
 
inline bool ask(int p, int l, int r, int k)
{
	if (l <= t[p].l && t[p].r <= r)
	{
		if (t[p].flag != k) return false;
		return true;
	}
	push_down(p);
	bool res = true;
	int mid = (t[p].l + t[p].r) >> 1;
	if (l <= mid) res &= ask(lp, l, r, k);
	if (r >mid) res &= ask(rp, l, r, k);
	
	return res;
}
 
inline PII search(int x)
{
	int a = query(1, x, x);	
	int L, R;
	
	int l = 1, r = x;
	while (l < r)
	{
		int mid = (l + r) >> 1;
		if (ask(1, mid, x, a)) r = mid; 
		else l = mid + 1;
	}
	L = l;
	
	l = x, r = n;
	while (l < r)
	{
		int mid = (l + r + 1) >> 1;
		if (ask(1, x, mid, a)) l = mid;
		else r = mid - 1;
	}
	R = l;
	
	return {L, R};
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	cin >> n >> q;
	build(1, 1, n);	
	for (re i = 1; i <= n; i ++) num[i] = 1;
	
	while (q --)
	{
		int op, x, y; cin >> op;
		if (op == 1)
		{
			cin >> x >> y;
			PII k = search(x); int l = k.first, r = k.second;
			
			num[query(1, x, x)] -= (r - l + 1);
			update(1, l, r, y);	
			num[y] += (r - l + 1);
			
		}
		else 
		{
			cin >> x;
			cout << num[x] << '\n';
		}
	}
	
	return 0;
}