bzoj2588/Spoj10628 Count on a tree(主席树+lca(树链剖分))

题目

给一棵树，n个节点，每个节点i有点权ai

m个询问，每次询问u到v这条链上第k小的值

n,m<=1e5

思路来源

http://www.cnblogs.com/autsky-jadek/p/4422979.html

心得

拼板子真tm费劲

本来这是个主席树的例题

因为dfs2看不懂，下午去现学的树链剖分QAQ

嗯dfs序的id[i]正好是主席树的那个rank[i]

其实想想原理，rank[i]也是给新开的那个节点标了个号，

既然树的dfs序已经有了一个不重复的标号，用这个当root不就好啦QAQ

 

看不懂这段的童鞋update那个地方开个++cnt2，cnt2赋初始值n，往上搞就好

好叭这里偷了个懒，

用的已经加得挺大了的边的编号的cnt给新建的子节点当标号了

也就是说根节点用dfs序的标号1-n的值对应那些节点，

然后下面的节点用一个已经大于2*n-2(n-1条边)的值当标号，且只增不减，

也就算是浪费了一个n的空间叭

不过n1e5的时候，19也是大于logn的，够用哈QAQ

有u和v存在说明n≥2，即2*n-2≥n，而++cnt的写法真的是恰到好处，保证新开的节点的编号≥3

被自己的机智深深打动呐

 

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=1e5+10;
//主席树 与上一棵树共用没有新开的那些节点 
//root数组代表第i颗树的根 
//插入和查询都是 两棵树同步走相对应的节点 

struct edge
{
	int to,nex;
}e[maxn*2];  
int num,n,q,res;
int par[maxn],dep[maxn],siz[maxn],son[maxn],top[maxn];
int Rank[maxn];
int head[maxn],cnt,a[maxn];
int id[maxn];
void add(int u,int v)
{
	e[cnt].to=v;
	e[cnt].nex=head[u];
	head[u]=cnt++;
}
struct node
{
	int lson,rson,num;
	//分别是左子下标 右子下标 这段值域出现的个数 
}tree[maxn*20];
//pre代表上一颗子树的根 cur代表当前子树的根 v代表要插的值 
void pushup(int pos)
{
	tree[pos].num=tree[tree[pos].lson].num+tree[tree[pos].rson].num;
}
void update(int pre,int cur,int l,int r,int v) 
{
	if(l==r)//前缀和思想，第i颗树包含了前i个元素，值即权值线段树的操作 
	{
		tree[cur].num=tree[pre].num+1;
		return; 
	}
	int mid=(l+r)>>1;
	if(v<=mid)//新值在左子树里 新开一个左子节点
	{
		tree[cur].lson=++cnt;
		tree[cur].rson=tree[pre].rson;//共用右子
		update(tree[pre].lson,tree[cur].lson,l,mid,v);//递归左子区间 
	} 
	else//新值在右子树里 新开一个右子节点 
	{
		tree[cur].rson=++cnt;
		tree[cur].lson=tree[pre].lson;
		update(tree[pre].rson,tree[cur].rson,mid+1,r,v);
	}
	pushup(cur); 
}
int kth(int a,int b,int c,int d,int l,int r,int rank)
{
	if(l==r)return l;
	int diff=tree[tree[a].lson].num+tree[tree[b].lson].num-tree[tree[c].lson].num-tree[tree[d].lson].num;
	int mid=(l+r)>>1;
	if(diff>=rank)return kth(tree[a].lson,tree[b].lson,tree[c].lson,tree[d].lson,l,mid,rank);
	else return kth(tree[a].rson,tree[b].rson,tree[c].rson,tree[d].rson,mid+1,r,rank-diff);
}
void init()
{
	//memset(par,0,sizeof(par)); 由于dfs1的时候会覆盖 不需要 
	//memset(dep,0,sizeof(dep)); 由于后续dep[v]=dep[u]+1 只需更新根节点 
	//memset(siz,0,sizeof(siz)) 由于siz[u]=1覆盖 不需要 
	//memset(tree,0,sizeof(tree));
	//memset(top,0,sizeof(top)); 后续都是根据根节点更新的 
	//memset(id,0,sizeof(id)); num=0了什么都好说 
	dep[1]=0;top[1]=1;
	memset(son,0,sizeof(son));
	memset(head,-1,sizeof(head));
	cnt=num=0; 
}
int lca(int u,int v)//重链log 轻链log 故O(log)在线查询LCA 
{
	//保证u的那条链的top一直在下 
	while(top[u]!=top[v])
	{
		if(dep[top[u]]<dep[top[v]])swap(u,v);
		u=par[top[u]];//从top走向它的父亲 
	}
	//此时top[u]==top[v] 初始状况或未swap 判一下 返回靠上的 
	if(dep[u]>dep[v])swap(u,v); 
	return u; 
}
void dfs1(int u)
{
	siz[u]=1;
	for(int i=head[u];~i;i=e[i].nex)
	{
		int v=e[i].to;
		if(v!=par[u])
		{
			par[v]=u;
			dep[v]=dep[u]+1;
			dfs1(v);
			siz[u]+=siz[v];
			if(siz[v]>siz[son[u]])son[u]=v;
		}
	}
}
void dfs2(int u)
{
	id[u]=++num;//dfs序 时间戳 id[i]即在线段树的第i位 想象给一颗dfs树标号 
	update(id[par[u]],id[u],1,res,a[u]);
	if(son[u])//优先遍历重儿子 保证重链dfs序相邻 
	{
		top[son[u]]=top[u];//重链上的根一定和父相同
		dfs2(son[u]); 
	} 
	for(int i=head[u];~i;i=e[i].nex)
	{
		int v=e[i].to;
		if(v!=par[u]&&v!=son[u])//非父 轻儿子
		{
			top[v]=v;//轻链以自己为根
			dfs2(v); 
		} 
	}
}
int main()
{
	//确保所有值都在1到n之间 如果不在的话 离散化一下就搞成1到n之间了
	//插第一条链的时候 不用管pre节点里值是什么 认为全都是0也无妨 
	//也可以先build一棵普通权值线段树 然后再add节点 
	scanf("%d%d",&n,&q);
	init();
	for(int i=1;i<=n;++i)
	{
	 scanf("%d",&a[i]);
	 Rank[i]=a[i];
    }
    for(int i=1;i<n;++i)
    {
    	int u,v;
    	scanf("%d%d",&u,&v);
    	add(u,v);
    	add(v,u);
    }
    //必备操作离散化
    sort(Rank+1,Rank+n+1);
    res=unique(Rank+1,Rank+n+1)-(Rank+1);
    for(int i=1;i<=n;++i)
    a[i]=lower_bound(Rank+1,Rank+res+1,a[i])-Rank;
	dfs1(1);
	dfs2(1);
	//前缀和思想 [l,r]信息只需将第root[r]棵树与第root[l-1]棵树作差 
	while(q--)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		int t=lca(u,v);
		printf("%d\n",Rank[kth(id[u],id[v],id[t],id[par[t]],1,res,w)]);
	}
	return 0;
}