BZOJ 2588 Count on a tree 可持久化线段树+LCA

兰芷结新佩

于 2017-01-07 18:40:29 发布

阅读量323

点赞数

分类专栏：可持久化数据结构文章标签：可持久 LCA DFS序

本文链接：https://blog.csdn.net/l975744425/article/details/54176993

版权

可持久化数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

题目大意：给出一棵n（n<=100000）个节点的树，每个节点有一个权值v（v<=2^31-1）,以及m（m<=100000）个询问：节点u到v之间的路径上的第k小权值。

一开始写的是DFS序加树状数组套权值线段树，即对于一条路径，其包含的权值所组成的权值线段树等价于u到root的权值线段树，加上v到root，减去LCA（u,v）到root，减去fa[LCA(u,v)]到root的权值线段树，那么对于一个点来说，其到根节点上的权值组成的权值线段树只受其祖先的影响，所以我们只需要在求出DFS序之后，对于一个点，其左括号位置权值线段树++，右括号+1处权值线段树--，代表我对我的子树造成了影响，然后搜集信息直接求和就行了。之后就直接二分了。

然而，上述做法无奈超时……好吧，老老实实可持久化线段树，对于一个节点，维护其到根的权值线段树只需要令其继承其父亲的权值线段树树然后修改logn的链即可。

先上超时代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
using namespace std;
int n,m,cnt=0,tot=0,num=0,ans=0;
const int maxn=200005;
int a[200005]={0},first[200005]={0},fa[200005][35]={0},root[200005]={0},L[200005]={0},R[200005]={0},dep[200005]={0};
int t[5][300]={0};
int number[100005]={0};
set<int>box;
map<int,int>ref;
struct Edge
{
	int next,to;
}edge[400005];
struct node
{
	int l,r,sum;
}tree[20000000];
void add(int x,int y)
{
	cnt++;
	edge[cnt].to=y;
	edge[cnt].next=first[x];
	first[x]=cnt;
}
void DFS(int x,int depth)
{
	L[x]=++num;
	dep[x]=depth;
	for(int i=first[x];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if(v!=fa[x][0])
		{
			fa[v][0]=x;
			DFS(v,depth+1);
		}
	}
	R[x]=++num;
}
int LCA(int x,int y)
{
	if(dep[x]<dep[y])swap(x,y);
	for(int i=log2(dep[x]-dep[y])+1;i>=0;i--)if(fa[x][i]!=-1&&dep[fa[x][i]]>=dep[y])x=fa[x][i];
	if(x==y)return x;
	for(int i=log2(dep[x])+1;i>=0;i--)
       if(fa[x][i]!=-1&&fa[y][i]!=-1&&fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
int low_bit(int x)
{
	return x&(-x);
}
void Insert(int l,int r,int &x,int pos,int v)
{
	if(!x)x=++tot;
	tree[x].sum+=v;
	if(l==r)return;
	int mid=(l+r)/2;
	if(pos<=mid)Insert(l,mid,tree[x].l,pos,v);
	else Insert(mid+1,r,tree[x].r,pos,v);
}
void Modify(int x,int pos,int v)
{
	while(x<=num)
	{
		Insert(0,maxn,root[x],pos,v);
		x+=low_bit(x);
	}
}
void Get(int pos,int k)
{
	t[k][0]=0;
	if(pos==-1)return;
	int temp=L[pos];
	while(temp>=1)
	{
		t[k][++t[k][0]]=root[temp];
		temp-=low_bit(temp);
	}
}
int Sum(int k)
{
	int sum=0;
	for(int i=1;i<=t[k][0];i++)sum+=tree[tree[t[k][i]].l].sum;
	return sum;
}
void Down(int k,int bj)
{
	if(!bj)for(int i=1;i<=t[k][0];i++)t[k][i]=tree[t[k][i]].l;
	else for(int i=1;i<=t[k][0];i++)t[k][i]=tree[t[k][i]].r;
}
void Ask(int u,int v,int k)
{
	int Fa=LCA(u,v),Fafa=fa[Fa][0];
	Get(u,1); Get(v,2);
	Get(Fa,3); Get(Fafa,4);
	int l=0,r=maxn,mid,sum;
	while(l<r)
	{
		mid=(l+r)/2;
		sum=Sum(1)+Sum(2)-Sum(3)-Sum(4);
		if(sum>=k)
		{
		   for(int i=1;i<=4;i++)Down(i,0);
		   r=mid;
	    }
	    else 
	    {
	       for(int i=1;i<=4;i++)Down(i,1);
	       k-=sum;
	       l=mid+1;
	    }
	}
	ans=number[l];
	cout<<ans<<'\n';
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
	{
	  scanf("%d",&a[i]);
	  box.insert(a[i]);
    }
    int ccnt=0;
    for(set<int>:: iterator it=box.begin();it!=box.end();it++){ref[*it]=++ccnt;number[ccnt]=*it;}
    memset(fa,-1,sizeof(fa));
    int x,y;
    for(int i=1;i<n;i++)
    {
    	scanf("%d%d",&x,&y);
    	add(x,y);
    	add(y,x);
    }
    DFS(1,1);
    for(int i=1;i<=30;i++)
       for(int j=1;j<=n;j++)
         if(fa[j][i-1]!=-1&&fa[fa[j][i-1]][i-1]!=-1)fa[j][i]=fa[fa[j][i-1]][i-1];
    num++;
    for(int i=1;i<=n;i++)
    {
    	Modify(L[i],ref[a[i]],1);
    	Modify(R[i]+1,ref[a[i]],-1);
    }
    int k;
    for(int i=1;i<=m;i++)
    {
    	scanf("%d%d%d",&x,&y,&k);
    	x^=ans;
    	Ask(x,y,k);
    }
	return 0;
}

然后是正解：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
using namespace std;
set<int>box;
map<int,int>ref;
int n,m,cnt=0,tot=0,num=0;
int first[100005]={0},val[100005]={0},root[100005]={0},number[100005]={0},fa[100005][35]={0},dep[100005]={0};
inline int Getint()
{	int ret=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){ret=ret*10+ch-'0';ch=getchar();}
	return ret*f;
}
struct Edge
{
	int next,to;
}edge[200005];
struct Node
{
	int ls,rs,sum;
}tree[2000000];
void add(int x,int y)
{
	cnt++;
	edge[cnt].to=y;
	edge[cnt].next=first[x];
	first[x]=cnt;
}
void Build(int &x,int l,int r)
{
	x=++tot;
	tree[x].sum=0;
	if(l==r)return;
	int mid=(l+r)/2;
	Build(tree[x].ls,l,mid);
	Build(tree[x].rs,mid+1,r);
}
void Insert(int dad,int &son,int l,int r,int pos,int v)
{
	son=++tot;
	tree[son]=tree[dad];
	tree[son].sum+=v;
	if(l==r)return;
	int mid=(l+r)/2;
	if(pos<=mid)Insert(tree[dad].ls,tree[son].ls,l,mid,pos,v);
	else Insert(tree[dad].rs,tree[son].rs,mid+1,r,pos,v);
}
void DFS(int u,int depth)
{
	dep[u]=depth;
	if(fa[u][0]!=-1)Insert(root[fa[u][0]],root[u],1,n,ref[val[u]],1);
	for(int i=first[u];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if(v!=fa[u][0])
		{
			fa[v][0]=u;
			DFS(v,depth+1);
		}
	}
}
int LCA(int x,int y)
{
	if(dep[x]<dep[y])swap(x,y);
	for(int i=log2(dep[x]-dep[y])+1;i>=0;i--)
	   if(fa[x][i]!=-1&&dep[fa[x][i]]>=dep[y])x=fa[x][i];
	if(x==y)return x;
	for(int i=log2(dep[x])+1;i>=0;i--)
	   if(fa[x][i]!=-1&&fa[y][i]!=-1&&fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
	return fa[x][0];
}
int Ask(int u,int v,int k)
{
	int Fa=LCA(u,v),Fafa=fa[Fa][0];
	if(Fafa==-1)Fafa=0;
	int l=1,r=n,mid,sum;
	u=root[u],v=root[v],Fa=root[Fa],Fafa=root[Fafa];
	while(l<r)
	{
		sum=tree[tree[u].ls].sum+tree[tree[v].ls].sum-tree[tree[Fa].ls].sum-tree[tree[Fafa].ls].sum;
		mid=(l+r)/2;
		if(sum>=k)
		{
			r=mid;
			u=tree[u].ls; v=tree[v].ls; Fa=tree[Fa].ls; Fafa=tree[Fafa].ls;
		}
		else
		{
			l=mid+1;
			k-=sum;
			u=tree[u].rs; v=tree[v].rs; Fa=tree[Fa].rs; Fafa=tree[Fafa].rs;
		}
	}
	return number[l];
}
int main(){
    scanf("%d%d",&n,&m);
    Build(root[0],1,n);
    for(int i=1;i<=n;i++)
	{
	  val[i]=Getint();
	  box.insert(val[i]);
    }
    for(set<int>:: iterator it=box.begin();it!=box.end();it++){ref[*it]=++num;number[num]=*it;}
    int x,y;
    for(int i=1;i<n;i++)
    {
    	x=Getint();
    	y=Getint();
    	add(x,y); add(y,x);
    }
    memset(fa,-1,sizeof(fa));
    Insert(root[0],root[1],1,n,ref[val[1]],1);
    DFS(1,1);
    for(int i=1;i<=30;i++)
       for(int j=1;j<=n;j++)
         if(fa[j][i-1]!=-1&&fa[fa[j][i-1]][i-1]!=-1)fa[j][i]=fa[fa[j][i-1]][i-1];
    int ans=0;
    int l,r,k;
    for(int i=1;i<=m;i++)
    {
    	l=Getint();
    	r=Getint();
    	k=Getint();
    	l^=ans;
    	ans=Ask(l,r,k);
    	cout<<ans<<'\n';
    }
	return 0;
}

两个程序在调试的时候都遇到了同样的问题，第一个程序在加边的时候只加了单向边……调了半天才调出来，第二个程序没加边……

兰芷结新佩

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
BZOJ 2588 Count on a tree 可持久化线段树+LCA

题目大意：给出一棵n（n 一开始写的是DFS序加树状数组套权值线段树，即对于一条路径，其包含的权值所组成的权值线段树等价于u到root的权值线段树，加上v到root，减去LCA（u,v）到root，减去fa[LCA(u,v)]到root的权值线段树，那么对于一个点来说，其到根节点上的权值组成的权值线段树只受其祖先的影响，所以我们只需要在求出DFS序之后，对于一个点，其左括号位置权值线
复制链接

扫一扫