[nowcoder 2020] 牛半仙的妹子序列

一、题目

点此看题

二、解法

很容易看出可以$\mathtt{d}\mathtt{p}$，$O(n^2)$ 暴力$\mathtt{d}\mathtt{p}$可以看我考试时候的注释。

/*
dp[i]为以i结尾的妹子序列个数
dp[i]+=dp[j]
第一个条件是结尾的是后面这一堆中最小的
第二个条件是开头的是前面这一堆中最大的
第三个条件是v单调递增，并且j是小于vi的最大值 
*/

本题将介绍三种方法：乱搞$\mathtt{a}\mathtt{c}$、神奇线段树、$\mathtt{c}\mathtt{d}\mathtt{q}$分治

0x01 乱搞

因为我往往想不到正解，所以这才是我的方法。乱搞虽然叫乱搞，但肯定有一个中心点，就是难以发现也没用却能让你$\mathtt{c}\mathtt{a}\mathtt{o}$过的点。

我先用$O(n^2)$暴力跑大样例，经过分析发现转移次数不会很多（观察较为苛刻的转移条件，不难感性理解，但是无法证明），跑出大样例的转移次数大约是$O(n\log n)$的，那么快速的找到转移点应该就能在随机数据下表现得较为优秀。

然后自然的想到的主席树，也就是预处理一个权值线段树的前缀和，那么在随机数据下时间复杂度是$O(n{\log }^{2}n)$，过了！ 这应该是我写过的最离谱的方法

#include <cstdio>
#include <iostream>
using namespace std;
const int M = 200005;
const int inf = 1e9;
const int MOD = 998244353;
int read()
{
    int num=0,flag=1;char c;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;
    while(c>='0'&&c<='9')num=(num<<3)+(num<<1)+(c^48),c=getchar();
    return num*flag;
}
int n,ans,cnt,a[M],dp[M],rt[M],mx[40*M],ls[40*M],rs[40*M];
void insert(int &x,int y,int l,int r,int id,int v)
{
	x=++cnt;
	mx[x]=max(mx[y],v);
	ls[x]=ls[y];
	rs[x]=rs[y];
	if(l==r) return ;
	int mid=(l+r)>>1;
	if(mid>=id) insert(ls[x],ls[y],l,mid,id,v);
	else insert(rs[x],rs[y],mid+1,r,id,v);
}
int ask(int x,int l,int r,int L,int R)
{
	if(l>R || L>r) return 0;
	if(L<=l && r<=R) return mx[x];
	int mid=(l+r)>>1;
	return max(ask(ls[x],l,mid,L,R),ask(rs[x],mid+1,r,L,R));
}
int main()
{
	n=read();
	for(int i=1;i<=n;i++)
	{
		a[i]=read();
		insert(rt[i],rt[i-1],1,n,a[i],i);
	}
	for(int i=1,mi=inf;i<=n;i++)
	{
		mi=min(mi,a[i]);
		if(a[i]==mi) dp[i]=1;
	}
	for(int i=1;i<=n;i++)
	{
		int x=ask(rt[i-1],1,n,1,a[i]);
		while(x)
		{
			dp[i]=(dp[i]+dp[x])%MOD;
			x=ask(rt[x-1],1,n,a[x],a[i]);
		}
	}
	for(int i=n,mx=0;i>=1;i--)
	{
		mx=max(mx,a[i]);
		if(a[i]==mx) ans=(ans+dp[i])%MOD;
	}
	printf("%d\n",ans);
}

0x02 神奇线段树

这种方法，看上去简单，但是感觉难以学习，暂且欣赏一下就好。

因为转移是根据权值操作所以可以尝试维护出一颗权值线段树，在线段树里，我们操作的是权值的下标，相当于我们判断在$[1,v_i]$这个范围内，如果没有权值比自己大的并且下标在自己前面的就可以转移。

讲不清楚，只能够看注释了。用的牛客网上面公开的代码，侵删

#include<bits/stdc++.h>
#define lc x<<1
#define rc x<<1|1
using namespace std;
inline int Rd() {
    int s=0; char fl=0,c=getchar();
    while(c<'0'||c>'9') fl|=(c=='-'),c=getchar();
    while(c>='0'&&c<='9') s=(s<<3)+(s<<1)+(c^48),c=getchar();
    return fl?-s:s;
}
const int N=2e5+5,mod=998244353;
int n,maxx,a[N],f[N],pos[N],tag[N<<2],mx[N<<2],lans[N<<2];
inline int add(int x,int y) {return (x+=y)>=mod?x-mod:x; }
void Build(int x,int l,int r) {
	if(l==r) return tag[x]=1,void();  int mid=l+r>>1;
	Build(lc,l,mid),Build(rc,mid+1,r);
}
int Ask(int x,int k) {//表示最大下标是k时候子树 
	if(tag[x]) return mx[x]>k?f[mx[x]]:0;
	//这里的复杂度是基于预处理了左子树的答案的
	//如果k的限制更强，那么重新计算左子树，右子树一定没有答案
	//否者左子树是可以直接用的，右子树需要现在算
	//只会访问一边，时间复杂度是O(log n)的
	//感觉完全就是朴素的思路，但是复杂度如此奇妙！ 
	return mx[rc]<k?Ask(lc,k):add(lans[x],Ask(rc,k));
}
inline void Pushup(int x) {
	mx[x]=max(mx[lc],mx[rc]);
	//这里可以暴力算左子树的答案，反正是O(log n)的 
	lans[x]=Ask(lc,mx[rc]);
}
void Insert(int x,int l,int r,int d,int v) {
//	cout<<l<<" "<<r<<endl; 
	if(l==r) return mx[x]=v,void();  int mid=l+r>>1;
	d<=mid?Insert(lc,l,mid,d,v):Insert(rc,mid+1,r,d,v);
	Pushup(x);
}
int Query(int x,int l,int r,int ql,int qr) {
	//把[1,v]的拆出来若干个线段树上的区间 
	if(ql<=l&&r<=qr) {
		int v=maxx; maxx=max(maxx,mx[x]);
		return Ask(x,v);//询问答案 
	}
	int mid=l+r>>1,res=0;
	if(qr>mid) res=add(res,Query(rc,mid+1,r,ql,qr));
	//需要优先访问右子树，得到最大下标 
	if(ql<=mid) res=add(res,Query(lc,l,mid,ql,qr));
	return res; 
}
int c[N];
inline void Add(int x,int d) {for(int i=x; i<=n; i+=i&(-i)) c[i]+=d; }
inline int Ask(int x) {int res=0; for(int i=x; i; i-=i&(-i)) res+=c[i]; return res; }
int main(){
	n=Rd(); for(int i=1; i<=n; ++i) pos[a[i]=Rd()]=i;
	Build(1,1,n);
	for(int i=1; i<=n; ++i) {//dp
		int x=pos[i]; maxx=0;
		f[i]=Query(1,1,n,1,x);
		if(!f[i]) f[i]=1;
		Insert(1,1,n,x,i);
	}
	int ans=0;
	for(int i=n; i; --i) {//dp完算答案 
		if(Ask(n)-Ask(pos[i])==0) ans=add(ans,f[i]);
		Add(pos[i],1);
	}
		
	printf("%d\n",ans);
    return 0;
}

cdq 分治

这个方法来自于我们的蒋永神，因为是还是基于权值来操作，按照权值来划分区间$cdq$，首先要看一幅图：

这是我们按权值划分时候的结果，$m$是我们的分界线，如果有权值像上图一样夹在$i,j$的中间，那么就不行。所以我们相当于把夹在中间的移动到两边去，设$r_j$为只考虑$[l,m]$中右边第一个比$j$大的数的下标，$l_i$表示只考虑$(m,r]$中左边第一个比$i$小的数的下标，读图可以满足：
$$l_i\le j\le i\le r_j$$首先$l,r$都是很好维护的，先按$l_i$排序，枚举$i$，加入$l_i\le j$，然后对于$[j,r_j]$更新贡献。

#include <cstdio>
#include <iostream>
#include <vector>
#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 = 200010;
const int infty = (1<<30)-1;
const int Mod = 998244353;
int n; // though alone, still necessary
struct Node{
	int a, id, l, r, dp;
	Node(){ dp = 0; }
	bool operator < (const Node &t) const {
		return id < t.id; // 按照下标排序
	}
};
Node node[MaxN];
class BIT{
	int c[MaxN];
public:
	void modify(int x,int v){
		for(int i=x; i<=n; i+=(i&-i))
			c[i] = (c[i]+v)%Mod;
	}
	int query(int x){
		int res = 0;
		for(int i=x; i; i-=(i&-i))
			res = (res+c[i])%Mod;
		return res;
	}
	void clear(int x){
		for(int i=x; i<=n; i+=(i&-i))
			c[i] = 0;
	}
};
BIT xyx;

vector< int > sta;
void getInfo(int l,int r){
	sort(node+l,node+r+1);
	sta.clear(); // good habit
	sta.push_back(0); // be bottom
	for(int i=l; i<=r; ++i){
		while(!sta.empty() &&
		node[sta.back()].a > node[i].a)
			sta.pop_back();
		node[i].l = node[sta.back()].id;
		sta.push_back(i);
	}
	sta.clear(); // essential
	sta.push_back(n+1); // be bottom
	for(int i=r; i>=l; --i){
		while(!sta.empty() &&
		node[i].a > node[sta.back()].a)
			sta.pop_back();
		node[i].r = node[sta.back()].id;
		sta.push_back(i);
	}
}
bool cmp(const Node &x,const Node &y){
	return x.l < y.l; // 按照 l 排序
}
bool cdq(const Node &x,const Node &y){
	return x.a < y.a; // 按照 a 值排序
}
void solve(int l,int r){
	if(l == r) return ; // nothing to do
	int m = (l+r)>>1;
	solve(l,m); // 中序遍历
	getInfo(l,m), getInfo(m+1,r);
	sort(node+m+1,node+r+1,cmp);
	sort(node+l,node+m+1); // 下标排序
	for(int i=r,j=m; i>m; --i){
		int zxy = node[i].l;
		while(j >= l && zxy < node[j].id){
			int x = node[j].dp; // 加入
			xyx.modify(node[j].r,Mod-x);
			xyx.modify(node[j].id+1,x);
			-- j; // 非常重要！
		}
		node[i].dp += xyx.query(node[i].id);
		node[i].dp %= Mod; // 小心点！
	}
	for(int i=l; i<=m; ++i){
		xyx.clear(node[i].r);
		xyx.clear(node[i].id+1);
	}
	sort(node+m+1,node+r+1,cdq);
	solve(m+1,r); // 继续递归右边
}

int main(){
	n = readint();
	for(int i=1,now=n+1; i<=n; ++i){
		node[i].id = i;
		node[i].a = readint();
		if(node[i].a < now){
			node[i].dp = 1;
			now = node[i].a;
		}
	}
	node[0].id = node[0].a = 0;
	node[n+1].id = node[n+1].a = n+1;
	sort(node+1,node+n+1,cdq);
	solve(1,n); // 两个边界都是实点
	sort(node+1,node+n+1); // 还原成原序列！
	int ans = 0; // sy orz. xyx orz.
	for(int i=n,now=0; i; --i)
		if(node[i].a > now){
			ans = (node[i].dp+ans)%Mod;
			now = node[i].a;
		}
	printf("%d\n",ans);
	return 0;
}