【HDOJ】4366 Successor

基本思路是将树形结构转换为线性结构。然后，所求即为一个区间内大于abi的最大的loy指向的ID。
将结点按照abi降序排序，注意abi可能相等。
然后，使用线段树单点更新，区间查询可解。

/* 4366 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

typedef struct node_t {
    int abi, id;
    
    friend bool operator< (const node_t& a, const node_t& b) {
        return a.abi > b.abi;
    }
    
} node_t;

typedef struct {
    int v, nxt;
} edge_t;

const int maxv = 50005;
const int maxn = 50005;
int abi[maxv], loy[maxv];
int head[maxv];
edge_t E[maxv];
int mx[maxn<<2];
int ID[maxn<<2];
int Beg[maxv], End[maxv], dfs_clock;
node_t nd[maxn];
int ans[maxn];
int n, m, l;

void init() {
    memset(head, -1, sizeof(head));
    l = dfs_clock = 0;
}

void addEdge(int u, int v) {
    E[l].v = v;
    E[l].nxt = head[u];
    head[u] = l++;
}

inline void PushUp(int rt) {
    int lb = rt<<1;
    int rb = lb|1;
    
    if (mx[lb] > mx[rb]) {
        mx[rt] = mx[lb];
        ID[rt] = ID[lb];
    } else {
        mx[rt] = mx[rb];
        ID[rt] = ID[rb];
    }
}

void Build(int l, int r, int rt) {
    mx[rt] = -1;
    if (l == r)
        return ;
    
    int mid = (l + r) >> 1;
    Build(lson);
    Build(rson);
    
    PushUp(rt);
}

void Update(int x, int id, int val, int l, int r, int rt) {
    if (l == r) {
        mx[rt] = val;
        ID[rt] = id;
        return ;
    }
    
    int mid = (l + r) >> 1;
    
    if (x <= mid)
        Update(x, id, val, lson);
    else
        Update(x, id, val, rson);
    
    PushUp(rt);
}

pii Query(int L, int R, int l, int r, int rt) {
    if (L==l && R==r) {
        return mp(mx[rt], ID[rt]);
    }
    
    int mid = (l + r) >> 1;
    
    if (R <= mid) {
        return Query(L, R, lson);
    } else if (L > mid) {
        return Query(L, R, rson);
    } else {
        pii ltmp = Query(L, mid, lson);
        pii rtmp = Query(mid+1, R, rson);
        if (ltmp.fir > rtmp.fir)
            return ltmp;
        else
            return rtmp;
    }
}

void dfs(int u) {
    int v, k;
    
    Beg[u] = ++dfs_clock;
    for (k=head[u]; k!=-1; k=E[k].nxt) {
        v = E[k].v;
        dfs(v);
    }
    End[u] = dfs_clock;
}

void solve() {
    
    dfs(0);
    int nn = dfs_clock;
    memset(mx, -1, sizeof(mx));
    
    rep(i, 1, n) {
        nd[i-1].abi = abi[i];
        nd[i-1].id = i;
    }
    
    int mm = n - 1;
    sort(nd, nd+mm);
    
    int u;
    pii p;
    int i = 0;
    
    while (i < mm) {
        int j = i;
        while (i<mm && nd[i].abi==nd[j].abi) {
            u = nd[i].id;
            int l = Beg[u]+1;
            int r = End[u];
            if (l > r) {
                ans[u] = -1;
            } else {
                p = Query(l, r, 1, nn, 1);
                ans[u] = p.fir==-1 ? -1:p.sec;
            }
            ++i;
        }
        
        while (j < i) {
            u = nd[j].id;
            Update(Beg[u], u, loy[u], 1, nn, 1);
            ++j;
        }
    }
    
    
    while (m--) {
        scanf("%d", &u);
        printf("%d\n", ans[u]);
    }
} 

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif
    
    int t;
    int u;
    
    scanf("%d", &t);
    while (t--) {
        init();
        scanf("%d %d", &n, &m);
        rep(i, 1, n) {
            scanf("%d %d %d", &u, &loy[i], &abi[i]);
            addEdge(u, i);
        }
        solve();
    }
    
    #ifndef ONLINE_JUDGE
        printf("time = %d.\n", (int)clock());
    #endif
    
    return 0;
}

 数据发生器。

from copy import deepcopy
from random import randint, shuffle
import shutil
import string


def GenDataIn():
    with open("data.in", "w") as fout:
        t = 10
        fout.write("%d\n" % (t))
        for tt in xrange(t):
            n = randint(200, 300)
            m = randint(200, 300)
            fout.write("%d %d\n" % (n, m))
            ust = [0]
            st = set()
            for i in xrange(1, n):
                idx = randint(0, len(ust)-1)
                a = ust[idx]
                b = randint(0, 105)
                while True:
                    c = randint(0, 10**6)
                    if c not in st:
                        break
                st.add(c)
                fout.write("%d %d %d\n" % (a, c, b))
                ust.append(i)
            L = []
            for i in xrange(m):
                x = randint(1, n-1)
                L.append(x)
            fout.write("\n".join(map(str, L)) + "\n")    
            
def MovDataIn():
    desFileName = "F:\eclipse_prj\workspace\hdoj\data.in"
    shutil.copyfile("data.in", desFileName)

    
if __name__ == "__main__":
    GenDataIn()
    MovDataIn()