hdu--3974 线段树 +dfs序 转自kuangbin大牛的博客，写一下自己的理解，原谅我这么弱

这道题 题意还是很简单：就是说在一个公司里面，每个人都会有自己的直接老板， 于是人与人之间的关系就会构成一颗树， 现在有操作给某个人布置一个任务x，那么这个人会把这个任务交给他的下属（他下属也会交给下属的下属） , 还有一个操作就是查询某个人正在做的工作是什么。
最多50000个人，最多有50000次操作，意味着在50000个人里面 需要在200次操作要得到结果，所以线段树肯定是可以做到的。（深度不会超过200）

如何将线段树和公司员工之间的关系树联系起来是窝一直都没想清楚的一个地方。 后来去kuangbin大牛的博客上学习了一波，感觉应该是看懂了。膜拜一波！

先讲解一下我所理解的想法吧：
因为先会输入有N个人 自然先构建线段树1-n (假如 N=5)

                             [1,5]
                [1,3]                   [4,5]
          [1,2]       [3,3]         [4,4]   [5,5]
   [1,1]     [2,2]        

然后我们来看看公司之间的员工，（就拿样例吧）

                      2
                 3         5
             4     1
          dfs排序之后 就变成这样了：
                 start[2]=1
        start[5]=2               start[3]=3
        end[5]=2                        
                             start[1]=4      start[4]=5                        
                             end[1]=4        end[4]=5
                 end[2]=end[3]=5;

              所以 之后的区间都是[ start[u] , end[u] ]

代码中的addedge(int u,int v) 是为了后面的dfs排序而服务的。
输入完每一段之后就会变成：
tot——0; ——-addedge(3,4)
edge[0].to=4
edge[0].next=head[3] (-1);
head[3]=tot //(0)
tot———1, ——-addedge(2,3)
edge[1].to=3
edge[1].next=head[2] (-1);
head[2]=tot //(1)
tot———2; ——-addedge(3,1)
edge[2].to=1;
edge[2].next=head[3]
head[3]=tot //(2)
tot———-3; ——-addedge(2,5)
edge[3].to=5
edge[3].next=head[2]
head[2]=3;

当然还有 used[2],[3],[4],[5]都变成true了，于是可以找到大boss 2；
既然找到了大boss 那接下来我们就可以将公司的员工排序了

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;

const int MAXN = 50010;
struct Edge
{
    int to,next;
}edge[MAXN];
int head[MAXN],tot;
int cnt;
int start[MAXN],end[MAXN];
void init()
{
    cnt = 0;
    tot = 0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)    //整个函数就是为了dfs和建树而服务
{
    edge[tot].to = v;    //记录u的下属 就是v。
    edge[tot].next = head[u];   //这一步很精髓，是为了dfs是的for循环而作，表示如果u之前没有和别人建立下属关系，那么head[u]=-1，如果有建立下属关系，那么我们可以在u=head[u] 里面去找u的另外一个下属。 其实就是一个链式前向星结构
    head[u] = tot++;    //这里的head[u]其实就是记录一下tot,为了找到         edge[tot].to,也就是u的下属。
}
void dfs(int u)   //为了建树而排序
{
    ++cnt;       // cnt就是排序的序号
    start[u] = cnt;    //将序号保存在start[] 数组里面
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        dfs(edge[i].to);    //这里就体现之前addedge的作用
    }
    end[u] = cnt;      //区间的后端   区间：[start[u],end[u]]
}
struct Node
{
    int l,r;
    int val;    //这个是表示正在做的工作
    int lazy;   //lazy tag 表示这个区间的所有子区间 都打上了lazy的标记
}segTree[MAXN*4];
void Update_Same(int r,int v)   //即 更新区间r
{
    if(r)
    {
        segTree[r].val = v;
        segTree[r].lazy = 1;
    }
}
void push_down(int r)    //作用：更新区间的左右子树+取消标记
{
    if(segTree[r].lazy)
    {
        Update_Same(r<<1,segTree[r].val);
        Update_Same((r<<1)|1,segTree[r].val);
        segTree[r].lazy = 0;
    }
}
void Build(int i,int l,int r)  //建树
{
    segTree[i].l = l;
    segTree[i].r = r;
    segTree[i].val = -1;
    segTree[i].lazy = 0;
    if(l == r)return;
    int mid = (l+r)/2;
    Build(i<<1,l,mid);
    Build((i<<1)|1,mid+1,r);
}
void update(int i,int l,int r,int v)  //分配工作
{
    if(segTree[i].l == l && segTree[i].r == r)
    {
        Update_Same(i,v);
        return;
    }
    push_down(i);
    int mid = (segTree[i].l + segTree[i].r)/2;
    if(r <= mid) update(i<<1,l,r,v);
    else if(l > mid) update((i<<1)|1,l,r,v);
    else
    {
        update(i<<1,l,mid,v);
        update((i<<1)|1,mid+1,r,v);
    }
}
int query(int i,int u)
{
    if(segTree[i].l == u && segTree[i].r == u)
        return segTree[i].val;
    push_down(i);        //查询一步，更新一步,不查询的不更新
    int mid = (segTree[i].l + segTree[i].r)/2;  
    if(u <= mid)return query(i<<1,u);
    else return query((i<<1)|1,u);
}
bool used[MAXN];
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n;
    int T;
    scanf("%d",&T);
    int iCase = 0;
    while(T--)
    {
        iCase++;
        printf("Case #%d:\n",iCase);
        int u,v;
        memset(used,false,sizeof(used));
        init();
        scanf("%d",&n);
        for(int i = 1;i < n;i++)
        {
            scanf("%d%d",&u,&v);
            used[u] = true;
            addedge(v,u);
        }
        for(int i = 1;i <= n;i++)
            if(!used[i])
            {
                dfs(i);
                break;
            }
        Build(1,1,cnt);
        char op[10];
        int m;
        scanf("%d",&m);
        while(m--)
        {
            scanf("%s",op);
            if(op[0] == 'C')
            {
                scanf("%d",&u);
                printf("%d\n",query(1,start[u]));
            }
            else
            {
                scanf("%d%d",&u,&v);
                update(1,start[u],end[u],v);
            }
        }
    }
    return 0;
}