HDU - 3974 Assign the task （DFS建树+区间覆盖+单点查询）

题意：一共有n名员工， n-1条关系， 每次给一个人分配任务的时候，（如果他有）给他的所有下属也分配这个任务， 下属的下属也算自己的下属， 每次查询的时候都输出这个人最新的任务（如果他有）， 没有就输出-1。

题解：需要用DFS建树来确立关系， 然后用线段树进行区间覆盖。

DFS建树： 从Boss 开始dfs，通过dfs递归时编号出现的先后顺序来确定某个员工对应的起点与终点。

样例的关系图是这样的

当dfs建树跑完了之后各个节点对应的位置是这样的

其中Start表示这个节点本身的新编号和这个节点管辖区间内的左端点 End表示这个点管辖区间内的右端点

从右边的图中可以看见其中的最上级2号员工（Boss）， 他的管辖区间是[1,5]，能覆盖所有人的结点， 5号员工他没有下属所以他的End值就等于Start值。

（发布于第二天的修改， 竟然被吐槽写的不好理解， 非要我再加上下面这幅图）

上面这幅图呢就是线段树下的员工状态图了， 假设我们现在对2号员工分配任务y1

那我们就需要对2号员工的管辖区域[1,5]区间的值都修改成y1。

再注意一下 管辖区域的左端点 还代表的这名员工在线段树下的区间下标是多少。

2号员工的管辖区域是[1,5] 所以他就在位置1。

管辖区域的右端点就是自己最多能管到员工的编号。

所以每次对自己的管辖区域进行线段树区域更新操作就可以将每个人的任务分配下去了。

这样每次查询某个员工的任务的时候只需要将lazy标记推到底，就能找到最后收到的任务了。

用DFS去访问每个节点，并将访问的顺序编号，当DFS遍历了整个关系图之后，每个人的管辖区间就确定下来了，然后就可以通过管辖区间来进行线段树区域覆盖和单点查询操作。

 int cnt = ;
 void dfs(int n)
 {
     Start[n] = ++cnt;
     int m = son[n].size();
     for(int i = ; i < m; i++)
         dfs(son[n][i]);//已经用vector son[n] 来存好了每个人的下属
     End[n] = cnt;
 }

 #include<iostream>
 #include<algorithm>
 #include<vector>
 #include<string>
 #include<cstring>
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 using namespace std;
 const int N = +;
 vector<int> son[N];
 int Start[N], End[N];
 int tree[N<<], lazy[N<<];
 bool vis[N];
 int cnt = ;
 void dfs(int n)
 {
     Start[n] = ++cnt;
     int m = son[n].size();
     for(int i = ; i < m; i++)
         dfs(son[n][i]);
     End[n] = cnt;
 }
 void PushDown(int rt)
 {
     if(lazy[rt] != -)
     {
         tree[rt<<] = tree[rt<<|] =  lazy[rt<<|] = lazy[rt<<] = lazy[rt];
         lazy[rt] = -;
     }
 }
 void Revise(int L, int R, int C, int l, int r, int rt)
 {
     if(L <= l && r <= R)
     {
         lazy[rt] = tree[rt] = C;
         return ;
     }
     PushDown(rt);
     int m =l+r >> ;
     if(L <= m) Revise(L,R,C,lson);
     if(m < R) Revise(L,R,C,rson);
 }
 int Query(int L, int l, int r, int rt)
 {
     if(l == r)
     {
         return tree[rt];
     }
     int m = l+r >> ;
     PushDown(rt);
     if(L <= m) return Query(L,lson);
     else return Query(L,rson);
 }
 int main()
 {
     ios::sync_with_stdio(false);
     cin.tie();
     cout.tie();
     int T;
     cin >> T;
     for(int i = ; i <= T; i++)
     {
         cout << "Case #" << i << ":\n";
         int n, u, v;
         cnt = ;
         cin >> n;
         for(int i = ; i <= n; i++)
             son[i].clear(), vis[i] = ;
         for(int i = ; i < n; i++)
         {
             cin >> u >> v;
             son[v].push_back(u);//用vector去对应的关系
             vis[u] = ;//如果某个点成为过下属就标记一下 没有标记过的那个人就是Boss(最上级）
         }
         int pos = -;
         for(int i = ; i <= n; i++)
             if(vis[i])
             {
                 pos = i;
                 break;
             }
         dfs(pos);//从最上级的人开始递归， 找到每个人对应的区间
         memset(tree, -, sizeof(tree));//因为没有接到任务过的人查询的时候输出-1
         memset(lazy, -, sizeof(lazy));//所以直接memset为-1就好了，不需要再进行特判
         int t;
         cin >> t;
         string str;
         int x, y;
         while(t--)
         {
             cin >> str;
             if(str[] == 'C')
             {
                 cin >> x;
                 cout << Query(Start[x],,cnt,) << endl;
             }
             else
             {
                 cin >> x >> y;
                 Revise(Start[x],End[x],y,,cnt,);
             }
         }
     }
     return ;
 }