[CSP-S2020]贪吃蛇

最新推荐文章于 2024-02-06 09:51:42 发布

OneInDark

最新推荐文章于 2024-02-06 09:51:42 发布

阅读量587

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ 博弈

本文链接：https://blog.youkuaiyun.com/qq_42101694/article/details/117851426

C++ 同时被 2 个专栏收录

547 篇文章

订阅专栏

博弈

27 篇文章

订阅专栏

本文解析了在编程竞赛中的经典问题——Toluogu中，蛇形矩阵中最强蛇如何通过策略避免被次强蛇牺牲。关键在于判断是否安全吃蛇，遵循递归规则，确保次级蛇作为缓冲。算法核心是利用队列维护蛇的强弱顺序，实现O(n)复杂度解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

传送门 to luogu

思路

最好玩的一点是，在某个情形下，最强蛇一定会吃最弱蛇，原因就在于次强蛇会不会当 “替死鬼”。

假设最强蛇是 $a_n$ ，最弱蛇是 $a_1$ ，次弱蛇是 $a_2$ ，次强蛇是 $a_{n-1}$ 。如果 $a_n-a_1\ge a_2$ （若相等则判断编号，下文中的 $\ge$ 和 $\le$ 同理）那么吃完之后， $a_2$ 成为最弱蛇。不妨设 $a_{n-1}$ 此时变成了最强蛇，那么 总是有
$a_{n-1}-a_2\le a_n-a_1$

多神奇的一个发现——只要最强蛇没有一跃成为最弱蛇，那么次强蛇吃完就会给它垫背！

而次强蛇可以选择不吃，所以次强蛇一定不会死。连次强蛇都没死，那比它更强的最强蛇当然也不会死！

所以，只要 $a_n-a_1\ge a_2$ ，最弱蛇就死定了。否则，我们还是要掂量掂量后果。

那么考虑第一次 $a_n-a_1\le a_2$ 的时候。即，最强蛇吃完之后，直接变成了最弱蛇。显然只需要看，此时自己会不会被吃。如果遇到了一个最强蛇吃完没有变成最弱蛇的状态，那我们就不要往火坑里跳；否则就接着递归！

总结一下就是：一开始 $a_n-a_1\ge a_2$ ，可以肆无忌惮地选择吃。直到第一次 $a_n-a_1\le a_2$ ，假设要吃，递归处理子局面。递归处理的每个局面都是最强蛇吃完直接变成最弱蛇，否则就会 $\rm return$ 。这个递归的结果就是，吃完之后直接变成最弱蛇，会不会被吃。这里只产生 $1$ 的贡献。

如何实现这个过程呢？递归处理的部分很简单，直接把最强蛇拿出来，变成最弱蛇，一个双端队列轻松实现。只看第一个部分。

利用上面的 “总是有” 不等式。所有吃过蛇的蛇是天然有序的，可以放在一个队列里面；最初的 $a_i$ 已经保证了单调，也可以放在队列里面。相当于我们有两个有序的数列，求 $\min$ 和 $\max$ 不是轻轻松松吗？

把这两个队列归并一下，就可以进入递归啦！显然每次操作 $\mathcal O(1)$ ，最多 $\mathcal O(n)$ 次，于是 $\mathcal O(Tn)$ 就解决了此题。

顺带吐槽一下：用 $k$ 竟然真的只是怕读入量太大？我还以为复杂度是 $\mathcal O(n\log n+Tk\log n)$ 呢……

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long int_;
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}
inline void writeint(int_ x){
	if(x > 9) writeint(x/10);
	putchar((x-x/10*10)^48);
}

const int MaxN = 1000005;
int a[MaxN], n, b[MaxN];
bool cmp(const int &x,const int &y){
	return a[x] < a[y] || (a[x] == a[y] && x < y);
}

deque<int> one, two;
bool alive(){
	int x = one.back(); one.pop_back();
	if(one.empty()) return true;
	a[x] -= a[one.front()];
	one.pop_front();
	if(!one.empty() && cmp(one.front(),x))
		return false; // always able to eat
	one.push_front(x); return !alive();
}
void merge_(){
	deque<int> res; res.clear();
	while(!one.empty() || !two.empty())
		if(two.empty() || (!one.empty() && cmp(one.front(),two.front())))
			res.push_back(one.front()), one.pop_front();
		else res.push_back(two.front()), two.pop_front();
	one.swap(res); // save result
}
int solve(){
	one.clear(), two.clear();
	for(int i=1; i<=n; ++i)
		a[i] = b[i], one.push_back(i);
	while(two.size()+one.size() > 1u){
		deque<int> *tiny = &one, *big = &one;
		if(!two.empty() && cmp(one.back(),two.back()))
			big = &two; // where's max
		if(!two.empty() && cmp(two.front(),one.front()))
			tiny = &two; // where's min
		int x = (*big).back();
		a[x] -= a[(*tiny).front()]; // eat it
		(*big).pop_back(), (*tiny).pop_front();
		if(one.empty()) one.swap(two); // reset
		two.push_front(x); // minimum one
		if(!one.empty() && cmp(x,one.front()))
			break; // need recursing check
	}
	if(one.size()+two.size() == 1u)
		return 1; // only remaining one
	merge_(); int ans = one.size();
	if(!alive()) ++ ans; // undo last "eat"
	return ans;
}

int main(){
	int T = readint();
	n = readint();
	rep(i,1,n) b[i] = readint();
	printf("%d\n",solve());
	for(int i=2; i<=T; ++i){
		int k = readint();
		for(int x; k; --k){
			x = readint();
			b[x] = readint();
		}
		printf("%d\n",solve());
	}
	return 0;
}