CF1902F.Trees and XOR Queries Again-点分治、线性基

link：https://codeforces.com/contest/1902/problem/F
题意：给一棵树，有点权，q次询问，每次问 $x\to y$ 的路径上是否存在一个点集的子集，使得其点权异或和恰为 $k$.
$n,q\le 2\times {10}^5,a_i,k<2^{20}$

---

异或和必然想线性基做，两个线性基合并是 $O({\log }^{2}V)$ 的。

暴力：如果用树链剖分+线段树维护线性基，复杂度会达到惊人的 $O(n{\log }^{2}n{\log }^{2}V)$.

一个简单的想法是只涉及到查询而没有修改，树链剖分里的线段树是不必要的，改成对每个点维护其到所有 $2^t$ 级祖先的线性基，再倍增地回答，这样是 $O(n\log n{\log }^{2}V)$ 左右（就默认当做 $n=q$ 了），虽然理论上还是不可过，但据说这题时限很大可以冲过去。

一个更加合理的想法：点分治，每次枚举到一个分治中心 $r$ 时，考虑所有以 $r$ 为 LCA的点对的询问，那必然是一条 $r\to x$ 的链和 $r\to y$ 的链，且两条链的交仅有 $r$ 这个点。因此处理 $r$ 到每个点的一个前缀线性基，然后dfs每个孩子的子树，再枚举这些点上的所有询问（我们提前把询问挂到 $x,y$ 上），看 $x$ 上的询问的另一个点 $y$ 是否位于 $r$ 的另一子树内，这一步可以通过dfs序实现。

对于时间复杂度来说，看起来每次枚举每个点上的询问很暴力，但由于点分治的优良特性（至多递归 $O(\log n)$ 层），因此每个询问最多也就被访问 $O(\log n)$ 次，同时处理一次询问是 $O({\log }^{2}V$) 的，每个询问也只会被处理到一次，因此这部分是 $O(q{\log }^{2}V)$ 的，点分治处理每个树链前缀的线性基是 $O(n\log V)$ 的，至多分治 $O(\log n)$ 层，所以这部分是 $O(n\log n\log V)$ 的。
整体复杂度 $O(n\log n\log V+q{\log }^{2}V+n\log n)$，大约就是log方的量级。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define endl '\n'
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
using namespace std;
typedef pair<int,int> pii;
const int N=2e5+5;
const int INF=0x3f3f3f3f;
template<class T,int MX=20>
class XorBasis{
public:
    T base[MX+1];
    void init(){rep(i,0,MX)base[i]=0;}
    void insert(T x){
        for(int i=MX;i>=0;i--)if(x>>i&1){
            if(base[i])x^=base[i];
            else{
                base[i]=x;
                return;
            }
        }
    }
    bool check(int k){
        for(int i=MX;i>=0;i--)if(k>>i&1){
            if(base[i])k^=base[i];
            else return false;
        }
        return true;
    }
};
int n,q,a[N];
vector<vector<int>> G;
vector<vector<pair<int,pii>>> Q;
int rt,sz[N],mx_rt;
int dfn[N],b[N],cnt_time,lst;
bool vis[N],ans[N];
XorBasis<int> basis[N];
void get_rt(int x,int fa,int sum){
    sz[x]=1;
    int mx=0;
    for(auto to:G[x])if(to!=fa&&!vis[to]){
        get_rt(to,x,sum);
        mx=max(mx,sz[to]);
        sz[x]+=sz[to];
    }
    mx=max(mx,sum-sz[x]);
    if(mx<mx_rt){
        rt=x;
        mx_rt=mx;
    }
 
}
void dfs(int x,int fa){
    basis[x].insert(a[x]);
    dfn[x]=++cnt_time;
    b[cnt_time]=x;
    for(auto to:G[x])if(to!=fa&&!vis[to]){
        basis[to]=basis[x];
        dfs(to,x);
    }
}
void dfz(int x,int sum=n){
    mx_rt=INF;
    get_rt(x,-1,sum);
    get_rt(x=rt,-1,sum);
    x=rt;
 
    lst=cnt_time=0;
 
    basis[x].insert(a[x]);
    dfn[x]=++cnt_time;
    b[cnt_time]=x;
    lst=cnt_time;
 
    for(auto to:G[x])if(!vis[to]){
        basis[to]=basis[x];
        dfs(to,x);
        rep(i,lst+1,cnt_time){
            int u=b[i];
            for(auto [v,p]:Q[u]){
                auto [k,idx]=p;
                if(dfn[v]<=lst){
                    auto base=basis[u];
                    rep(i,0,20)base.insert(basis[v].base[i]);
                    ans[idx]=base.check(k);
                }
            }
        }
        lst=cnt_time;
    }
    for(auto [v,p]:Q[x])if(dfn[v]<=cnt_time){
        auto [k,idx]=p;
        auto base=basis[x];
        rep(i,0,20)base.insert(basis[v].base[i]);
        ans[idx]=base.check(k);
    }
    rep(i,1,cnt_time)basis[b[i]].init(),dfn[b[i]]=INF;
 
    vis[x]=true;
    for(auto to:G[x])if(!vis[to])dfz(to,sz[to]);
}
int main(){
    fastio;
    cin>>n;
    rep(i,1,n)cin>>a[i];
    G=vector<vector<int>>(n+1);
    Q=vector<vector<pair<int,pii>>>(n+1);
    rep(i,1,n)dfn[i]=INF;
    rep(i,1,n-1){
        int u,v;
        cin>>u>>v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    cin>>q;
    rep(i,1,q){
        int x,y,k;
        cin>>x>>y>>k;
        Q[x].push_back({y,{k,i}});
        Q[y].push_back({x,{k,i}});
    }
    dfz(1,n);
    rep(i,1,q){
        if(ans[i])cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}