SPOJ - QTREE3Query on a tree again!——树链剖分_spoj query on a tree again-优快云博客

本文链接：https://blog.youkuaiyun.com/T_T233333333/article/details/98077502

本文介绍了一种解决树形结构中查询问题的高效算法——树链剖分结合线段树。通过预处理将树转换为一系列重链，利用线段树维护每个区间首次遇到特定条件节点的位置，实现快速查询。适用于需要频繁查询树路径上特定节点的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【题目描述】
SPOJ - QTREE3Query on a tree again!
在这里插入图片描述
【题目分析】
题目要求是输出从 $1$ 到 $x$ 的路径上遇到的第一个黑色的点。我们可以用树链剖分（不了解的同学请出门左拐，详见树链剖分入门）
我们用线段树维护每个区间第一次遇到黑点的位置，这样访问出的点同样是从1开始路径上的第一个点。因为我们总是从根节点1开始，我们在访问的时候从后往前每次访问重链时在线段树上都是一段连续的区间，因此在映射数组的位置越靠前则在路径上越靠前
【AC代码】

#include<iostream>
#include<cstdio>
#include<vector>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<climits>

using namespace std;

const int MAXN=100005;
vector<int>g[MAXN];
int fa[MAXN],A[MAXN],color[MAXN],pos[MAXN],siz[MAXN],son[MAXN],h[MAXN],top[MAXN],re[MAXN];
int cnt=0,n,m;
int Min[MAXN<<2];

void dfs1(int u,int f)
{
    int i,v;
    siz[u]=1;
    son[u]=0;
    fa[u]=f;
    h[u]=h[f]+1;
    for(i=0;i<g[u].size();i++)
	{
        v=g[u][i];
        if(v!=f)
		{
            dfs1(v,u);
            siz[u]+=siz[v];
            if(siz[son[u]]<siz[v]) son[u]=v;
        }
    }
}
void dfs2(int u,int f,int k)
{
    int i,v;
    top[u]=k;
    pos[u]=++cnt;
    re[cnt]=u;
    //A[cnt]=INT_MAX;
    if(son[u]) dfs2(son[u],u,k);
    for(i=0;i<g[u].size();i++)
	{
        v=g[u][i];
        if(v!=f&&v!=son[u]) dfs2(v,u,v);
    }
}

void build(int k,int l,int r)
{
	if(l==r)
	{
		Min[k]=INT_MAX;
		return; 
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	Min[k]=min(Min[k<<1],Min[k<<1|1]);
}

void update(int k,int l,int r,int x,int color)
{
     if(l==r)
	 {
	 	if(color==1)
        Min[k]=l;
        else
        Min[k]=INT_MAX;
        return;
     }
     int mid=(l+r)/2;
     if(x<=mid) update(k<<1,l,mid,x,color);
     else update(k<<1|1,mid+1,r,x,color);
     Min[k]=min(Min[k<<1],Min[k<<1|1]);
}

int QueryMin(int k,int l,int r,int L,int R)
{
    if(L<=l && r<=R) return Min[k];
    int mid=(l+r)/2;
    int ret=INT_MAX;
    if(L<=mid) ret=min(ret,QueryMin(k<<1,l,mid,L,R));
    if(R>mid) ret=min(ret,QueryMin(k<<1|1,mid+1,r,L,R));
    return ret;
}

int FindMin(int u)
{
    int ans=INT_MAX;
    while(top[u]!=1)
	{
         ans=min(ans,QueryMin(1,1,n,pos[top[u]],pos[u]));
         u=fa[top[u]];
    }
     ans=min(ans,QueryMin(1,1,n,1,pos[u]));
    return ans;
}


int main()
{
    int a,b,r,l,mid,ans;
    memset(A,0,sizeof(A));
    memset(color,0,sizeof(color));
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++)
	{
        scanf("%d%d",&a,&b);
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs1(1,0);
    dfs2(1,0,1);
    build(1,1,n);
    while(m--)
	{
        scanf("%d%d",&a,&b);
        if(a==0) 
		{
			color[b]=!color[b];
			update(1,1,n,pos[b],color[b]);
		}
        else
		{
			ans=FindMin(b);
			if(ans==INT_MAX)
			{
				printf("-1\n");
			}
			else
			{
				printf("%d\n",re[ans]);	//维护的是在映射数组上的下标，应该用一个数组保存从下标到节点的映射
			}
		}
    }
    return 0;
}