HDU - 3974 Assign the task DFS括号引理+线段树

原题目链接

题意是给你一棵树，然后有两类操作，一种是将某个节点以及它所有的子孙修改成某个数，另一种是查询该节点的值。所有节点的初始值为-1；

---

思路

说实话不好联想到线段树上来，如果用暴力修改每棵子树的话每次修改的复杂度都可以达到O(n)，不过我当时想到可以另外建立一棵结构相同的懒惰标记的树。但是复杂度并没有变化。

在学习图论的时候学DFS生成树的时候有一个叫做括号引理的结论。对于每个节点u，设dTime[u]为该节点首次发现(discover)时间，fTime[u]为节点访问结束(finish)时间，那么整个节点的活跃期

active[u] = ( dTime[u], fTime[u] )

给定任意图G=（V，E）及其任意DFS森林，则

u是v的后代 iff active[u] ⊆ active[v]
u是v的祖先 iff active[u[ ⊇ active[v]

由该结论就能通过节点的DFS序来确定节点的关系。而活跃期就成功将树映射到了区间。这种修改也就可以和线段树建立关系了。

#include<iostream>
#include<limits.h>
#include<vector>
#include<string>
#include<stdlib.h>
#include<algorithm>
#include<map>
#include<cstdlib>
#include<stack>
#include<set>
#include<cmath>
#include<queue>
#include<stdio.h>
#include<cstring>
//#include<bits/stdc++.h>


using namespace std;

const int maxn = 2e5+10;
const int inf = 0x3f3f3f3f;
const double dinf = 1061109567.0;
typedef long long ll;

ll sum[maxn<<2];
ll lazy[maxn<<2];
ll n,m;

//链式前向星
struct Edge{
    int next,to;
};
Edge edge[maxn];
int cnt;
int head[maxn];

void add(int u,int v){
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}

//通过dfs计算各节点的活跃期
int dTime[maxn],fTime[maxn];

void dfs(int v,int &clock){
    if(!dTime[v])   dTime[v]=clock++;//发现时间是先序
    for(int i=head[v];i!=-1;i=edge[i].next){
        dfs(edge[i].to,clock);
    }
    if(!fTime[v])   fTime[v]=clock++;//结束时间是后序
}


//线段树
void pushdown(ll rt,ll l,ll r){
    ll mid=(l+r)>>1;
    ll lc=(rt<<1);
    ll rc=(rt<<1|1);
    if(lazy[rt]){
        lazy[lc]=lazy[rt];
        lazy[rc]=lazy[rt];
        sum[lc]=(lazy[rt]);
        sum[rc]=(lazy[rt]);
        lazy[rt]=0;
    }
}

void build(ll l,ll r,ll rt){
    lazy[rt]=0;
    if(l==r){
        //scanf("%lld",&sum[rt]);
        sum[rt]=-1;
        return;
    }
    ll mid=(l+r)>>1;
    build(l,mid,rt<<1);
    build(mid+1,r,rt<<1|1);
    //pushup(rt);
}

void update(ll LL,ll RR,ll val,ll l,ll r,ll rt){
    ll mid=(l+r)>>1;
    if(LL<=l&&RR>=r){
        sum[rt]=val;
        lazy[rt]=val;
        return ;
    }

    pushdown(rt,l,r);
    if(LL<=mid) update(LL,RR,val,l,mid,rt<<1);
    if(RR>mid)  update(LL,RR,val,mid+1,r,rt<<1|1);
    //pushup(rt);
}

//意是单点查询
ll query(ll p,ll l,ll r,ll rt){
    if(l==r)
        return sum[rt];
    ll mid=(l+r)>>1;
    pushdown(rt,l,r);
    if(p<=mid)  return query(p,l,mid,rt<<1);
    else return query(p,mid+1,r,rt<<1|1);
}

//根据出度确定根节点
bool indegree[maxn];

int main(){
    //freopen("input.txt","r",stdin);
    int t;
    scanf("%d",&t);
    for(int kase=1;kase<=t;kase++){
        scanf("%lld",&n);
        for(int i=1;i<=n;i++){
            head[i]=-1;
        }
        cnt=0;
        int u,v;
        memset(indegree,false,sizeof(indegree));
        for(int i=1;i<n;i++){
            scanf("%d%d",&u,&v);
            add(v,u);
            indegree[u]=1;
        }
        
        int root;
        for(int i=1;i<=n;i++){
            if(!indegree[i]){
                root=i;
                break;
            }
        }

        memset(dTime,0,sizeof(dTime));
        memset(fTime,0,sizeof(fTime));
        int clock=1;
        dfs(root,clock);

        clock--;//注意所有节点dfs结束之后clock还自加了一次
        build(1,clock,1);
        char op[10];
        ll l,r,pos;
        scanf("%lld",&m);
        printf("Case #%d:\n",kase);

        while(m--){
            scanf("%s",op);
            if(op[0]=='C'){
                scanf("%lld",&pos);
                printf("%lld\n",query(dTime[pos],1,clock,1));
            }
            else{
                scanf("%lld%lld",&l,&r);
                update(dTime[l],fTime[l],r,1,clock,1);
            }
        }


    }
    return 0;
}