CF1902F.Trees and XOR Queries Again-點分治、線性基

yoshinow2001發表於2024-05-08
AI

link：https://codeforces.com/contest/1902/problem/F
題意：給一棵樹，有點權，q次詢問，每次問 \(x\to y\) 的路徑上是否存在一個點集的子集，使得其點權異或和恰為 \(k\).
\(n,q\leq 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;
}

相關文章