Trie树

T1 BD

通过Trie树来优化的DP。
首先得出状态转移方程为
$DP_i=max(DP_j)+1 \ (i-j \lt L S_i \bigoplus S_j \le X)$
以每个位置的$S_i$作为插入Trie树时的键值，记录当前的位置，
对Trie树的每一个节点维护一个单调队列可以实现$O(logA_i)$的查询。
查询时，以X的每一位作优先级来选择查询的儿子。

Code

#include<bits/stdc++.h>
using namespace std;

#define Komachi is retarded
#define REP(i,a,b) for(int i=(a),i##_end_=(b);i<i##_end_;i++)
#define DREP(i,a,b) for(int i=(a),i##_end_=(b);i>i##_end_;i--)
#define M 100004
#define K 30
#define MK 3100004

inline void chkmax(int &a,const int &b){if(a<b)a=b;}
int T,N,X,L,P,Q,A[M];
int DP[M];
struct Trie{
    int Next[MK][2],Cnt[MK],L[MK],R[MK],From[MK],sz,tot;
    bool Clear(){Next[0][0]=Next[0][1]=sz=tot=0;}
    void Init(int x){
        int p=0;
        DREP(i,K-1,-1){
            int &nt=Next[p][x>>i&1];
            if(!nt)nt=++sz,Next[sz][0]=Next[sz][1]=Cnt[sz]=0;
            Cnt[p=nt]++;
        }
    }
    void Build(){
        REP(i,0,sz+1)
            L[i]=tot,R[i]=tot-1,tot+=Cnt[i]+1;
    }
    int Front(int A,int Limit){
        while(L[A]<=R[A] && (From[L[A]]<Limit))L[A]++;
        return L[A]<=R[A]?DP[From[L[A]]]:-1;
    }
    int Push(int A,int x){
        while(L[A]<=R[A] && DP[From[R[A]]]<DP[x])R[A]--;
        From[++R[A]]=x;
    }
    int Query(int q,int Limit){
        int p=0,Ans=-1;
        DREP(i,K-1,-1){
            int t=q>>i&1;
            if(X>>i&1)chkmax(Ans,Front(Next[p][t],Limit)),p=Next[p][!t];
            else p=Next[p][t];
            if(p==0)break;
        }
        chkmax(Ans,Front(p,Limit));
        return Ans;
    }
    void Insert(int x){
        int p=0;
        DREP(i,K-1,-1)
            p=Next[p][A[x]>>i&1],Push(p,x);
    }
}Trie;
int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d%d%d",&N,&X,&L);
        scanf("%d%d%d",&A[1],&P,&Q);

        REP(i,2,N+1)A[i]=(1ll*A[i-1]*P+Q)&268435455;

        REP(i,2,N+1)A[i]^=A[i-1];

        Trie.Clear();
        REP(i,0,N+1)Trie.Init(A[i]);
        Trie.Build();

        Trie.Insert(0);
        memset(DP,0,sizeof(DP));
        REP(i,1,N+1){
            DP[i]=Trie.Query(A[i],i-L)+1;
            if(DP[i])Trie.Insert(i);
        }
        printf("%d\n",DP[N]);
    }
    return 0;
}

T2 XOR

和上一题类似。
不过因为一些特性，可以用奇怪的方法写出来。
先二分答案X，按类似上面的思路来转移。
这里可以把前缀去掉，改为每次向Trie树中异或一个值进去。
查询的时候找到最大值与X比较即可。

Code

#include<bits/stdc++.h>
using namespace std;

#define Komachi is retarded
#define REP(i,a,b) for(int i=(a),i##_end_=(b);i<i##_end_;i++)
#define DREP(i,a,b) for(int i=(a),i##_end_=(b);i>i##_end_;i--)
#define M 10004
#define K 32

int n,m,l,T,A[M];
bool DP[2][M];
struct Trie{
    int Next[M*(K+1)][2],Pass[M*(K+1)],sz;
    bool Kp[K+4];
    void Clear(){memset(Kp,Next[0][0]=Next[0][1]=sz=0,sizeof(Kp));Pass[0]=-M;}
    void Add(int x){
        int p=0;
        DREP(i,K-1,-1){
            int &nt=Next[p][0^Kp[i]];
            if(!nt)nt=++sz,Next[nt][0]=Next[nt][1]=0;
            Pass[p=nt]=x==0?1:x;
        }
    }
    void Updata(int x){
        REP(i,0,K)Kp[i]^=x>>i&1;
    }
    int Query(int Limit,int q){
        int p=0,Res=0;
        DREP(i,K-1,-1){
            int t=!((q>>i&1)^Kp[i]);
            if(Pass[Next[p][t]]>Limit)
                p=Next[p][t],Res|=1<<i;
            else if(Pass[Next[p][!t]]>Limit)
                p=Next[p][!t];
            else return -1;
        }
        return Res;
    }
}Trie;
bool Check(int Mid){
    bool f=0;
    memset(DP,0,sizeof(DP));
    REP(j,0,m){
        Trie.Clear();
        if(j==0)Trie.Add(0);
        memset(DP[!f],0,sizeof(DP[!f]));

        REP(i,1,n+1){
            DP[!f][i+1]=(Trie.Query(i-l,A[i])>=Mid) || (DP[f][i] && A[i]>=Mid);
            if(DP[f][i])Trie.Add(i);
            Trie.Updata(A[i]);
        }
        f^=1;
    }
    return DP[f][n+1];
}
int main(){
    scanf("%d",&T);
    REP(Case,1,T+1){
        scanf("%d%d%d",&n,&m,&l);
        REP(i,1,n+1)scanf("%d",&A[i]);

        int L=0,R=1<<30,Ans=-1;
        while(L<=R){
            int Mid=L+R>>1;
            if(Check(Mid))Ans=Mid,L=Mid+1;
            else R=Mid-1;
        }
        printf("Case #%d:\n%d\n",Case,Ans);
    }
    return 0;
}

T3 AB

维护在一个可重数集内，
选定一个数后选另一个数得到的最小值最大。
可以发现选定一个数后，第一个最小值一定是在它与Trie树的第一个能找到其他数的节点向下查询得到的。
利用这个东西来进行Trie树上的DP和更新即可。
DSU或直接合并都可以完成。

Code

#include<bits/stdc++.h>
using namespace std;

#define Komachi is retarded
#define REP(i,a,b) for(int i=(a),i##_end_=(b);i<i##_end_;i++)
#define DREP(i,a,b) for(int i=(a),i##_end_=(b);i>i##_end_;i--)
#define LREP(i,A) for(int i=Head[A];i;i=Next[i])
#define M 100004
#define K 20

void chkmax(int &a,const int &b){if(a<b)a=b;}
void chkmin(int &a,const int &b){if(a>b)a=b;}

int T,n,m,Ans[M],Val[M];
int Next[M<<1],Head[M],V[M<<1],tot;
void Add_Edge(int u,int v){
    Next[++tot]=Head[u],V[Head[u]=tot]=v;
}
struct Trie{
    int Next[M*K][2],Num[M*K],F[M*K],sz;
    int Cnt[M*K];

    bool Clear(){sz=Next[0][0]=Next[0][1]=F[0]=0;}

    int NewNode(){
        int p=++sz;
        F[p]=Num[p]=Cnt[p]=Next[p][0]=Next[p][1]=0;
        return p;
    }

    int Query(int p,int x,int d){
        DREP(i,d-1,-1){
            int t=(x>>i)&1,nt=Next[p][t];
            if(nt)p=nt;
            else p=Next[p][!t];
        }
        return Num[p];
    }

    int Tmp[K+4],len;
    void Add(int x){
        int p=0;
        len=0;

        DREP(i,K-1,-1){
            int &nt=Next[p][(x>>i)&1];
            if(!nt)nt=NewNode();
            Tmp[len++]=p;
            p=nt,Cnt[p]++;
        }
        if(Cnt[p]==1)F[p]=Num[p]=x;
        else F[p]=0;

        DREP(i,len-1,-1){
            int A=Tmp[i],l=Next[A][0],r=Next[A][1];
            if(!Cnt[l]||!Cnt[r])
                F[A]=Cnt[l]?F[l]:F[r];
            else if(Cnt[l]>1&&Cnt[r]>1)
                F[A]=max(F[l],F[r]);
            else if(Cnt[l]==1&&Cnt[r]==1)
                F[A]=F[l]^F[r];
            else {
                if(Cnt[l]!=1)swap(l,r);
                F[A]=F[l]^Query(r,F[l],K-i-1);
            }
        }
    }
}Trie;

int Sz[M],Son[M],DFN[M],Ed[M],ID[M],dfn;
void Get(int A,int f){
    int B;
    DFN[A]=++dfn;
    ID[dfn]=A;
    Sz[A]=1;
    Son[A]=0;
    LREP(i,A)if((B=V[i])!=f){
        Get(B,A);
        Sz[A]+=Sz[B];
        if(Sz[B]>Sz[Son[A]])Son[A]=B;
    }
    Ed[A]=dfn;
}
void Answer(int A,int f){
    int B;
    LREP(i,A)if((B=V[i])!=f && B!=Son[A]){
        Answer(B,A);
        Trie.Clear();
    }
    if(Son[A])Answer(Son[A],A);

    LREP(i,A)if((B=V[i])!=f && B!=Son[A])
        REP(j,DFN[B],Ed[B]+1)Trie.Add(Val[ID[j]]);

    Trie.Add(Val[A]);

    Ans[A]=Sz[A]==1?-1:Trie.F[0];
}

int main(){
    scanf("%d",&T);
    REP(Case,1,T+1){
        scanf("%d",&n);

        Trie.Clear();
        REP(i,1,n+1)Head[i]=0;
        tot=dfn=0;

        REP(i,1,n+1)scanf("%d",&Val[i]);
        REP(i,1,n){
            int u,v;
            scanf("%d%d",&u,&v);
            Add_Edge(u,v);
            Add_Edge(v,u);
        }

        Get(1,0);
        Answer(1,0);

        scanf("%d",&m);
        printf("Case #%d:\n",Case);
        while(m--){
            int u;
            scanf("%d",&u);
            printf("%d\n",Ans[u]);
        }
    }
    return 0;
}