[ZROI2021]Unfair Tournament

最新推荐文章于 2021-10-31 19:29:48 发布

OneInDark

最新推荐文章于 2021-10-31 19:29:48 发布

阅读量133

点赞数

分类专栏： CDQ分治 C++

本文链接：https://blog.csdn.net/qq_42101694/article/details/115280809

版权

竞赛策略冠军预测 CDQ算法实力动态调整比赛规则

关键词由CSDN通过智能技术生成

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

547 篇文章 3 订阅

订阅专栏

CDQ分治

8 篇文章 0 订阅

订阅专栏

题目

题目描述
有一场不公平的竞赛，一共有 $n$ 位参赛选手，站成一列，第 $i$ 位参赛选手的初始实力值为 $a_i$ 。

一共有 $n - 1$ 场比赛，每场比赛你可以任意选择两个相邻的参赛选手，实力值大的胜出（若两个人实力相同则你可以指定胜者）。这看上去很公平。糟糕的是，由于战斗经验的增加，胜者的实力值会永久加一。败者离开这场比赛（从这个选手序列中删除）。在这 $n - 1$ 场比赛后剩下的那一名选手即为冠军。

容易看出冠军不一定是初始实力值最大的选手。求哪些选手可能是最后的冠军。

数据范围与提示
$n\le 5\times 10^5,\;0\le a_i<2^{31}$ 。

考场草稿

怎样保护一个选手？把他身边比他弱的都干掉。不能让强强对决，这样只会造出一个更强的！也不能弱弱对决，那样会让这个人少一些经验。

假如他会失败，一定是身边两个人把他夹住了。即存在 $l < x < r$ 使得 $r-l-2+a_x<\min(a_l,a_r)$ ，即 $r-l-1+a_x\le\min(a_l,a_r)$ 。

如果 $a_l<a_r$ ，那么只需要 $a_x\le a_l+l-r+1$ ，最小化 $r$ 并且最大化 $a_l+l$ 即可。

如果 $a_l\ge a_r$ ，只需要 $a_x\le a_r-r+l+1$ ，最大化 $l$ 并且最大化 $a_r-r$ 即可。

能不能 $\tt cdq$ 呢？考虑将序列分成 $[1, m i d), [m i d, r)$ ，然后左边的 $a_l$ 贡献给更大的 $a_r$ 。有了！在 $a_r$ 处考虑它贡献给 $[m i d, r)$ ，就只需要求最大的 $a_l+l$ 即可。 $l$ 同理。

按照 $a$ 归并即可。 $\mathcal O(n\log n)$ 。

一些解释

为什么会往 $\tt cdq$ 上面想呢？因为这个 $l < x < r$ 的条件中， $l$ 的范围相差甚小。很久之前我就说过，这种东西就往 $\tt cdq$ 上面靠准没错。

当然，也有可能是因为 $l < r$ 与 $a_l<a_r$ 类似二维偏序吧？因为 $\min$ 这玩意儿也挺难搞的。要么 $\min\text-\max$ 反演，要么枚举，再没别的想法。

上面那个等价条件是怎么想到的呢？我也不知道 😕 可能是因为这种题目必须要等价转化吧。因为它本身是一个很复杂的过程，你去模拟它就是 $\mathcal O(n^2)$ 的了……

总结一下就是：要先想到 $\tt cdq$ ，再考虑怎么套。上一次见到这种先想算法再套进去的题目，已经是上古时期了……

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
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;
}

const int MaxN = 500005;
const int_ INF = (1ll<<60)-1;

struct Ren{
	int pos; int_ val;
	bool operator < (const Ren &p) const {
		return val < p.val;
	}
};
Ren ren[MaxN]; int ans[MaxN];

Ren xyx[MaxN]; int tmp[MaxN];
void updateL(int l,int r){
	for(int i=l,v=0; i!=r; ++i){
		ans[i] = max(ans[i],v);
		v = max(v,tmp[i]); // Kai Qv Jian
	}
}
void updateR(int l,int r){
	for(int i=r-1,v=0; i>=l; --i){
		ans[i] = max(ans[i],v);
		v = max(v,tmp[i]); // Kai Qv Jian
	}
}
void solve(int l,int r){
	if(r-l == 1) return ;
	int mid = (l+r)>>1;
	solve(l,mid), solve(mid,r);
	/* a_l < a_r for r */ ;
	int_ v = -INF;
	for(int j=mid,i=l; j!=r; ++j){
		for(; i!=mid&&ren[i]<ren[j]; ++i)
			v = max(v,0ll+ren[i].pos+ren[i].val);
		tmp[ren[j].pos] = max(-1ll,v-ren[j].pos+1);
	}
	/* a_l >= a_r for r */ ;
	v = -INF;
	for(int j=r-1,i=mid-1; j>=mid; --j){
		for(; i>=l&&!(ren[i]<ren[j]); --i)
			v = max(v,0ll+ren[i].pos);
		tmp[ren[j].pos] = max(
			0ll+tmp[ren[j].pos],
			v+ren[j].val-ren[j].pos+1
		);
	}
	updateR(mid,r); // release tag
	/* a_l >= a_r for l */ ;
	v = -INF;
	for(int i=l,j=mid; i!=mid; ++i){
		for(; j!=r&&!(ren[i]<ren[j]); ++j)
			v = max(v,0ll+ren[j].val-ren[j].pos);
		tmp[ren[i].pos] = max(-1ll,v+ren[i].pos+1);
	}
	/* a_l < a_r for l */ ;
	v = -INF;
	for(int i=mid-1,j=r-1; i>=l; --i){
		for(; j>=mid&&ren[i]<ren[j]; --j)
			v = max(v,0ll-ren[j].pos);
		tmp[ren[i].pos] = max(
			0ll+tmp[ren[i].pos],
			v+ren[i].pos+ren[i].val+1
		);
	}
	updateL(l,mid);
	/* merge sort */ ;
	for(int i=l,j=mid; i!=mid||j!=r; )
		if(j == r || (i != mid && ren[i] < ren[j]))
			xyx[i+j-mid] = ren[i], ++ i;
		else xyx[i+j-mid] = ren[j], ++ j;
	for(int i=l; i!=r; ++i) ren[i] = xyx[i];
}

int ori[MaxN]; // original val
int main(){
	int n = readint();
	for(int i=1; i<=n; ++i){
		ren[i].pos = i;
		ren[i].val = readint();
		ori[i] = ren[i].val;
		ans[i] = -1; // init
	}
	ren[0].pos = 0; // virtual wall
	ren[0].val = INF>>1;
	solve(0,n+1); // right open
	for(int i=0; i<=n; ++i)
		xyx[ren[i].pos] = ren[i];
	for(int i=0; i<=n; ++i)
		ren[i] = xyx[i]; // restore
	ren[n+1].pos = n+1; // wall
	ren[n+1].val = INF>>1;
	solve(1,n+2); // right open
	int calc = 0;
	for(int i=1; i<=n; ++i)
		if(ans[i] < ori[i])
			++ calc;
	printf("%d\n",calc);
	for(int i=1; i<=n; ++i)
		if(ans[i] < ori[i])
			printf("%d ",i);
	putchar('\n');
	return 0;
}

吐槽

那种 $\mathcal O(n^2)$ 的做法，可以优化吗？比如用 $\tt ST$ 表 $+$ 倍增？

其实它只会让你白白地多一个 $\log$ 。有一种很厉害的数据，专门卡这玩意儿的：左边是 $x,x-2,x-4,\dots,\frac{n}{2}$ ，中间是任意的 $\frac{n}{2}$ 个 $0 / 1$ ，右边是 $\frac{n}{2}+1,\frac{n}{2}+3,\frac{n}{2}+5,\dots,x+1$ 。不难发现，对于这种 “山沟沟” 型数据，谷底的元素都不得不左右横跳，一定是 $\mathcal O(n^2)$ 的。