hdu 4366 单点更新，区间查询最值

比赛的时候一看就是棵树，我还以为是个树dp呢，再看做出来的人那么少，就更是没上心。

没想到这是棵线段树！！！

题意：http://acm.hdu.edu.cn/showproblem.php?pid=4366

         给你一棵树，每个结点有两个属性值，1：能力值  2：忠诚度

         然后m个询问，每次询问一个整数u，求u的子树中能力值大于u的且忠诚度最大的点的编号

解：

思路：

          这题的重点是将树转化为一个线性序列后，用线段树去维护什么？

          首先，这个题目要求找的是子树中忠诚值最大的。这个倒是可以用线段树去维护。因为一个树的线性序列的子树都在一个连续序列（有个进入这棵子树的时间戳和出去的时间戳）中，所以只要像往常一样去维护一棵普通的求最大值的线段树即可。

         题目还要求能力要比根强。对于这个，我们的策略是先在线段树里面插入能力强的，再插入能力弱的。那么，前面的在查询的时候就不会查询到能力比自己弱的了。（能力一样的应该一起插入。）

实现：

         预处理：1.同时记录一个人的能力，忠诚度和编号。由于用线段树维护的是loyalty，那么最后询问出来的肯定也是loyalty的值，所以用map对loyalty和编号id进行一一映射（loyalty唯一，所以才能有一一映射的关系）。   2.将一棵树映射为一个线性序列，分别用两个数组去记录每个节点进去的时间和出去的时间。用深度优先搜索，有那么一点像线序遍历。3.按照能力值进行排序。
         4.按能力值从大到小一一批量处理，能力相同的为同一批。将答案存入一个数组当中。最后以O（1）的复杂度进行询问。

居然数组开小了，给WA了。改成大的就A了。

/*
Pro: 0

Sol:

date:
*/
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <map>
#include <stack>
#include <algorithm>
#define lson l, m , rt << 1
#define rson m + 1, r, rt << 1 | 1
#define maxn 50010
using namespace std;
struct people{
    int id,loty,abty;
    bool operator < (const people& cmp)const {
        return abty > cmp.abty;//能力从大到小排列
    }
}emp[maxn];
int Max[maxn << 2],t,n,m,ans[maxn],L[maxn],R[maxn],head[maxn],tot,ed;
map <int, int> mp;
struct Edge{
    int v,next;
}edge[maxn];
void add(int u,int v){
    edge[ed].v = v;
    edge[ed].next = head[u];
    head[u] = ed ++;
}
//void dfs(int rt){//这个是电脑的dfs，两个dfs都能过！
//    L[rt] = tot ++;
//    for(int i = head[rt]; i != -1; i = edge[i].next){
//        dfs(edge[i].v);
//    }
//    R[rt] = tot;
//}
void dfs(int root){//这是我手写的dfs
    bool vis[maxn];
    memset(vis,0,sizeof(vis));
    tot = 0;    stack <int> ss;
    while(!ss.empty()){ss.pop();}
    ss.push(root); vis[root] = true;    L[root] = tot ++;

    while(!ss.empty()){
        int now = ss.top();
        bool flag = false;
        for(int i = head[now]; i != - 1; i = edge[i].next){
            int x = edge[i].v;
            if(!vis[x]){
                flag = true;
                vis[x] = true;
                L[x] = tot ++;
                ss.push(x);
                head[now] = edge[i].next;
                break;//这个break绝对绝对不能忘。这样才是dfs
            }
        }
        if(flag)    continue;
        //flag为false的时候就是now这个点的孩子已经全部被访问过的时候，是时候pop了
        if(vis[now]){
            R[now] = tot;
            ss.pop();
        }
    }
}
int query(int L, int R, int l, int r, int rt){//区间询问
    if(L > R) return -1;
    if(L <= l && r <= R){
        return Max[rt];
    }int m = (l + r) >> 1;
    int ll = -1, rr = -1;
    if(L <= m) ll = query(L,R,lson);
    if(R > m) rr = query(L,R,rson);
    return max(ll,rr);
}
void update(int &pos, int &val, int l, int r, int rt){//单点更新
    if(l == r){
        Max[rt] = val;  return ;
    }int m = (l + r) >> 1;
    if(pos <= m) update(pos,val,lson);
    else update(pos,val,rson);
    Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]);
}
void pre(){//预处理
    mp.clear(); mp[-1] = -1;    tot = ed = 0;
    memset(L,0,sizeof(L));  memset(R,0,sizeof(R));  memset(ans,-1,sizeof(ans));
    memset(head,-1,sizeof(head));   memset(Max,-1,sizeof(Max));//相当于build。

    for(int i = 1,fa; i < n; i ++){
        scanf("%d%d%d",&fa,&emp[i].loty, &emp[i].abty);
        add(fa,i);
        mp[emp[i].loty] = i;
        emp[i].id = i;
    }
    dfs(0);

    sort(emp + 1,emp + n);
}
void showans(){
    int fired;
    while(m --){
        scanf("%d",&fired);
        printf("%d\n",ans[fired]);
    }
}
int main(){
    scanf("%d",&t);
    while(t --){
        scanf("%d%d",&n,&m);
        pre();
        for(int i = 1, j; i < n; i = j){
            j = i;
            while(j < n && emp[j].abty == emp[i].abty){
                int id = emp[j].id;
                int lo = query(L[id] + 1,R[id] - 1,0,tot - 1, 1);
                ans[id] = mp[lo];
                j ++;
            }
            j = i;
            while(j < n && emp[j].abty == emp[i].abty){
                int id = emp[j].id;
                update(L[id],emp[j].loty,0,tot - 1, 1);
                j ++;
            }
        }
        showans();
    }
    return 0;
}