【题解】FJOI2015火星商店问题

　　好几天之前做的题目了，一直想写一下博客也没腾出时间来，今天赶紧把坑给填上呼呼呼~

　　这道题首先如果只考虑每个商店中没有时间限制的物品时，我们只需要使用一棵可持久化trie树来维护区间内的异或最大值即可，这样我们可以把两部分的问题分离开来。

　　之后我们再考虑有时间限制与编号限制的情况下，该怎样做？无脑做法线段树套trie，直接在对应的区间trie树上贪心，如果该条边的最后更新时间在允许的范围内，说明可以走这条边。虽然这样也可以卡过去（主要在于卡空间），但我们来介绍一种更加妙妙的线段树分治做法。其实我感觉在这题的体现上就是离线版树套树？机房大佬貌似不认可，但我确实是这样觉得哒。

　　我们考虑在线椴树上的一次区间查询，实际上是将查询的区间分成了log个已经处理好的小区间，分别查询之后再合并达到最终的答案。那么我们可以模拟这个在线段树上分裂区间的操作：

　　1.如果当前处理的区间（l,r）完全包含于询问区间，我们将这个询问的区间在这一层进行处理。（这样的询问均不再下传，跳过后续步骤）

　　2.如果询问的区间有涉及（l,mid）的范围，递归左区间处理。

　　3.如果询问的区间有涉及（mid+1,r）的范围，递归右区间处理。

　　（本题分治的区间表示时间的范围，可持久化trie负责处理编号的限制）。

　　这样的复杂度是多少？我们可以分处理trie树与查询的两个方面来分析。处理trie树时，我们插入一个值是log的复杂度，而包含一个修改的总分治区间数也是log个，所以是\(O(nlog^{2}n)\)的复杂度。查询也是log的复杂度，一个查询最多被分别查询 log 次。所以复杂度依然是 \(O(nlog^{2}n)\) 的。

#include <bits/stdc++.h>
using namespace std;
#define maxn 1000000
int n, m, sz, qt, nt, tot, cnt, timer;
int ans[maxn], sum[maxn * ], id[maxn], q[maxn];
int bit[], ch[maxn * ][], num[maxn], root[maxn];
 
int read()
{
    int x = , k = ;
    char c; c = getchar();
    while(c < '' || c > '') { if(c == '-') k = -; c = getchar(); }
    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
    return x * k;
}
 
struct ques
{
    int l, r, s, t, x;
}Q[maxn];
 
struct modify
{
    int id, val, t;
    friend bool operator <(const modify& a, const modify& b)
    { return a.id < b.id; }
}P[maxn], ql[maxn], qr[maxn];
 
void Ins(int now, int last, int x, int val)
{
    if(x < ) return;
    bool t = (bit[x] & val);
    ch[now][!t] = ch[last][!t]; ch[now][t] = ++ sz;
    sum[ch[now][t]] = sum[ch[last][t]] + ;
    Ins(ch[now][t], ch[last][t], x - , val);
}
 
int Query(int l, int r, int x, int val)
{
    if(l > r || x < ) return ;
    int ans = ; bool t = val & bit[x];
    if(sum[ch[r][!t]] - sum[ch[l][!t]])
        ans = (bit[x] + Query(ch[l][!t], ch[r][!t], x - , val));
    else ans = Query(ch[l][t], ch[r][t], x - , val);
    return ans;
}
 
int Check(int v)
{
    int l = , r = nt, ret = ;
    while(l <= r)
    {
        int mid = (l + r) >> ;
        if(num[mid] <= v) ret = mid, l = mid + ;
        else r = mid - ;
    }
    return ret;
}
 
void Work(int l, int r)
{
    sz = , nt = ;
    for(int i = l; i <= r; i ++)
    {
        nt ++; root[nt] = ++ sz;
        Ins(root[nt], root[nt - ], , P[i].val);
        num[nt] = P[i].id;
    }
    for(int i = ; i <= qt; i ++)
    {
        int l = Check(Q[q[i]].l - ), r = Check(Q[q[i]].r);
        ans[q[i]] = max(ans[q[i]], Query(root[l], root[r], , Q[q[i]].x));
    }
}
 
void Divide(int l, int r, int L, int R, int pres)
{
    if(l > r || !pres) return;
    int mid = (L + R) >> ; qt = ;
    for(int i = ; i <= pres; i ++)
        if(Q[id[i]].s <= L && R <= Q[id[i]].t) q[++ qt] = id[i];
    Work(l, r); if(L == R) return;
    int ll = , rr = ;
    for(int i = l; i <= r; i ++)
    {
        if(P[i].t <= mid) ql[++ ll] = P[i];
        else qr[++ rr] = P[i];
    }
    for(int i = ; i <= ll; i ++) P[i + l - ] = ql[i];
    for(int i = ; i <= rr; i ++) P[i + l + ll - ] = qr[i]; 
 
    int ind = ;
    for(int i = ; i <= pres; i ++)
    {
        if(Q[id[i]].s <= L && R <= Q[id[i]].t) continue;
        if(Q[id[i]].s <= mid) swap(id[i], id[++ ind]);
    }
    Divide(l, l + ll - , L, mid, ind);
    ind = ;
    for(int i = ; i <= pres; i ++)
    {
        if(Q[id[i]].s <= L && R <= Q[id[i]].t) continue;
        if(Q[id[i]].t > mid) swap(id[i], id[++ ind]);
    }
    Divide(l + ll, r, mid + , R, ind);
}
 
int main()
{
    bit[] = ; for(int i = ; i <= ; i ++) bit[i] = bit[i - ] << ;
    n = read(), m = read();
    for(int i = ; i <= n; i ++) root[i] = ++ sz, Ins(root[i], root[i - ], , read());
    for(int i = ; i <= m; i ++)
    {
        int opt = read();
        if(!opt)
        {
            ++ timer; P[++ tot].id = read();
            P[tot].val = read(); P[tot].t = timer;
        }
        else
        {
            Q[++ cnt].l = read(); Q[cnt].r = read();
            Q[cnt].x = read(); int d = read();
            Q[cnt].s = max(timer - d, ) + ; Q[cnt].t = timer;
            ans[cnt] = Query(root[Q[cnt].l - ], root[Q[cnt].r], , Q[cnt].x);
        }
    }
    sort(P + , P +  + tot);
    for(int i = ; i <= cnt; i ++) id[i] = i;
    Divide(, tot, , timer, cnt);
    for(int i = ; i <= cnt; i ++) printf("%d\n", ans[i]);
    return ;
}