Water Tree CodeForces 343D 树链剖分+线段树

Water Tree CodeForces 343D 树链剖分+线段树

题意

给定一棵n个n-1条边的树，起初所有节点权值为0。

然后m个操作， 1 x:把x为根的子树的点的权值修改为1； 2 x：把x结点到根路径上的点修改为0； 3 x：查询结点x的值。

解题思路

这个因为是在树上进行的操作，所以首先需要把树进行一些转化，比如使用dfs序列转变成一维的，这样方便使用线段树或则树状数组来进行操作。但是因为这里的操作2需要把x节点和它的父节点赋值为0，所以需要树链剖分来进行处理。

关于树链剖分的讲解可以参照我的代码，如果是初学者的话，我有一篇博文专门总结了一些优秀的关于树链剖分的文章，可以参考，点我进去

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=5e5+7;
struct node{
    int l, r;
    int val, lazy; //val表示在l到r的范围内是不是都有水，lazy就是标记了
}t[maxn<<2]; //线段树的基本单元
struct edge{
    int to, next;
}e[maxn<<1]; //采用链式向前星的形式来存边
int son[maxn], size[maxn], f[maxn], dep[maxn];
int in[maxn], top[maxn], cnt; 
int head[maxn], len;
int n, m;
void init()
{
    len=cnt=0;
    for(int i=1; i<=n; i++)
        head[i]=-1;
}
void add(int u, int v)
{
    e[len].to=v;
    e[len].next=head[u];
    head[u]=len++;
}
void dfs1(int u, int fa, int depth) //这个dfs主要解决每个点的基本信息，如深度，父节点是谁，点的规模大小和它的重儿子
{
    f[u]=fa;
    dep[u]=depth;
    size[u]=1; //点的规模包括自己和自己的所有子儿子。
    for(int i=head[u]; i!=-1; i=e[i].next)
    {
        int v=e[i].to;
        if(v==fa) //因为是无向树，所以要注意不能回去
            continue;
        dfs1(v, u, depth+1);
        size[u]+=size[v];
        if(size[v] > size[son[u]]) //一个点只有一个重儿子，就是规模最大的子儿子
            son[u]=v; //记录u这个点的重儿子
    }
}
void dfs2(int u, int t) //这里是dfs序，但是有所不同，在处理一个节点的子儿子时，先处理它的重儿子，也就是先处理重链。
{
    top[u]=t; //链的顶部
    in[u]=++cnt;//这里存储树按照新的排列方式的顺序，从1到n
    if(!son[u]) //如果没有重儿子说明到了叶子节点
        return ;
    dfs2(son[u], t);//先处理重儿子
    for(int i=head[u]; i!=-1; i=e[i].next) //下面是处理u的轻儿子
    {
        int v=e[i].to;
        if(v==son[u] || v==f[u]) //如果遇到重儿子和它的父节点就不能再处理一遍了。
            continue;
        dfs2(v, v); //轻儿子的顶点就是本身
    }
}
//-----------------------------这里是线段树----------------------------------
void up(int rt)
{
    t[rt].val=(t[rt<<1].val && t[rt<<1|1].val);
}
void build(int rt, int l, int r)
{
    t[rt].l=l;
    t[rt].r=r;
    t[rt].lazy=-1;
    t[rt].val=0;
    if(l==r)
        return ;
    int mid=(l+r)>>1;
    build(rt<<1, l, mid);
    build(rt<<1|1, mid+1, r);
}
void down(int rt)
{
    if(t[rt].lazy==-1) return ;
    int l=rt<<1, r=rt<<1|1;
    t[l].val=t[l].lazy=t[rt].lazy;
    t[r].val=t[r].lazy=t[rt].lazy;
    
    t[rt].lazy=-1; 
} 
void update(int rt, int l, int r, int v)
{
    if(l<=t[rt].l && t[rt].r<=r)
    {
        t[rt].lazy=t[rt].val=v;
        return ;    
    }   
    down(rt);
    int mid=(t[rt].l+t[rt].r)>>1;
    if(l<=mid) 
        update(rt<<1, l, r, v);
    if(r>mid) 
        update(rt<<1|1, l, r, v);
    up(rt);
} 
int query(int rt, int x)
{
    if(t[rt].l==t[rt].r)
        return t[rt].val;
    down(rt);
    int mid=(t[rt].l+t[rt].r)>>1;
    if(x<=mid) return query(rt<<1, x);
    else return query(rt<<1|1, x);  
}
//--------------------线段树到此结束------------------------------------
void solve(int x) //这里是关键的一步，用来处理一个点和它的祖先们。
{
    int f1=top[x]; //在这里，上面使用的top来记录一个重链的上端点的用处就体现出来了。实际上就是用来加速的
    while(f1!=1)
    {
        update(1, in[f1], in[x], 0);
        x=f[x];
        f1=top[x];
    }
    update(1, 1, in[x], 0); //不要忘记这一步。
}
int main()
{
    scanf("%d", &n);
    init();
    int x, y;
    for(int i=1; i<n; i++)
    {
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
    }
    dfs1(1, 0, 1);
    dfs2(1, 1);
    build(1, 1, n);
    scanf("%d", &m);
    int op;
    for(int i=1; i<=m; i++)
    {
        scanf("%d%d", &op, &x);
        if(op==1)
            update(1, in[x],  in[x]+size[x]-1, 1);
        else if(op==2)
            solve(x);
        else printf("%d\n", query(1, in[x])); 
    }
    return 0;
}

转载于:https://www.cnblogs.com/alking1001/p/11402253.html