HDU4776 Ants(Trie && xor)
之前mark下来的一道题，今天填一下坑。
题意是这样子的。给你一棵边上有权的树。然后有树上两点（u,v）的路径有n*(n-1)条，路径(u,v)的权值是边权的xor. 然后下面有m个询问，询问你n*(n-1)条路径中的第k大是多少。(k<=200000)
首先树路径的xor是一个很经典的问题，首先求出所有点i到根路径的xor值val[i]。然后我们就可以发现val[u]^val[v]就是u，v路径的xor值。
然后第二个很经典的地方就是最大xor.给你一个数组，要你求数组里面xor最大的一对数。方法是根据二进制的最高位到最低位插到一棵Trie树上，然后每次询问和x xor起来最大的，就从最高位贪心地去匹配，譬如最高位是1我们就可以去匹配0。
本题的突破口在于k<=200000, 因为k小，所以我们完全可以把所有的k求出来，把询问离线一下就好了。
现在关键是我们怎么能够顺次得到第k大的呢？ 方法其实很简单，首先我们对每个权值在Trie树上求出和它最大的那个，压入一个优先队列里面。然后很显然第一大的必然是优先队列的队首，然后优先队列队首的元素弹出来，这个元素里需要保存的是它是第i个结点的第k大，然后我们再把第i个结点的k+1大压入（当k达到n-1就不压了）。然后问题转化为对于一个数x,求它能匹配到的第k大，做法也很简单，Trie树上存向0走和向1走的点的个数各有多少个，如果匹配到1的时候的结点树>=k，就往匹配到1的方向走，否则就往0走，然后对应的k减去相应的值。
坑的话有两个吧，一是注意ll,二是当n=1的时候优先队列不用初始化，因为这样会把n=1当成有解的。
#pragma warning(disable:4996)
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstdio>
using namespace std;
#define ll long long
#define maxn 150000
#define MAXCHAR 61
struct Edge
{
int v; ll w;
Edge(int _v, ll _w) :v(_v), w(_w){}
Edge(){}
};
vector<Edge> G[maxn];
ll val[maxn];
int n, m;
void dfs(int u, int fa,ll vv)
{
val[u] = vv;
for (int i = 0; i < G[u].size(); i++){
int v = G[u][i].v;
ll w = G[u][i].w;
if (v == fa) continue;
dfs(v, u, vv^w);
}
}
struct Trie
{
Trie *go[2];
int num[2];
void init(){
memset(go, 0, sizeof(go));
memset(num, 0, sizeof(num));
}
}*root,pool[maxn*65];
int tot;
void insert(ll x)
{
Trie *p = root;
for (int i = MAXCHAR; i >= 0; i--){
int ind = (x >> i) & 1;
p->num[ind]++;
if (p->go[ind] != NULL) {
p = p->go[ind];
}
else{
pool[tot].init();
p->go[ind] = &pool[tot++];
p = p->go[ind];
}
}
}
ll get(ll x, int k)
{
Trie *p = root; int kk = k; ll ret = 0;
for (int i = MAXCHAR; i >= 0; i--){
int ind = (x >> i) & 1;
if (p->num[ind ^ 1] >= kk){
ret += (1LL << i);
p = p->go[ind ^ 1];
}
else{
kk -= p->num[ind ^ 1];
p = p->go[ind];
}
}
return ret;
}
struct Query
{
int k, id;
bool operator < (const Query &b) const{
return k < b.k;
}
}q[maxn];
struct Node
{
int t, k;
ll val;
Node(int _t, int _k, ll _val) :t(_t), k(_k), val(_val){}
Node(){}
bool operator < (const Node &b) const{
return val < b.val;
}
};
ll ans[maxn];
priority_queue<Node> que;
int main()
{
while (cin >> n && n)
{
int ui, vi; ll wi;
for (int i = 0; i <= n; i++) G[i].clear();
for (int i = 0; i < n-1; i++){
scanf("%d%d%I64d", &ui, &vi, &wi);
G[ui].push_back(Edge(vi, wi));
G[vi].push_back(Edge(ui, wi));
}
dfs(1, -1, 0);
tot = 0; root = &pool[tot++]; root->init();
for (int i = 1; i <= n; i++){
insert(val[i]);
}
scanf("%d", &m);
for (int i = 0; i < m; i++){
scanf("%d", &q[i].k);
q[i].id = i;
}
sort(q, q + m);
while (!que.empty()) que.pop();
for (int i = 1; i <= n&&n!=1; i++){
que.push(Node(i, 1, get(val[i], 1)));
}
int cur = 0; int idx = 1;
while (!que.empty() && cur < m){
Node node = que.top(); que.pop();
if (idx== q[cur].k){
ans[q[cur].id] = node.val;
cur++; idx++;
}
else{
idx++;
}
if (node.k < n-1){
que.push(Node(node.t, node.k + 1, get(val[node.t], node.k + 1)));
}
}
for (int i = cur; i < m; i++){
ans[q[i].id] = -1;
}
for (int i = 0; i < m; i++){
printf("%I64d\n", ans[i]);
}
}
return 0;
}