hdu6191 Query on A Tree(可持久化01字典树)

题目

n(n<=1e5)个点,第i个点上有个权值vi(0<=vi<=1e9)

q(q<=1e5)次询问,每次询问给出u和x,

要求选择u的子树的一个节点y,使得y的权值异或x最大,

输出这个最大值

思路来源

https://www.cnblogs.com/LQLlulu/p/9496426.html

题解

按dfs序将树压成线性序列,子树的权值就是一段连续的序列

对线性序列建可持久化01字典树,

询问u的子树的时候,就是[in[u],out[u]]这段序列对应的01字典树的最优解

在该01字典树上贪心地跑,能反则反,被迫同则同,贪心地选

注意开始建一条全0的链,但似乎题意没说可以不选???

心得

要习惯这种开若干个数组建数据结构的代码吧

毕竟数组来模拟数据结构,往往无敌,不会被卡空间,也很少被卡时间

学了一下可持久化01字典树,算是对可持久化结构理解更深了一步吧

总之就是用的时候动态开点,查询时候两条链在同一节点一起向下跑

代码

#include
#include
#include
#include
#include
#include 
#include
#include
using namespace std;
typedef long long ll;
const int maxn=1e5+10;
int n,q,par,u,x;
int v[maxn];
int in[maxn],out[maxn],dfn;
int ord[maxn]; 
vectore[maxn];
int root[maxn];
int ch[maxn*33*2][2],cnt;//cnt用于动态开点 
int num[maxn*33*2][2];
//01字典树 每个节点的值的出现个数 
int id[maxn*33*2];//记录尾节点的值的pos 
void dfs(int u,int fa)
{
	in[u]=++dfn;
	ord[dfn]=v[u];
	for(int i=0;i=0;--i)
	{
		int j=x>>i&1;
		num[cur][j]+=num[pre][j]+1;
		num[cur][!j]+=num[pre][!j];
		ch[cur][j]=++cnt;
		ch[cur][!j]=ch[pre][!j];
		//现用现清 
		memset(ch[cnt],0,sizeof ch[cnt]);
		memset(num[cnt],0,sizeof num[cnt]);
		pre=ch[pre][j];
		cur=ch[cur][j]; 
	} 
	id[cur]=pos;//记录链尾的下标 
} 
int ask(int pre,int cur,int x)
{
	for(int i=30;i>=0;--i)
	{
		int j=!(x>>i&1);//先取反的,不能取再取相同的
		if(num[cur][j]-num[pre][j]>0)
		{
			cur=ch[cur][j];
			pre=ch[pre][j];
		} 
		else
		{
			cur=ch[cur][!j];
			pre=ch[pre][!j];
		}
	}
	return id[cur];
}
int main()
{
	while(~scanf("%d%d",&n,&q))
	{
		dfn=cnt=0; 
		for(int i=1;i<=n;++i)
		{
			scanf("%d",&v[i]);
			e[i].clear();
		}
		for(int i=2;i<=n;++i)
		{
			scanf("%d",&par);
			e[par].push_back(i);
		}
		dfs(1,-1);
		update(0,0,0,0);//建一个全0的链 
		for(int i=1;i<=n;++i)
		{
		   root[i]=++cnt;
		   update(root[i-1],root[i],ord[i],i);
		} 
		for(int i=1;i<=q;++i)
		{
			scanf("%d%d",&u,&x);
			printf("%d\n",x^ord[ask(root[in[u]-1],root[out[u]],x)]);
		}
	}
	return 0;
}

 

你可能感兴趣的:(hdu6191 Query on A Tree(可持久化01字典树))