[线段树]Codeforces 339D Xenia and Bit Operations

Xenia and Bit Operations

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, ..., a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to calculate some value v for a.

Namely, it takes several iterations to calculate value v. At the first iteration, Xenia writes a new sequence a1 or a2, a3 or a4, ..., a2n - 1 or a2n, consisting of 2n - 1 elements. In other words, she writes down the bit-wise OR of adjacent elements of sequence a. At the second iteration, Xenia writes the bitwise exclusive OR of adjacent elements of the sequence obtained after the first iteration. At the third iteration Xenia writes the bitwise OR of the adjacent elements of the sequence obtained after the second iteration. And so on; the operations of bitwise exclusive OR and bitwise OR alternate. In the end, she obtains a sequence consisting of one element, and that element is v.

Let's consider an example. Suppose that sequence a = (1, 2, 3, 4). Then let's write down all the transformations (1, 2, 3, 4)  →  (1 or 2 = 3, 3 or 4 = 7)  →  (3 xor 7 = 4). The result is v = 4.

You are given Xenia's initial sequence. But to calculate value v for a given sequence would be too easy, so you are given additional m queries. Each query is a pair of integers p, b. Query p, b means that you need to perform the assignment ap = b. After each query, you need to print the new value v for the new sequence a.

Input

The first line contains two integers n and m (1 ≤ n ≤ 17, 1 ≤ m ≤ 105). The next line contains 2n integers a1, a2, ..., a2n (0 ≤ ai < 230). Each of the next m lines contains queries. The i-th line contains integers pi, bi (1 ≤ pi ≤ 2n, 0 ≤ bi < 230) — the i-th query.

Output

Print m integers — the i-th integer denotes value v for sequence a after the i-th query.

Examples

input

Copy

2 4
1 6 3 5
1 4
3 4
1 2
1 2

output

Copy

1
3
3
3

Note

For more information on the bit operations, you can follow this link: http://en.wikipedia.org/wiki/Bitwise_operation

题意:

给出2的n次方个数，每次将现在这个序列中相邻的两个数运算后合并为一个数，得到一个新的序列，这个新序列的长度是上一个序列长度-1，当新序列长度为1时停止运算，奇数次操作进行OR运算，偶数次操作进行XOR运算，
现在有m个询问，每次询问会改变上一个序列中的一个值，问新序列运算后的值为多少

思路:

树上的每一层是一个新序列，从叶子节点那一层记为0，向上更新层数，每层的层数是它下面那层的层数+1
记录了层数之后就知道每一层要进行什么计算了，奇数层OR，偶数层XOR，
最后对每次询问单点修改，向上更新后输出根节点的值就可以了

 #include<bits/stdc++.h>
 using namespace std;
 const int amn=<<+;
 typedef long long ll;
 int a[amn];
 struct tree{
     ll l,r,sum,deep;
     #define ls rt<<1
     #define rs rt<<1|1
     #define trl tr[rt].l
     #define trr tr[rt].r
     #define trsum tr[rt].sum
     #define trlssum tr[ls].sum
     #define trrssum tr[rs].sum
     #define trdp tr[rt].deep
 }tr[amn];
 void push_up(int rt){
     trdp=tr[ls].deep+;     ///记录计算层数，叶子节点设为0，父节点的层数为儿子节点层数+1
     if(trdp&)              ///奇数层数OR运算，偶数层数XOR运算
         trsum=trlssum|trrssum;
     else
         trsum=trlssum^trrssum;
 }
 void build(int rt,int l,int r){
     trl=l,trr=r;
     if(trl==trr){
         trsum=a[l];
         trdp=;             ///叶子节点计算层数
         return ;
     }
     int mid=(l+r)>>;
     build(ls,l,mid);
     build(rs,mid+,r);
     push_up(rt);
 }
 void updata(int rt,int l,int r,int pos,ll val){
     int mid=(l+r)>>;
     if(trl==trr&&trl==pos){
         trsum=val;
         return;
     }
     if(pos<=mid)updata(ls,l,mid,pos,val);
     else updata(rs,mid+,r,pos,val);
     push_up(rt);
 }
 int main(){
     int n,m,p,b;
     ios::sync_with_stdio();
     cin>>n>>m;
     int len=<<n;           ///注意这里长度为2的n次方
     for(int i=;i<=len;i++)
         cin>>a[i];
     build(,,len);
     while(m--){
         cin>>p>>b;
         updata(,,len,p,b);
         printf("%d\n",tr[].sum);
     }
 }
 /***
 给出2的n次方个数，每次将现在这个序列中相邻的两个数运算后合并为一个数，得到一个新的序列，这个新序列的长度是上一个序列长度-1，当新序列长度为1时停止运算，奇数次操作进行OR运算，偶数次操作进行XOR运算，
 现在有m个询问，每次询问会改变上一个序列中的一个值，问新序列运算后的值为多少
 在纸上模拟可以看出这是一个完全二叉树的结构，单点修改，向上更新数值，可以想到用线段树来维护
 树上的每一层是一个新序列，从叶子节点那一层记为0，向上更新层数，每层的层数是它下面那层的层数+1
 记录了层数之后就知道每一层要进行什么计算了，奇数层OR，偶数层XOR，
 最后对每次询问单点修改，向上更新后输出根节点的值就可以了
 ***/