hdu 4366 线段树＋dfs对树按子树分段

就是用dfs扫一遍将记录子树的段，然后维护段内的最大值，先对员工按照能力从大到小排序，能力相同的按照id从小到大排序，那么按照这个顺序插入，能力强的先出入，只需找到段中最大忠诚的即可，因为id小的先进，所以不会出现子树中存在能力相同的子孙的情况，数组开小了，wrong成狗．．．．

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#define MAX 50007

using namespace std;

struct Node
{
    int a,b,c,id;
    bool operator < ( const Node& p ) const 
    {
        if ( c == p.c ) return id < p.id;
        return c > p.c;
    }
}p[MAX];

int t,n,m;

struct Edge 
{
    int v,next;
}e[MAX<<1];

int head[MAX];
int cc,dep;

void add ( int u , int v )
{
    e[cc].v = v;
    e[cc].next = head[u];
    head[u] = cc++;
}

int first[MAX],back[MAX],tid[1000007];

void dfs ( int u , int p )
{
    first[u] = ++dep;
    for ( int i = head[u] ; ~i ; i = e[i].next )
    {
        int v = e[i].v;
        if ( v == p ) continue;
        dfs ( v , u );
    }
    back[u] = dep;
}

struct Tree
{
    int l , r , maxn;
}tree[MAX<<2];

void build ( int u , int l , int r )
{
    tree[u].l = l , tree[u].r = r;
    tree[u].maxn = -1;
    if ( l == r ) return;
    int mid = l + r >> 1;
    build ( u<<1 , l , mid );
    build ( u<<1|1 , mid+1 , r );           
}

void push_up ( int u )
{
    tree[u].maxn = max ( tree[u<<1].maxn , tree[u<<1|1].maxn );
}

void update ( int u , int x , int v )
{
    int l = tree[u].l , r = tree[u].r;
    if ( l == r )
    {
        tree[u].maxn = v;
        return;
    }
    int mid = l + r >> 1;
    if ( x > mid ) update ( u<<1|1 , x , v );
    else update ( u<<1 , x , v );
    push_up ( u );
}

int query ( int u , int left , int right )
{
    int l = tree[u].l , r = tree[u].r;
    if ( left <= l && r <= right )
        return tree[u].maxn;
    int mid = l + r >> 1;
    int ret = -1;
    if ( left <= mid && right >= l ) 
        ret = max ( ret , query ( u<<1 , left , right ) );
    if ( left <= r && right > mid )
        ret = max ( ret , query ( u<<1|1 , left , right ) );
    return ret;
}

int ans[MAX];

int main ( )
{
    scanf ( "%d" , &t );
    while ( t-- )
    {
        scanf ( "%d%d" , &n , &m );
        memset ( head , -1 , sizeof ( head ) );
        cc = 0;
        for ( int i = 1 ; i < n ; i++ )
        {
            scanf ( "%d%d%d" , &p[i].a , &p[i].b , &p[i].c );
            p[i].id = i;
            tid[p[i].b] = i;
            add ( p[i].a , i );
            add ( i , p[i].a );
        }
        dep = -1;
        dfs ( 0 , -1 );
        sort ( p+1 , p+n );
        build ( 1 , 1 , n );
        memset ( ans , -1 , sizeof ( ans ));
        for ( int i = 1 ; i < n ; i++ )
        {
            int id = p[i].id;
            ans[id] = query ( 1 , first[id] , back[id] );
            if ( ans[id]!= -1 ) ans[id] = tid[ans[id]]; 
            update ( 1 , first[id] , p[i].b );
        }
        int q;
        for ( int i = 1 ; i <= m ; i++ )
        {
            scanf ( "%d" , &q );
            printf ( "%d\n" , ans[q] );
        }
    }
}