【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 = ;
 const int maxn = ;
 int abi[maxv], loy[maxv];
 int head[maxv];
 edge_t E[maxv];
 int mx[maxn<<];
 int ID[maxn<<];
 int Beg[maxv], End[maxv], dfs_clock;
 node_t nd[maxn];
 int ans[maxn];
 int n, m, l;

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

 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<<;
     int rb = lb|;

     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] = -;
     if (l == r)
         return ;

     int mid = (l + r) >> ;
     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) >> ;

     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) >> ;

     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+, 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!=-; k=E[k].nxt) {
         v = E[k].v;
         dfs(v);
     }
     End[u] = dfs_clock;
 }

 void solve() {

     dfs();
     int nn = dfs_clock;
     memset(mx, -, sizeof(mx));

     rep(i, , n) {
         nd[i-].abi = abi[i];
         nd[i-].id = i;
     }

     int mm = n - ;
     sort(nd, nd+mm);

     int u;
     pii p;
     int i = ;

     while (i < mm) {
         int j = i;
         while (i<mm && nd[i].abi==nd[j].abi) {
             u = nd[i].id;
             int l = Beg[u]+;
             int r = End[u];
             if (l > r) {
                 ans[u] = -;
             } else {
                 p = Query(l, r, , nn, );
                 ans[u] = p.fir==- ? -:p.sec;
             }
             ++i;
         }

         while (j < i) {
             u = nd[j].id;
             Update(Beg[u], u, loy[u], , nn, );
             ++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, , 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 ;
 }

数据发生器。

 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()