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[N][N],s[N],v[N],n,m,q;
vector<int> G[N];
bool ask[N][N]={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]]);
}