Codeforces Round #365 (Div. 2) [D] Mishka and Interesting sum

Mishka and Interesting sum

time limit per test

3.5 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Little Mishka enjoys programming. Since her birthday has just passed, her friends decided to present her with array of non-negative integers a1, a2, ..., an of n elements!

Mishka loved the array and she instantly decided to determine its beauty value, but she is too little and can't process large arrays. Right because of that she invited you to visit her and asked you to process m queries.

Each query is processed in the following way:

1. Two integers l and r (1 ≤ l ≤ r ≤ n) are specified — bounds of query segment.
2. Integers, presented in array segment [l,  r] (in sequence of integers al, al + 1, ..., ar) even number of times, are written down.
3. XOR-sum of written down integers is calculated, and this value is the answer for a query. Formally, if integers written down in point 2 are x1, x2, ..., xk, then Mishka wants to know the value , where  — operator of exclusive bitwise OR.

Since only the little bears know the definition of array beauty, all you are to do is to answer each of queries presented.

Input

The first line of the input contains single integer n (1 ≤ n ≤ 1 000 000) — the number of elements in the array.

The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — array elements.

The third line of the input contains single integer m (1 ≤ m ≤ 1 000 000) — the number of queries.

Each of the next m lines describes corresponding query by a pair of integers l and r (1 ≤ l ≤ r ≤ n) — the bounds of query segment.

Output

Print m non-negative integers — the answers for the queries in the order they appear in the input.

Examples

input

3
3 7 8
1
1 3

output

0

input

7
1 2 1 3 3 2 3
5
4 7
4 5
1 3
1 7
1 5

output

0
3
1
3
2

Note

In the second sample:

There is no integers in the segment of the first query, presented even number of times in the segment — the answer is 0.

In the second query there is only integer 3 is presented even number of times — the answer is 3.

In the third query only integer 1 is written down — the answer is 1.

In the fourth query all array elements are considered. Only 1 and 2 are presented there even number of times. The answer is .

In the fifth query 1 and 3 are written down. The answer is .

题意： 求区间中出现次数为偶数次的数的异或值。

这题其实一看就知道要考线段树或者树状数组了，但是如果用裸的线段树我们很难明确要维护什么，因此进行分析:

对于一个区间内次数为偶数次数的异或值，它其实等于这个区间内所有不同的数的异或值异或上出现了奇数次的异或值，区间中出现次数为奇数次的数的异或值恰好等于区间的异或值，因此只要求区间中不同的数的异或值就能求出区间中出现次数为偶数次的数的异或值。

我的智商就只能想到这了，看了一下其他大神的解法顿时有了思路

其实将求区间中不同数的异或和求区间中不同数的个数进行类比，就可以得到一种离线的算法

把所有的询问按照右端点排序(其实左端点也可以，不过就是把last数组修改以下)对于每一个元素，如果这个元素在以前出现过，那么删除掉他以前出现的位置，把当前位置设为他最后出现的位置(last数组)。即每个数只保留最右边的一个，可以用线段树或者树状数组来单点更新每个元素，然后查询前缀异或值。

时间复杂度为(m*logn)

在前面要预处理一下a数组，将所有重复的元素删除，然后将a数组记录原来这个位置的元素在排序后的数组出现的位置，这样能够方便我们的讨论

#include<cstdio> 
#include<iostream> 
#include<algorithm> 
#define lowbit(x) x&(-x)
using namespace std; 
const int maxn=1e6+5; 
inline void _read(int &x){ 
    char t=getchar();bool sign=true; 
    while(t<'0'||t>'9') 
    {if(t=='-')sign=false;t=getchar();} 
    for(x=0;t>='0'&&t<='9';t=getchar())x=x*10+t-'0'; 
    if(!sign)x=-x; 
}
int n,m,sum[maxn],last[maxn];
int a[maxn],b[maxn],c[maxn];
struct wk{int l,r,id,ans;}q[maxn];
bool cmp1(wk x,wk y){return x.r==y.r?x.l<y.l:x.r<y.r;}
bool cmp2(wk x,wk y){return x.id<y.id;}
void modify(int x,int d){
	for(int i=x;i<=n;i+=lowbit(i))
	    c[i]^=d;
}
int getsum(int x){
	int num=0;
	for(int i=x;i;i-=lowbit(i))
	    num^=c[i];
	return num;
}
int main(){
	_read(n);
	int i,j=1;
	for(i=1;i<=n;i++){
		_read(a[i]);
		b[i]=a[i];
		sum[i]=sum[i-1]^a[i];
	}
	sort(b+1,b+1+n);
	int hs=unique(b+1,b+1+n)-(b+1);
	for(i=1;i<=n;i++)a[i]=lower_bound(b+1,b+hs,a[i])-b;
	_read(m);
	for(i=1;i<=m;i++){
		_read(q[i].l);_read(q[i].r);
		q[i].id=i;
	}
	sort(q+1,q+1+m,cmp1);
	for(i=1;i<=m;i++){
		while(j<=q[i].r){  
            if(last[a[j]])modify(last[a[j]],b[a[j]]);  
            last[a[j]]=j;  
            modify(j,b[a[j]]);  
            j++;  
        }  
		q[i].ans=getsum(q[i].l-1)^getsum(q[i].r)^sum[q[i].l-1]^sum[q[i].r];
	}
	sort(q+1,q+1+m,cmp2);
	for(i=1;i<=m;i++)
	    printf("%d\n",q[i].ans);
}