【LOJ3247】「USACO 2020.1 Platinum」Non-Decreasing Subsequences（DP，分治）

题面

🔗

题解

对于一整个序列，我们可以通过 $O(N\log K)$ 的 DP （树状数组优化）求出不下降子序列的数量。如果对于头尾元素进行讨论，时间复杂度就变为 $O(NK\log K)$ 。如果通过两端区间的头尾元素讨论合并成一段区间的不下降子序列数量，时间复杂度是 $O(K)$ 的，而这道题能够支持的也就是 $O(QK)$ 了，所以我们的解法是：

分治

把询问放到分治区间上，保证分治区间的中心在询问区间里，然后 DP 处理出左边每个后缀讨论尾部的结果，右边每个前缀讨论头部的结果，每个询问把对应的左右两端合并起来就好了。

总时间复杂度 $O(NK\log N\log K+QK)$ 。不要以为 $K$ 是 log 级别的就不可以作为底数了。

这好像是个很经典的思路，可惜我没有想到。

CODE

#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<queue>
#include<stack>
#include<random>
#include<bitset>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
#pragma GCC optimize(2)
using namespace std;
#define MAXN 200005
#define LL long long
#define ULL unsigned long long
#define ENDL putchar('\n')
#define DB double
#define lowbit(x) (-(x) & (x))
#define FI first
#define SE second
#define PR pair<int,int>
#define UIN unsigned int
int xchar() {
	static const int maxn = 1000000;
	static char b[maxn];
	static int pos = 0,len = 0;
	if(pos == len) pos = 0,len = fread(b,1,maxn,stdin);
	if(pos == len) return -1;
	return b[pos ++];
}
// #define getchar() xchar()
inline LL read() {
	LL f = 1,x = 0;int s = getchar();
	while(s < '0' || s > '9') {if(s<0)return -1;if(s=='-')f=-f;s = getchar();}
	while(s >= '0' && s <= '9') {x = (x<<1) + (x<<3) + (s^48);s = getchar();}
	return f*x;
}
void putpos(LL x) {if(!x)return ;putpos(x/10);putchar((x%10)^48);}
inline void putnum(LL x) {
	if(!x) {putchar('0');return ;}
	if(x<0) putchar('-'),x = -x;
	return putpos(x);
}
inline void AIput(LL x,int c) {putnum(x);putchar(c);}

const int MOD = 1000000007;
int n,m,s,o,k;
inline int& MD(int &x) {return x>=MOD ? x-=MOD:x;}
int a[MAXN];
void addc(int *c,int x,int y) {while(x<=m)MD(c[x]+=y),x+=lowbit(x);}
void addc2(int *c,int x,int y) {while(x>0)MD(c[x]+=y),x &= (x-1);}
int sum(int *c,int x) {int s=0;while(x>0)MD(s+=c[x]),x&=(x-1);return s;}
int suf(int *c,int x) {int s=0;while(x<=m)MD(s+=c[x]),x+=lowbit(x);return s;}
int as[MAXN],ql[MAXN],qr[MAXN];
vector<int> bu[MAXN<<2];
void addtree(int a,int l,int r,int al,int ar,int i) {
	if(al > r || ar < l || l > r) return ;
	int md = (al + ar) >> 1;
	if((l <= md && r > md) || al == ar) {bu[a].push_back(i);return ;}
	addtree(a<<1,l,r,al,md,i); addtree(a<<1|1,l,r,md+1,ar,i);
	return ;
}
int dp[50005][23];
void solve(int x,int l,int r) {
	if(l == r) {
		for(auto &i:bu[x]) {
			as[i] = 2;
		} return ;
	}
	int md = (l + r) >> 1;
	int dpp[23][23] = {};
	for(int i = md;i >= l;i --) {
		for(int j = 1;j <= m;j ++) {
			int nm = suf(dpp[j],a[i]) + (j==a[i]);
			addc2(dpp[j],a[i],nm);
		}
		dp[i][0] = 1;
		for(int j = 1;j <= m;j ++) {
			dp[i][j] = suf(dpp[j],1);
		}
	}
	memset(dpp,0,sizeof(dpp)); addc(dpp[0],1,1);
	for(int i = 1;i <= m;i ++) addc(dpp[i],i,1);
	for(int i = md+1;i <= r;i ++) {
		for(int j = 0;j <= m;j ++) {
			int nm = sum(dpp[j],a[i]);
			addc(dpp[j],a[i],nm);
		}
		for(int j = 0;j <= m;j ++) {
			dp[i][j] = sum(dpp[j],m);
		}
	}
	for(auto i:bu[x]) {
		as[i] = 0;
		for(int j = 0;j <= m;j ++) {
			MD(as[i] += dp[ql[i]][j]*1ll*dp[qr[i]][j]%MOD);
		}
	}
	solve(x<<1,l,md); solve(x<<1|1,md+1,r);
	return ;
}
int main() {
	n = read(); m = read();
	for(int i = 1;i <= n;i ++) {
		a[i] = read();
	}
	int Q = read();
	for(int i = 1;i <= Q;i ++) {
		ql[i] = read(); qr[i] = read();
		addtree(1,ql[i],qr[i],1,n,i);
	}
	solve(1,1,n);
	for(int i = 1;i <= Q;i ++) AIput(as[i],'\n');
	return 0;
}