bzoj-2743 采花

题意：

给出一个长度为n的序列，m次查询区间[l,r]中出现两次的数的种类数；

n,m<=1000000；

题解：

一开始看出来数据范围。。少看一个0；

于是写了一发莫队，O(n√n)直接TLE掉；

这题正解当然是O(nlogn)的算法咯，和HH的项链那道题的思想确实很相似；

我们记录与第i个数相同的最后一个数下标为pre[i]；

将询问离线，按r端点排序，每扫到一个点i就回答r端点为i的所有询问；

扫过i时，我们在树状数组中将pre[i]的值+1，pre[pre[i]]的值-1；

这时，对于一个区间[l,r]来说，直接查询[l,r]的区间和吗是答案咯；

并不需要区间+1什么的操作呢，况且树状数组维护那东西我又不会= =；

时间复杂度O(nlogn)，代码复杂度也是很低的；

代码：

#include<cctype>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 1000010
#define LEN 1<<16
using namespace std;
struct node
{
	int l,r,no;
	friend bool operator<(node a,node b)
	{
		return a.r<b.r;
	} 
}Q[N];
int a[N],pre[N],last[N],sum[N],ans[N],n;
char getc()
{
    static char *S,*T,buf[LEN];
    if(S==T)
    {
        T=(S=buf)+fread(buf,1,LEN,stdin);
        if(S==T)
            return EOF;
    }
    return *S++;
}
int read()
{
    static char ch;
    static int D;
    while(!isdigit(ch=getc()));
    for(D=ch-'0';isdigit(ch=getc());)
        D=D*10+ch-'0';
    return D;
}
int lowbit(int x)
{
	return x&(-x);
}
void update(int x,int val)
{
	if(!x)	return ;
	while(x<=n)
	{
		sum[x]+=val;
		x+=lowbit(x);
	}
}
int query(int x)
{
	int ret=0;
	while(x)
	{
		ret+=sum[x];
		x-=lowbit(x);
	}
	return ret;
}
int main()
{
	int c,m,i,j,k,l,r;
	n=read(),c=read(),m=read();
	for(i=1;i<=n;i++)
		a[i]=read(),pre[i]=last[a[i]],last[a[i]]=i;
	for(i=1;i<=m;i++)
	{
		Q[i].l=read(),Q[i].r=read();
		Q[i].no=i;
	}
	sort(Q+1,Q+m+1);
	for(i=1,j=1;i<=n;i++)
	{
		update(pre[i],1);
		update(pre[pre[i]],-1);
		while(j<=m&&Q[j].r==i)
		{
			ans[Q[j].no]=query(i)-query(Q[j].l-1);
			j++;	
		}
	}
	for(i=1;i<=m;i++)
		printf("%d\n",ans[i]);
	return 0;
}