P8866 [NOIP2022] 喵了个喵 （构造）

P8866 [NOIP2022] 喵了个喵

构造模拟题，思路很简洁，但是代码不好写。

首先看到数据范围，发现 \(k\) 的数据范围很特殊，种类少一种就是部分分，所以 \(k\) 一定是关键的，先思考 \(k=2n-2\) 的情况。

\(k=2n-2\)

观察两种操作，对于即将进入的牌 \(x\)，若某个栈顶或栈底有相同的 \(x\)，我们都可以很快的将其消去。这启发我们：

1. 把所有栈的数量控制在 \(2\) 以内是最优的，并且所有相同类型的牌不会在栈中出现第二次。
2. 当某类牌出现偶数次时，会被消光。

再回到数据范围，如果我们将 \(2n-2\) 种牌放到前 \(n-1\) 个栈中，由于一定有空栈，我们就可以任意消去所有类型的牌，不会无解。

\(k=2n-1\)

我们仍然想要沿用之前的思路，但是会遇到新的情况，即前 \(n-1\) 个栈都放满了，而即将放入的栈是第 \(2n-1\) 种牌 \(x\)。此时如果放入空栈，容易导致无解。

这时我们考虑什么时候不能放在空栈。发现如果放在空栈，当遇到一个目前类型在栈底的牌，并且此时它仍被栈顶挡住时，就无解了；如果两张 \(x\) 之间没有在栈底的牌，这时我们可以放入栈底。而我们可以枚举找到第一个在类型在栈底的牌 \(y\)，所在的栈为 \(s\)，这时再考虑什么情况它仍会被栈顶挡住。

设栈 \(s\) 的栈顶为 \(p\)：

如果 \(x\) 到 \(y\) 中的 \(p\) 数量为偶数时，把 \(x\) 放在 \(s\) 上，把所有 \(p\) 都放入空栈消掉，最后用空栈删去 \(y\)。

如果 \(x\) 到 \(y\) 中的 \(p\) 数量为奇数时，把 \(x\) 放在空栈，这是我们可以把 \(p\) 全放入 \(s\) 中把栈顶消去，最后把 \(y\) 放入 \(x\) 中，此时发现 \(s\) 栈空了，而原本的空栈多了一个 \(x\)，也就是空栈变成了 \(s\)。

现在思路就清晰了：

能用先前的思路就用先前的思路，不能用就分类讨论。

代码能力在这里就体现了，如果没有运用合适的数据结构就会写的很复杂。

1. 对于可用的位置我们用队列维护，原先每个栈放两个位置进去。
2. 对于栈，我们用双端队列维护，我们还需要每个种类的牌此时所在的位置，用数组 \(id\) 记录。
3. 对于答案记录，边模拟边记录，数组或 vector 都可以。
4. 由于操作会多次调用，所以考虑用函数封装，使主函数代码更简洁。

每一次枚举找到第一个在类型在栈底的牌后，我们可以直接将 \(i=r\)，复杂度是 \(O(m)\)。

总结：一题有思维的模拟题，需要从数据范围出发，找到启发性性质，对模拟过程有清晰思路后才开始写代码；用合适的数据结构维护数据和模拟过程。

#include <bits/stdc++.h>
typedef std::pair<int, int> pii;
typedef long long ll;
int read() {
	int x = 0, f = 1;
	char c = getchar();
	while(!isdigit(c)) {
		if(c == '-') f = -1;
		c = getchar();
	}
	while(isdigit(c)) {
		x = (x << 3) + (x << 1) + (c - '0');
		c = getchar();
	} 
	return x * f;
}
int t, n, m, k, sp;
int a[2000010], id[610];
std::deque<int> st[610];
std::vector<pii> ans;
std::queue<int> q;
void pu(int x) {
	ans.push_back({0, x});
}
void del(int x, int y) {
	ans.push_back({x, y});
}
bool normal(int a) {
	int s = id[a];
	if(!s) {
		if(q.empty()) return 0;
		s = q.front();
		q.pop();
		pu(s);
		st[s].push_back(a);
		id[a] = s; 
	}
	else {
		id[a] = 0;
		q.push(s);
		if(st[s].back() == a) {
			pu(s);
			st[s].pop_back();
		}
		else {
			pu(sp);
			del(s, sp);
			st[s].pop_front();
		}
	}
	return 1;
}
void Solve() {
	memset(id, 0, sizeof(id));
	while(!q.empty()) q.pop();
	ans.clear();
	n = read(), m = read(), k = read();
	sp = n;
	for(int i = 1; i <= m; i++) a[i] = read();
	for(int i = 1; i < n; i++) {
		q.push(i), q.push(i);
	} 
	for(int i = 1; i <= m; i++) {
		if(!normal(a[i])) {
			int r = i + 1, x = a[r], now = a[i];
			for(; r <= m && x != now && st[id[x]].back() == x; r++, x = a[r]);
			if(x == now) {
				pu(sp);
				for(int l = i + 1; l < r; l++) {
					normal(a[l]);
				}
				pu(sp);
			}
			else {
				bool flg = 0;
				int s = id[x], y = st[s].back(); 
				for(int l = i + 1; l < r; l++) {
					if(a[l] == y) {
						flg ^= 1;
					}
				}
				if(!flg) {
					pu(s);
					st[s].push_back(now);
					for(int l = i + 1; l < r; l++) {
						if(a[l] == y) pu(sp);
						else normal(a[l]);
					}
					pu(sp);
					del(s, sp);
					st[s].pop_front();
					id[x] = 0;
					id[now] = s;
				}
				else {
					pu(sp);
					st[sp].push_back(now);
					for(int l = i + 1; l < r; l++) {
						if(a[l] == y) pu(s);
						else normal(a[l]);
					}
					pu(s);
					id[x] = id[y] = 0;
					id[now] = sp;
					st[s].clear();
					q.push(sp);
					sp = s;
				}
			}
			i = r;
		}
	}
	std::cout << ans.size() << "\n";
	for(pii p : ans) {
		if(p.first == 0) std::cout << "1 " << p.second << "\n";
		else std::cout << "2 " << p.first << " " << p.second << "\n";
	}
}

int main() {
	
	t = read();
	while(t--) Solve();

	return 0;
}