Assign the task---hdu3974（线段树优化+dfs）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3974

题意就是：公司有n个员工，关系有n-1个，T x y 代表把工作y交给员工x；

员工可以把工作交给下属；

本来是线段树的题，但是我真心看不懂，所以就找了个能看懂的方法了

 

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
#define N 50050

int f[N];
struct node
{
    int task, order;
}a[N];
int Query(int x)
{
    int order = -1, ans = -1;
    while(x != 0)
    {
        if(a[x].order > order)
        {
            ans = a[x].task;
            order = a[x].order;
        }
        x = f[x];
    }
    return ans;
}

int main()
{
    int T, n, m, t=1, x, y;
    char s[10];
    scanf("%d", &T);
    while(T--)
    {

        scanf("%d", &n);
        memset(a, -1, sizeof(a));
        memset(f, 0, sizeof(f));
        for(int i=1; i<=n-1; i++)
        {
            scanf("%d %d", &x, &y);
            f[x] = y;
        }
        scanf("%d", &m);
        printf("Case #%d:
", t++);
        for(int i=1; i<=m; i++)
        {
            scanf("%s", s);
            if(s[0] == 'C')
            {
                scanf("%d", &x);
                printf("%d
", Query(x));
            }
            else
            {
                scanf("%d %d", &x, &y);
                a[x].order = i;//工作的顺序；
                a[x].task = y;
            }
        }
    }
    return 0;
}

 看了学长的代码，有点理解了，就写了一下；

补充一下线段树的方法吧

可以用每个节点的所包含的子节点段来当做线段树的节点，查找每个节点所包含的段可以用简单的DFS实现。

 

#include<stdio.h>
#include<vector>
#include<iostream>
#include<string.h>
#include<algorithm>
#define N 50050
#define Lson r<<1
#define Rson r<<1|1
#define INF 0xfffffff
using namespace std;

int s[N], e[N], used[N], index;//s表示每个员工所有下属的开始和结束节点，包含本身
vector<int>G[N];

struct SegTree
{
    int L, R, task, vis;
    int mid()
    {
        return (L+R)>>1;
    }
    int len()
    {
        return R-L+1;
    }
}a[N<<2];
void dfs(int k)
{
    s[k]=++index;
    for(int i=0,len=G[k].size(); i<len; i++)
        dfs(G[k][i]);
    e[k]=index;
}
void BuildTree(int r, int L, int R)
{
    a[r].L =  L; a[r].R = R;
    a[r].task = -1; a[r].vis = 0;
    if(L == R)return ;

    BuildTree(Lson, L, a[r].mid());
    BuildTree(Rson, a[r].mid()+1,R);
}
void Down(int r)
{
    if(a[r].L != a[r].R && a[r].vis == 1)
    {
        a[Lson].vis = a[Rson].vis = 1;
        a[Lson].task = a[Rson].task = a[r].task;
        a[r].vis = 0;
    }
}
void Update(int r, int L, int R, int k)
{
    Down(r);
    if(a[r].L == L && a[r].R == R)
    {
        a[r].task = k;
        a[r].vis = 1;
        return;
    }

    if(R <= a[r].mid())
        Update(Lson, L, R, k);
    else if(L > a[r].mid())
        Update(Rson, L, R, k);
    else
    {
        Update(Lson, L, a[r].mid(), k);
        Update(Rson, a[r].mid()+1, R, k);
    }
}
int Query(int r, int k)
{
    Down(r);
    if(a[r].L == a[r].R)
        return a[r].task;
    if(k<=a[r].mid())
        return Query(Lson, k);
    else
        return Query(Rson, k);
}
int main()
{
    int T, t=1, n, m, x, y, u, v;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        memset(used, 0, sizeof(used));
        for(int i=0;i<=n;i++)
            G[i].clear();
        for(int i=1; i<n; i++)
        {
            scanf("%d %d", &u, &v);
            G[v].push_back(u);
            used[u] = 1;
        }
        index = 0;
        for(int i=1; i<=n; i++)
        {
            if(used[i]==0)
            {
                dfs(i);break;
            }
        }
        BuildTree(1, 1, n);
        printf("Case #%d:
", t++);
        scanf("%d", &m);
        while(m--)
        {
            char str[5];
            scanf("%s", str);
            if(str[0]=='C')
            {
                scanf("%d", &x);
                printf("%d
", Query(1,s[x]));
            }
            else
            {
                scanf("%d%d", &x, &y);
                Update(1, s[x], e[x], y);
            }
        }
    }
    return 0;
}

 很久之后的今天20160505再来看这道题，完全不是很难看懂的状态了

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <stack>
#include <vector>
using namespace std;
typedef long long LL;
#define met(a, b) memset(a, b, sizeof(a))
#define N 50011
#define Lson r<<1
#define Rson r<<1|1

struct node
{
    int L, R, task, flag;///flag表示此区间是否被全部覆盖，如果是那么task表示此区间的工作是什么；
    int Mid(){ return (L+R)/2; }
    int Len(){ return (R-L+1); }
}a[N*4];

vector<vector<int> >G;
int s[N], e[N], du[N], Index;

void dfs(int u)
{
    s[u] = ++Index;///相当于是记录u得起始下属下标，结束下标在递归回来的时候确定的，
    int len = G[u].size();
    for(int i=0; i<len; i++)
        dfs(G[u][i]);
    e[u] = Index;
}

void Build(int r, int L, int R)
{
    a[r].L = L, a[r].R = R; a[r].task = -1;
    if( L == R )return;
    Build(Lson, L, a[r].Mid());
    Build(Rson, a[r].Mid()+1, R);
}

void Down(int r)
{
    if(a[r].flag && a[r].L != a[r].R)
    {
        a[Lson].flag = a[Rson].flag = a[r].flag;
        a[Lson].task = a[Rson].task = a[r].task;
        a[r].flag = 0;
    }
}

void Update(int r, int L, int R, int task)
{
    if(a[r].L == L && a[r].R == R)
    {
        a[r].flag = 1;
        a[r].task = task;
        return ;
    }
    Down(r);
    if( R <= a[r].Mid() )
        Update(Lson, L, R, task);
    else if( L > a[r].Mid() )
        Update(Rson, L, R, task);
    else
    {
        Update(Lson, L, a[r].Mid(), task);
        Update(Rson, a[r].Mid()+1, R, task);
    }
}
int Query(int r, int pos)
{
    Down(r);///因为上面也许没有更新到最底部，所以要再接着往下压；

    if(a[r].L == a[r].R)///找到叶子节点，并返回；
        return a[r].task;

    if(pos <= a[r].Mid())
        return Query(Lson, pos);
    else
        return Query(Rson, pos);
}

int main()
{
    int T, n, m, u, v, x, y, t = 1;
    scanf("%d", &T);
    while(T--)
    {
        met(du, 0); met(s, 0); met(e, 0);

        scanf("%d", &n);

        G.clear();
        G.resize(n+5);

        for(int i=1; i<n; i++)
        {
            scanf("%d %d", &u, &v);
            G[v].push_back(u);
            du[u] = 1;
        }
        Index = 0;
        for(int i=1; i<=n; i++)
        {
            if(!du[i])///找到根节点，然后按照递归的形式找到自己连续的下属；
            {
                dfs(i);break;
            }
        }
        Build(1, 1, n);
        scanf("%d", &m);
        printf("Case #%d:
", t++);
        while(m--)
        {
            char ch[15];
            scanf("%s", ch);
            if(ch[0]=='T')
            {
                scanf("%d %d", &x, &y);
                Update(1, s[x], e[x], y);///更新的是x这个人的所有下属；
            }
            else
            {
                scanf("%d", &x);
                printf("%d
", Query(1, s[x]));
            }
        }
    }
    return 0;
}