Jzoj5428 查询

给出一个长度为n的序列a[]

给出q组询问，每组询问形如<x,y>，求a序列的所有区间中，数字x的出现次数与数字y的出现次数相同的区间有多少个

对于100%的数据，1<=n<=8000,1<=q<=500000，1<=x,y,a[i]<=10^9

这题十分的鬼畜

我们考虑预先处理处答案，将序列离散化

让后对于每个值开一个链表记录其在数组中出现的位置

每次考虑询问i,j，我们将一个位置p的‘差分值‘定义为p前i的个数-p前j的个数

显然，任意两个‘差分值’相同的位置组成的区间一定是合法区间

那么我们对于i,j出现的位置逐个考虑，求出每种差分值各有多少个格子

这样就可以求出一组答案

又因为，链表的节点总数为n，而且每个值只会和n-1个其他值匹配，所以复杂度为O(n^2)

写的时候各种优化就怕过不了结果只跑了500+ms还是不错的

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
#define N 8010
using namespace std;
int f

,s
,v
,n,m,q;
vector<int> G
;
bool ask

={0};
int A[500010],B[500010];
inline int rd(int& X){
char ch=X=0;
for(;ch<'0' || ch>'9';ch=getchar());
for(;ch>='0'&&ch<='9';ch=getchar()) X=(X<<3)+(X<<1)+ch-'0';
return X;
}
int main(){
freopen("query.in","r",stdin);
freopen("query.out","w",stdout);
rd(n); rd(q);
for(int i=1;i<=n;++i) rd(s[i]);
memcpy(v,s,sizeof v);
sort(v+1,v+1+n); m=unique(v+1,v+1+n)-v-1;
for(int i=1;i<=n;++i){
s[i]=lower_bound(v+1,v+1+m,s[i])-v;
G[s[i]].push_back(i);
}
for(int i=m;~i;--i) G[i].push_back(n+1);
for(int i,j,x,y,k=1;k<=q;++k){
rd(x); rd(y);
i=lower_bound(v+1,v+1+m,x)-v;
if(v[i]!=x) i=0;
j=lower_bound(v+1,v+1+m,y)-v;
if(v[j]!=y) j=0;
if(i>j) swap(i,j);
A[k]=i; B[k]=j;
ask[i][j]=1;
}
for(int i=0;i<=m;++i)
for(int j=i;j<=m;++j)
if(ask[i][j]){
int c[16000]={0};
register int p=0,q,now=8000,d;
for(register int h1=0,h2=0;;){
if(G[i][h1]==n+1 && G[j][h2]==n+1){
d=n+1-p;
f[i][j]+=(d*(d-1)>>1)+d*c[now];
break;
}
if(G[i][h1]<G[j][h2]){
d=(q=G[i][h1])-p;
f[i][j]+=(d*(d-1)>>1)+d*c[now];
c[now]+=d; ++now; p=q; ++h1;
} else {
d=(q=G[j][h2])-p;
f[i][j]+=(d*(d-1)>>1)+d*c[now];
c[now]+=d; --now; p=q; ++h2;
}
}
}
for(int i=1;i<=q;++i) printf("%d\n",f[A[i]][B[i]]);
}