Codeforces Round #365 (Div. 2) D 线段树+离线 (区间内的数有哪些

链接：戳这里

D. Mishka and Interesting sum

time limit per test3.5 seconds

memory limit per test256 megabytes

inputstandard input

outputstandard 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:

Two integers l and r (1 ≤ l ≤ r ≤ n) are specified — bounds of query segment.
Integers, presented in array segment [l,  r] (in sequence of integers al, al + 1, ..., ar) even number of times, are written down.
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 .

题意：

长度为n的正整数序列，q个询问[l,r]。输出区间[l,r]内出现偶数次数的数的抑或和

思路：

区间抑或和可以筛出区间出现奇数个数的抑或总和   如1 2 3 1 3  区间[1,5]抑或和为 2

然后再处理一下区间里面出现的数有哪些，现在发现是1 2 3 ，在抑或一下区间[1,5]抑或和 则为 1^2^3^2=1^3=2 

区间抑或和弄个前缀数组，统计区间出现哪些数且快速算出这些数抑或和，用线段树

离线处理q个询问的[l,r]，关键字按r小的排序，r相等l小的排序

线段树存储的是区间出现的数的抑或和，当前询问为[l,r]，map记录上一个r出现的位置

假设当前r之前没有出现过，线段树插入这个数的值

当之前出现过，那么再在出现的过位置插入这个数值，显然抑或操作会将这个数消除，然后再当前位置插入这个数

对于当前这组[l,r]，询问当前线段树里面[l,r]的出现的数的抑或和

那么还有一些位置是没有出现r也就是没有更新到，直接while跟上就可以了，同理出现的数再在之前位置插一次.....

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<iomanip>
#include<cmath>
#include<bitset>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef long double ld;
#define INF (1ll<<60)-1
#define Max 1e9
using namespace std;
struct node{
    int l,r,id;
    bool operator < (const node &a)const{
        if(r==a.r) return l<a.l;
        return r<a.r;
    }
}s[1000100];
ll anw[1000100];
int n,q;
ll a[1000100];
map<ll,int> mp;
ll tr[4000100];
void build(int root,int l,int r){
    if(l==r){
        tr[root]=0LL;
        return ;
    }
    int mid=(l+r)/2;
    build(root*2,l,mid);
    build(root*2+1,mid+1,r);
    tr[root]=tr[root*2]^tr[root*2+1];
}
void update(int root,int l,int r,int x,ll v){
    if(x==l && r==x){
        tr[root]=tr[root]^v;
        return ;
    }
    int mid=(l+r)/2;
    if(x<=mid) update(root*2,l,mid,x,v);
    else update(root*2+1,mid+1,r,x,v);
    tr[root]=tr[root*2]^tr[root*2+1];
}
ll query(int root,int l,int r,int x,int y){
    if(x<=l && y>=r){
        return tr[root];
    }
    int mid=(l+r)/2;
    if(y<=mid) return query(root*2,l,mid,x,y);
    else if(x>mid) return query(root*2+1,mid+1,r,x,y);
    else {
        return query(root*2,l,mid,x,mid)^query(root*2+1,mid+1,r,mid+1,y);
    }
}
ll sum[1000100];
int main(){
    scanf("%d",&n);
    sum[0]=0LL;
    for(int i=1;i<=n;i++) {
        scanf("%I64d",&a[i]);
        sum[i]=sum[i-1]^a[i];
    }
    scanf("%d",&q);
    for(int i=1;i<=q;i++){
        scanf("%d%d",&s[i].l,&s[i].r);
        s[i].id=i;
    }
    build(1,1,n);
    sort(s+1,s+q+1);
    int R=1;
    for(int i=1;i<=q;i++){
        int l=s[i].l,r=s[i].r;
        while(R<r) {
            if(mp[a[R]]==0) update(1,1,n,R,a[R]);
            else {
                int pos=mp[a[R]];
                update(1,1,n,pos,a[R]);
                update(1,1,n,R,a[R]);
            }
            mp[a[R]]=R;
            R++;
        }
        R=r+1;
        if(mp[a[r]]==0){
            mp[a[r]]=r;
            update(1,1,n,r,a[r]);
        } else {
            int x=mp[a[r]];
            update(1,1,n,x,a[r]);
            mp[a[r]]=r;
            update(1,1,n,r,a[r]);
        }
        anw[s[i].id]=query(1,1,n,l,r);
        ll ans=sum[r]^sum[l-1];
        anw[s[i].id]=anw[s[i].id]^ans;
    }
    for(int i=1;i<=q;i++) printf("%I64d\n",anw[i]);
    return 0;
}