hdu 4776 Ants(trie+优先队列)

题目链接：hdu 4776 Ants

题意：

给你一棵有n个节点的树，每条边有一个权值a_i，现在定义两点直接的距离为路径上经过的边的异或和。

现在有m个询问，每次询问你第k长的路径是多少。

题解：

一开始我想二分+树分治+trie，发现只能做一个询问。- -!。

这里有一个优秀的做法，可以预处理出前k个答案。

首先，这里两点间的距离就是val[i]^val[j]，val[i]表示根节点到i节点的异或和。

然后我们可以将所有的val插进trie，然后我们将每个节点都作为起点，将以该起点的最大路径放进优先队列。

显然当前第一大的肯定就是优先队列的top，然后我们将这个top 记录下来，并且pop掉。

然后将产生这个top的节点x得到以x为起点的第二大路径放进优先队列。并且重复操作。

这样就可以将前k个答案以60*n*logn的复杂度预处理出来，然后询问就可以O(1)了。

#include<bits/stdc++.h>
#define F(i,a,b) for(int i=(a);i<=(b);++i)
#define mst(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;

const int N=2e5+7;
int n,m,g[N],v[N*2],nxt[N*2],ed;
ll w[N*2],val[N],z,ans[N];
int ct,x,y,cnt[N*62],tr[N*62][2],tot;
struct Node
{
    int idx,k;
    ll val;
    Node(int a=0,int b=0,ll c=0):idx(a),k(b),val(c){}
    bool operator<(const Node &B)const{return val<B.val;}
};
priority_queue<Node>Q;

void adg(int x,int y,ll z){v[++ed]=y,w[ed]=z,nxt[ed]=g[x],g[x]=ed;}

void dfs(int x,ll va,int fa)
{
    val[x]=va;
    for(int i=g[x];i;i=nxt[i])
        if(v[i]!=fa)dfs(v[i],va^w[i],x);
}

void ins(ll a,int x=1)
{
    for(int i=60;i>=0;i--)
    {
        int w=(a>>i)&1;
        if(!tr[x][w])
        {
            cnt[++tot]=0,mst(tr[tot],0);
            tr[x][w]=tot;
        }
        x=tr[x][w],cnt[x]++;
    }
}

ll kth(ll a,int k,int x=1,int i=60)
{
    if(i<0)return 0;
    int w=(a>>i)&1;
    if(tr[x][w^1]&&cnt[tr[x][w^1]]>=k)
        return (1ll*(w^1)<<i)|kth(a,k,tr[x][w^1],i-1);
    return (1ll*w<<i)|kth(a,k-cnt[tr[x][w^1]],tr[x][w],i-1);
}

void init(){mst(g,0),ed=ct=0,mst(tr[1],0),cnt[tot=1]=0;}

int main(){
    while(scanf("%d",&n),n)
    {
        init();
        while(!Q.empty())Q.pop();
        F(i,1,n-1)
        {
            scanf("%d%d%lld",&x,&y,&z);
            adg(x,y,z),adg(y,x,z);
        }
        dfs(1,0,0);
        F(i,1,n)ins(val[i]);
        F(i,1,n)
        {
            ll now=kth(val[i],1)^val[i];
            Q.push(Node(i,1,now));
        }
        while(ct<=200000&&!Q.empty())
        {
            Node now=Q.top();Q.pop();
            ans[++ct]=now.val;
            if(now.k+1>n)continue;
            ll tp=kth(val[now.idx],now.k+1)^val[now.idx];
            Q.push(Node(now.idx,now.k+1,tp));
        }
        scanf("%d",&m);
        F(i,1,m)
        {
            scanf("%d",&x);
            printf("%lld
",(x>ct||n==1)?-1:ans[x]);
        }
    }
    return 0;
}