P4585(火星商店问题 线段树分治(将询问分到时间线段树里) 可持久化trie)

题目

每次询问是有一个时间段[t1,t2]限制，将这个限制插入到线段树里。由于可持久化trie建树时，需要离散坐标，要先对所有修改按位置从小到大排序。这样左边修改的时间可能>mid，右边可以<=mid，就乱了，所以我们每次分治前将修改的时间<=mid的放在分治的左边。这个题是问的挑一个数与他异或最大 可以多次更新答案。（不像并查集+线段树分治那样，要这个时间之前的整个状态。）

//本题是只要有修改才代表新的一天开始.
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=1e5+5,Maxbit=16;
int t[N*60][2],Sz[N*60],root[N],sz;
void build(int &x,int y,int val){
    int now=x;now=x=++sz;
    for(int i=Maxbit;i>=0;--i){
        int c=((val>>i)&1);
        t[now][c^1]=t[y][c^1],t[now][c]=++sz;
        now=t[now][c],y=t[y][c],Sz[now]=Sz[y]+1;
    }
}
int query(int x,int y,int val){
    int res=0;
    for(int i=Maxbit;i>=0;--i){
        int c=((val>>i)&1);
        if(Sz[t[y][c^1]]-Sz[t[x][c^1]]>0)//取相反的位
            res+=(1<<i),x=t[x][c^1],y=t[y][c^1];
        else x=t[x][c],y=t[y][c];
    }
    return res;
}
vector<int>vec[N];
void ins(int id,int cl,int cr,int l,int r,int pos){
    if(cl>cr) return;
    if(cl<=l&&r<=cr){vec[pos].push_back(id);return;}
    int mid=(l+r)>>1;
    if(cl<=mid) ins(id,cl,cr,l,mid,pos<<1);
    if(cr>mid) ins(id,cl,cr,mid+1,r,pos<<1|1);
}
struct Update{int pos,val,tim;}u[N],tmp1[N],tmp2[N];
inline int cmp(Update x,Update y){return x.pos<y.pos;}
struct Query{int l,r,t1,t2,val;}q[N];
int refl[N],ans[N];
void divide(int cl,int cr,int l,int r,int pos){
    if(cl>cr) return;
    if(vec[pos].size()){//vec里面放的询问都包括在[l,r]时间存活的值(只是包括 还会包括其他的 被分散到时间线段树里了)
        sz=0;int tot=0;//可持久化trie只需要sz=0即可 因为没意依赖root[0]这个空树建树
        for(int i=cl;i<=cr;++i){//将[cl,cr]的修改都做了 即该添加什么就添加进去
            refl[++tot]=u[i].pos;
            build(root[tot],root[tot-1],u[i].val);
        }
        for(int i=0;i<vec[pos].size();++i){//更新一下里面的询问
            int id=vec[pos][i],ll,rr;
            ll=lower_bound(refl+1,refl+tot+1,q[id].l)-refl;//玄学离散化 我不懂呜呜呜
            rr=lower_bound(refl+1,refl+tot+1,q[id].r+1)-refl-1;
            ans[id]=max(ans[id],query(root[ll-1],root[rr],q[id].val));
        }
    }
    if(l==r) return;
    int num1=0,num2=0,mid=(l+r)>>1;
    for(int i=cl;i<=cr;++i){
        if(u[i].tim<=mid) tmp1[++num1]=u[i];//修改时间在[l,mid]的放在左边
        else tmp2[++num2]=u[i];//修改时间在[mid+1,r]的放在右边
    }
    for(int i=1;i<=num1;++i) u[cl+i-1]=tmp1[i];
    for(int i=1;i<=num2;++i) u[cl+num1+i-1]=tmp2[i];
    divide(cl,cl+num1-1,l,mid,pos<<1);//u[i](i属于[cl,cr])的修改时间一定在[cl,cr]之间 但不是时间有序 只是满足这条件
    divide(cl+num1,cr,mid+1,r,pos<<1|1);
}
int main(){
    int n,m;scanf("%d%d",&n,&m);
    for(int i=1,x;i<=n;++i)
        scanf("%d",&x),build(root[i],root[i-1],x);//build可持久化trie
    int tim=0,cnt=0;
    for(int i=1;i<=m;++i){
        int f;scanf("%d",&f);
        if(!f){
            int s,v;scanf("%d%d",&s,&v);
            u[++tim]=(Update){s,v,tim};//位置在tim时刻添加v这个值
        }else{
            int l,r,x,d;scanf("%d%d%d%d",&l,&r,&x,&d);
            ans[++cnt]=query(root[l-1],root[r],x);//还没添加时[l,r]中与x异或最大的 更新答案
            q[cnt]=(Query){l,r,max(1,tim-d+1),tim,x};//查询的区间是[l,r] 时间区间是[max(1,tim-d+1),tim]; 查询与x异或最大得到的值
        }
    }
    for(int i=1;i<=cnt;++i) ins(i,q[i].t1,q[i].t2,1,tim,1);//以[1,tim](只与修改有关)建立时间线段树 将查询得时间区间插到时间线段树里
    sort(u+1,u+tim+1,cmp);//按 修改的位置排序 因为我们不是建树 查询用到可持久化trie嘛 它与pos的区间有关 要离散化.
    divide(1,tim,1,tim,1);//注意按pos排过序了。。。  只不过[1,tim]区间一定满足 里面的u[i].tim在[1,tim]之间...
    for(int i=1;i<=cnt;++i) printf("%d\n",ans[i]);
}