HDU-3974 Assign the task（多叉树DFS时间戳建线段树）

http://acm.hdu.edu.cn/showproblem.php?pid=3974

Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Problem Description

There is a company that has N employees(numbered from 1 to N),every employee in the company has a immediate boss (except for the leader of whole company).If you are the immediate boss of someone,that person is your subordinate, and all his subordinates are your subordinates as well. If you are nobody's boss, then you have no subordinates,the employee who has no immediate boss is the leader of whole company.So it means the N employees form a tree.
The company usually assigns some tasks to some employees to finish.When a task is assigned to someone,He/She will assigned it to all his/her subordinates.In other words,the person and all his/her subordinates received a task in the same time. Furthermore,whenever a employee received a task,he/she will stop the current task(if he/she has) and start the new one.
Write a program that will help in figuring out some employee’s current task after the company assign some tasks to some employee.

Input

The first line contains a single positive integer T( T <= 10 ), indicates the number of test cases.
For each test case:
The first line contains an integer N (N ≤ 50,000) , which is the number of the employees.
The following N - 1 lines each contain two integers u and v, which means the employee v is the immediate boss of employee u(1<=u,v<=N).
The next line contains an integer M (M ≤ 50,000).
The following M lines each contain a message which is either
"C x" which means an inquiry for the current task of employee x
or
"T x y"which means the company assign task y to employee x.
(1<=x<=N,0<=y<=10^9)

Output

For each test case, print the test case number (beginning with 1) in the first line and then for every inquiry, output the correspond answer per line.

Sample Input

1 
5 
4 3 
3 2 
1 3 
5 2 
5 
C 3 
T 2 1
C 3 
T 3 2 
C 3

Sample Output

Case #1:
-1 
1 
2

题意：

公司中有N个职员，只有一个老板，其余每个职员对应一个上司，这N个职员刚好组成一棵树。然后有M个操作。

当给一个职员x分配任务y时（即 T x y)，x及其下属及其下属的下属都会放下手头的工作去完成任务y。对于每次询问（即C x），程序输出职员x正在进行什么任务。

简而言之：给出一个有向多叉树，初始所有节点为-1.有两种操作，一种为(T,x,y)，表示将x节点及其的所有子树中的节点变为y，另一种为(C,x)，为求x节点的值。

题解：

这道题的难点就在于如何将题中的对应关系转化为线段树的模型，在于如何处理好多叉树和线段树间的映射关系。

线段树的本质就是对一整段连续区间进行操作。所以这道题的关键就在于清楚怎么将对多叉树的操作转化成对一整段连续区间的操作。

很明显该公司的所有员工间的关系可以用一颗多叉树来表示。然后从公司老板（也就是入度为0的点）出发，用dfs给这棵树打上时间戳，确定每个点的影响范围并记录下来。

根据新分配的id号码将其节点对应映射到线段树上面。这样分配任务就相当于更新一段连续的节点，查询任务相当于单点查询。

代码如下：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <math.h>
const int INF=0x3f3f3f3f;
typedef long long LL;
const int mod=1e9+7;
//const double PI=acos(-1);
const int maxn=1e5+10;
using namespace std;
//ios::sync_with_stdio(false);
//    cin.tie(NULL);

struct Edge_node
{
    int v;
    int next;
}Edge[50005*2];

struct SegTree_node
{
    int l;
    int r;
    int num;
}SegTree[50005<<2];
int n,m;
int cnt;//边的计数器，从0开始 
int num;//线段树序号的计数器，从1开始 
int head[50005];
int vis[50005];//是否有上司，即入度为0 
int st[50005];//开始遍历时的编号，同时作为线段树中的序号 
int ed[50005];//遍历结束后的序号，表示该点在线段树中可以影响的最后一个序号(即上司)

void init()//初始化 
{
    cnt=0;
    num=0; 
    memset(head,-1,sizeof(head));
    memset(st,0,sizeof(st));
    memset(ed,0,sizeof(ed));
    memset(Edge,0,sizeof(Edge));
    memset(vis,0,sizeof(vis));
}

void add_edge(int u,int v)
{
    Edge[cnt].v=v;
    Edge[cnt].next=head[u];
    head[u]=cnt++; 
}

void DFS(int u)
{
    num++;
    st[u]=num;
    for(int i=head[u];i!=-1;i=Edge[i].next)
    {
        DFS(Edge[i].v);
    }
    ed[u]=num;
}

void PushDown(int rt)
{
    if(SegTree[rt].num!=-1)
    {
        SegTree[rt<<1].num=SegTree[rt<<1|1].num=SegTree[rt].num;
        SegTree[rt].num=-1;
    }
}

void Build(int l,int r,int rt)
{
    SegTree[rt].l=l;
    SegTree[rt].r=r;
    SegTree[rt].num=-1;
    if(l==r)
        return ;
    int mid=(l+r)>>1;
    Build(l,mid,rt<<1);
    Build(mid+1,r,rt<<1|1);
}

void Update(int L,int R,int C,int rt)
{
    int l=SegTree[rt].l;
    int r=SegTree[rt].r; 
    if(L<=l&&R>=r)
    {
        SegTree[rt].num=C;
        return ;
    }
    PushDown(rt);
    int mid=(l+r)>>1;
    if(L<=mid)
        Update(L,R,C,rt<<1);
    if(R>mid)
        Update(L,R,C,rt<<1|1);
}

int Query(int L,int rt)
{
    int l=SegTree[rt].l;
    int r=SegTree[rt].r;
    if(l==r)
        return SegTree[rt].num;
    PushDown(rt);
    int mid=(l+r)>>1;
    if(L<=mid)
        Query(L,rt<<1);
    else if(L>mid)
        Query(L,rt<<1|1);
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int k=1;k<=T;k++)
    {
        printf("Case #%d:
",k);
        init();
        scanf("%d",&n);
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d %d",&u,&v);
            vis[u]=1;
            add_edge(v,u);
        }
        for(int i=1;i<=n;i++)
        {
            if(!vis[i])
            {
                DFS(i);
                break;
            }
        }
        Build(1,num,1);
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            char c[5];
            int x;
            scanf("%s %d",c,&x);
            if(c[0]=='C')
            {
                printf("%d
",Query(st[x],1));
            } 
            else if(c[0]=='T')
            {
                int t;
                scanf("%d",&t);
                //st[x]->ed[x]代表x及x的下属在线段树中的区间范围 
                Update(st[x],ed[x],t,1);
            }
        }
    }
    return 0;
}