hdu5919：Sequence II（可持久化线段树）

题目传送门：http://acm.hdu.edu.cn/showproblem.php?pid=5919

题目大意：给出一个拥有不超过2*10^5个元素的序列，再给出2*10^5个询问，对于每一个询问[L,R]，我们假设区间内有k个不同的数，他们在这个区间内第一次出现的位置分别为p1,p2,p3……pk，排序后输出第(k/2向上取整)个数。本题采用强制在线。

如原序列为：1 1 2 3 3，询问区间为[2,5]。

我们发现区间内有3个不同的数，他们在区间内第一次出现的位置为：

1 2

2 3

3 4（这里的位置是指在原序列中的位置）

于是输出3

分析：本题实乃千古好题。我们先来考虑一个简化版的问题：假设没有强制在线，我们要求一个区间有多少个不同的数，该怎么做？

这个问题有很多种做法，其中一种做法是，我们把询问[L,R]插入R的邻接链表中，然后我们维护两个数组。

例如原序列是1 1 2 2 3 4

我们从左往右做，假设我们做到第四个元素，我们在数组a的第四个位置+1，然后我们发现原序列的第四个元素是2，我们将上一个2的位置（即a[3]）-1。至于我们如何知道上一个2的位置，我们可以维护另一个下标数组b实现。

然后我们处理每一个R=4的询问，答案即为a[L]~a[R]的和，我们将数组a改成线段树即可快速求和。

我们回顾一下为什么这种方法是对的。当我们做到R的时候，对于[1，R]中的每一个不同的数，我们都只保留了他们的最后一个，而我们查询的时候右端点固定在了R，于是不可能出现两个相同的数，只查询到左边的a[l]=0，不查询到右边a[r]=1的情况。

我们再来回顾一下这题，对于每一个询问，我们要保留的是区间中每个数的第一个，于是我们从后往前做，做到L的时候我们查询[L,R]的和，然后再用一次二叉查找找到中间那个数的位置。至于强制在线，用可持久化即可。

CODE:

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=200010;
const int lg=35;

struct Tnode
{
	int sum;
	Tnode *lson,*rson;
} tree[maxn*lg];
Tnode *Root[maxn];
int cur;

int Next[maxn];
int a[maxn];
int t,n,m;

Tnode *New_node()
{
	tree[ ++cur ].sum=0;
	tree[cur].lson=tree[cur].rson=tree;
	return tree+cur;
}

void Update(Tnode *root,int L,int R,int x,int v)
{
	if ( x<L || R<x ) return;
	if ( L==x && x==R )
	{
		root->sum+=v;
		return;
	}
	
	int mid=(L+R)>>1;
	
	Tnode *y=New_node();
	if (x<=mid)
	{
		*y=*(root->lson);
		root->lson=y;
		Update(root->lson,L,mid,x,v);
	}
	else
	{
		*y=*(root->rson);
		root->rson=y;
		Update(root->rson,mid+1,R,x,v);
	}
	
	root->sum=root->lson->sum+root->rson->sum;
}

int Query(Tnode *root,int L,int R,int x,int y)
{
	if ( y<L || R<x ) return 0;
	if ( x<=L && R<=y ) return root->sum;
	
	int mid=(L+R)>>1;
	
	int vl=Query(root->lson,L,mid,x,y);
	int vr=Query(root->rson,mid+1,R,x,y);
	
	return vl+vr;
}

int Get(Tnode *root,int L,int R,int rank)
{
	if (L==R) return L;
	int left_sum=root->lson->sum;
	int mid=(L+R)>>1;
	if (rank<=left_sum) return Get(root->lson,L,mid,rank);
	else return Get(root->rson,mid+1,R,rank-left_sum);
}

int main()
{
	freopen("c.in","r",stdin);
	freopen("c.out","w",stdout);
	
	scanf("%d",&t);
	for (int q=1; q<=t; q++)
	{
		printf("Case #%d:",q);
		
		scanf("%d%d",&n,&m);
		for (int i=1; i<=n; i++) scanf("%d",&a[i]);
		
		cur=-1;
		Root[n+1]=New_node();
		memset(Next,0,sizeof(Next));
		for (int i=n; i>=1; i--)
		{
			Root[i]=New_node();
			*Root[i]=*Root[i+1];
			if (Next[ a[i] ])
			{
				Update(Root[i],1,n,Next[ a[i] ],-1);
				Tnode *x=New_node();
				*x=*Root[i];
				Root[i]=x;
			}
			Next[ a[i] ]=i;
			Update(Root[i],1,n,i,1);
		}
		
		int ans=0;
		for (int i=1; i<=m; i++)
		{
			int L,R;
			scanf("%d%d",&L,&R);
			L=(L+ans)%n+1;
			R=(R+ans)%n+1;
			if (L>R) swap(L,R);
			int k=Query(Root[L],1,n,L,R);
			k=(k+1)/2;
			ans=Get(Root[L],1,n,k);
			printf(" %d",ans);
		}
		
		printf("\n");
	}
	
	return 0;
}