[TS-A1486][2013中国国家集训队第二次作业]树[树的重心，点分治]

首先考虑暴力，可以枚举每两个点求lca进行计算，复杂度O(n^3logn)，再考虑如果枚举每个点作为lca去枚举这个点的子树中的点复杂度会大幅下降，如果我们将每个点递归考虑，每次计算过这个点就把这个点删掉，那么如果每次删掉的点是当前子树的重心，枚举点对的复杂度就只有O(logn)，对于每次查询答案在trie树中找到时间复杂度基本可视为O(1)，最后在分治同时考虑“关键点”即可。总复杂度O(nlogn)。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>

using namespace std;

struct Edge
{
    int    to,next;
}e[210000];

int    n,k,Ans=-1;
int    Size[110000],cnt,p[110000],f[110000],a[110000];
bool    visited[110000];

void    Add_edge(const int x,const int y)
{
    e[++cnt].to=y;
    e[cnt].next=p[x];
    p[x]=cnt;
    return ;
}

struct Trie
{
    private:
        int    c[110000][2];
        int    d[3500000];
        int    cnt,root;

    public:
        void    insert(const int val,const int flag)
        {
            int    pos=root,temp;
            for(int i=30;i>=0;--i)
            {
                temp=!!(val&(1<<i));
                if(!c[pos][temp])
                {
                    c[pos][temp]=++cnt;
                    c[cnt][0]=c[cnt][1]=0;
                    d[cnt]=0;
                }
                d[pos]=max(d[pos],flag);
                pos=c[pos][temp];
            }
            d[pos]=max(d[pos],flag);
            return ;
        }

        void    query(const int val,const int flag)
        {
            int    temp,num=0,pos=root;
            for(int i=30;i>=0;--i)
            {
                temp=!(val&(1<<i));
                if(c[pos][temp] && d[c[pos][temp]]+flag>=k)
                {
                    pos=c[pos][temp];
                    num|=(1<<i);
                }
                else
                {
                    if(!c[pos][temp^1] || d[c[pos][temp^1]]+flag<k)
                    {
                        num=-1;
                        break;
                    }
                    else    pos=c[pos][temp^1];
                }
            }
            if(k<=flag)Ans=max(Ans,val);
            Ans=max(Ans,num);
        }
        
        void    clear()
        {
            root=1;
            cnt=1;
            c[root][0]=c[root][1]=0;
            d[root]=0,d[0]=0;
            return ;
        }
}T;

int    Dfs(const int S,const int fa)
{
    Size[S]=1;
    for(int i=p[S];i;i=e[i].next)
    {
        if(e[i].to!=fa && !visited[e[i].to])
            Size[S]+=Dfs(e[i].to,S);
    }
    return Size[S];
}

void    Get(const int S,const int fa,int & Centre,int & tot,const int nn)
{
    int    Max=0,i;

    for(i=p[S];i;i=e[i].next)
    {
        if(e[i].to!=fa && !visited[e[i].to])
        {
            Get(e[i].to,S,Centre,tot,nn);
            Max=max(Max,Size[e[i].to]);
        }
    }
    Max=max(Max,nn-Size[S]);
    if(tot>Max)tot=Max,Centre=S;
    return ;
}

void    Query(const int S,const int fa,int A,int F)
{
    A^=a[S];F+=f[S];
    T.query(A,F);
    for(int i=p[S];i;i=e[i].next)
    {
        if(e[i].to!=fa && !visited[e[i].to])
            Query(e[i].to,S,A,F);
    }
    return ;
}

void    Insert(const int S,const int fa,int A,int F)
{
    A^=a[S];F+=f[S];
    T.insert(A,F);
    for(int i=p[S];i;i=e[i].next)
    {
        if(e[i].to!=fa && !visited[e[i].to])
            Insert(e[i].to,S,A,F);
    }
    return ;
}

void    TDC(const int S)
{
    int    i,Centre;

    visited[S]=true;
    for(i=p[S];i;i=e[i].next)
    {
        if(!visited[e[i].to])
        {
            int    tot=n+1;
            Dfs(e[i].to,0);
            Get(e[i].to,0,Centre,tot,Size[e[i].to]);
            TDC(Centre);
        }
    }
    T.clear();
    for(i=p[S];i;i=e[i].next)
    {
        if(!visited[e[i].to])
        {
            Query(e[i].to,0,a[S],f[S]);
            Insert(e[i].to,0,0,0);
        }
    }
    T.query(a[S],f[S]);
    visited[S]=false;
    return ;
}

int main()
{
    int    i,x,y;

    scanf("%d%d",&n,&k);
    for(i=1;i<=n;++i)scanf("%d",&f[i]);
    for(i=1;i<=n;++i)scanf("%d",&a[i]);

    for(i=1;i<n;++i)
    {
        scanf("%d%d",&x,&y);
        Add_edge(x,y);
        Add_edge(y,x);
    }

    TDC(1);

    printf("%d\n",Ans);

    return 0;
}