HDRF

input/code.cpp: In function 'void make(int, int&)':
input/code.cpp:39:35: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for (int k = 0; k < kids[i].size(); ++k) {
                                   ^
input/code.cpp: In function 'void make_cover(int, int)':
input/code.cpp:99:35: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for (int k = 0; k < kids[i].size(); ++k) {
                                   ^
input/code.cpp: In function 'int main()':
input/code.cpp:138:32: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for (int i = 0; i < nums.size(); ++i) {
                                ^

#include <iostream>
#include <vector>
#include <algorithm>
const int inf = 1e9 + 7;
const int N = 1e5 + 1;
const int M = 9;
std::vector<int> kids[N];
int par[N];
int cover[N][M];
int pri[N];
int depth[N];
 
// For LCA
int pos[N];
int segment[8 * N];
int h;
 
int get(int ls, int le, int i = 1, int s = 0, int e = h) {
	if (le < s || e < ls) return inf;
	if (ls <= s && e <= le) return segment[i];
	int mid = (s + e) / 2;
	int res = std::min(get(ls, le, 2 * i, s, mid), get(ls, le, 2 * i + 1, mid+1, e));
	return res;
}
 
void set(int i, int s, int e, int ind, int v) {
	if (ind < s || e < ind) return;
	if (s == e) { segment[i] = v; return; }
	int mid = (s + e) / 2;
	set(2 * i, s, mid, ind, v);
	set(2 * i + 1, mid+1, e, ind, v);
	segment[i] = std::min(segment[2 * i], segment[2 * i + 1]);	
}
 
void make(int i, int& s) {
	pos[i] = s;
	set(1, 0, h, s, depth[i]);
	++s;
	for (int k = 0; k < kids[i].size(); ++k) {
		make(kids[i][k], s);
		set(1, 0, h, s, depth[i]);
		++s;
	}
}
// End for LCA
 
struct Odd {
	int ind;
 
	bool operator< (const Odd& oth) const {
		int ap = pos[ind];
		int bp = pos[oth.ind];
		int lca = (ap < bp ? get(ap, bp) : get(bp, ap));
		if (depth[ind] == lca) {
			return false;
		} else if (depth[oth.ind] == lca) {
			return true;
		}
		int ai = ind;
		int k = 1;
		while(k > 0) {
			while((depth[cover[ai][k]] > lca) && (k < M)) {
				++k;
			}
			--k;
			ai = cover[ai][k];
		}
		k = 1;
		int bi = oth.ind;
		while(k > 0) {
			while((depth[cover[bi][k]] > lca) && (k < M)) {
				++k;
			}
			--k;
			bi = cover[bi][k];
		}
		return pri[ai] < pri[bi];
	}
};
 
int up(int val, int a, int k) {
	while((k >= 0) && (pri[cover[a][k]] < val)) {
		--k;
	}
	if (k >= 1) {
		return up(val, cover[a][k], k);
	} else {
		return cover[a][k+1];
	}
}
 
void make_cover(int i = 1, int d = 1) {
	depth[i] = d;
	cover[i][0] = i;
	cover[i][1] = up(pri[i], par[i], M-1);
	for (int j = 2; j < M-1; ++j) {
		cover[i][j] = cover[cover[i][j-1]][j-1];
	}
	for (int k = 0; k < kids[i].size(); ++k) {
		make_cover(kids[i][k], d + 1);
	}
}
 
int main() {
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(0);
	
	int n;
	std::cin >> n;
	
	par[1] = 0;
	for (int i = 2; i <= n; ++i) {
		std::cin >> par[i];
		kids[par[i]].push_back(i);
	}
	for (int i = 1; i <= n; ++i) {
		std::cin >> pri[i];
	}
	cover[1][0] = 1;
	depth[0] = 0;
	make_cover();
	h = 2 * n;
	int tmp = 1;
	while(tmp <= h) {
		tmp <<= 1;
	}
	h = tmp;
	--h;
	tmp = 0;	
	make(1, tmp);	
	std::vector<Odd> nums;
	for (int i = 1; i <= n; ++i) {
		Odd d;
		d.ind = i;
		nums.push_back(d);
	}
	std::sort(nums.begin(), nums.end());
	for (int i = 0; i < nums.size(); ++i) {
		std::cout << nums[i].ind << " ";
	}
	std::cout << "\n";
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: TIME LIMIT EXCEEDED

Test 3

Verdict: TIME LIMIT EXCEEDED

Test 4

Verdict: TIME LIMIT EXCEEDED

Test 5

Verdict: TIME LIMIT EXCEEDED

Test 6

Verdict: TIME LIMIT EXCEEDED

Test 7

Verdict: TIME LIMIT EXCEEDED

Test 8

Verdict: TIME LIMIT EXCEEDED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: TIME LIMIT EXCEEDED

Test 11

Verdict: TIME LIMIT EXCEEDED

Test 12

Verdict: TIME LIMIT EXCEEDED

Test 13

Verdict: TIME LIMIT EXCEEDED

Test 14

Verdict: TIME LIMIT EXCEEDED

Test 15

Verdict: TIME LIMIT EXCEEDED

Test 16

Verdict: TIME LIMIT EXCEEDED

Test 17

Verdict: TIME LIMIT EXCEEDED

Test 18

Verdict: TIME LIMIT EXCEEDED

Test 19

Verdict: TIME LIMIT EXCEEDED

Test 20

Verdict: TIME LIMIT EXCEEDED

Test 21

Verdict: TIME LIMIT EXCEEDED

Test 22

Verdict: TIME LIMIT EXCEEDED

Test 23

Verdict: TIME LIMIT EXCEEDED

Test 24

Verdict: TIME LIMIT EXCEEDED

Test 25

Verdict: TIME LIMIT EXCEEDED

Test 26

Verdict: TIME LIMIT EXCEEDED

Test 27

Verdict: TIME LIMIT EXCEEDED

Test 28

Verdict: TIME LIMIT EXCEEDED

Test 29

Verdict: TIME LIMIT EXCEEDED

Test 30

Verdict: TIME LIMIT EXCEEDED

Test 31

Verdict: TIME LIMIT EXCEEDED

Test 32

Verdict: TIME LIMIT EXCEEDED

Test 33

Verdict: TIME LIMIT EXCEEDED

Test 34

Verdict: TIME LIMIT EXCEEDED

Test 35

Verdict: TIME LIMIT EXCEEDED

Test 36

Verdict: TIME LIMIT EXCEEDED

Test 37

Verdict: TIME LIMIT EXCEEDED

Test 38

Verdict: TIME LIMIT EXCEEDED

Test 39

Verdict: TIME LIMIT EXCEEDED

Test 40

Verdict: TIME LIMIT EXCEEDED

Test 41

Verdict: TIME LIMIT EXCEEDED

Test 42

Verdict: TIME LIMIT EXCEEDED

Test 43

Verdict: TIME LIMIT EXCEEDED

Test 44

Verdict: TIME LIMIT EXCEEDED

Test 45

Verdict: TIME LIMIT EXCEEDED

Test 46

Verdict: TIME LIMIT EXCEEDED

Test 47

Verdict: TIME LIMIT EXCEEDED

Test 48

Verdict: TIME LIMIT EXCEEDED

Test 49

Verdict: TIME LIMIT EXCEEDED

Test 50

Verdict: TIME LIMIT EXCEEDED

Test 51

Verdict: TIME LIMIT EXCEEDED

Test 52

Verdict: TIME LIMIT EXCEEDED

Test 53

Verdict: TIME LIMIT EXCEEDED

Test 54

Verdict: TIME LIMIT EXCEEDED

Test 55

Verdict: TIME LIMIT EXCEEDED

Test 56

Verdict: TIME LIMIT EXCEEDED

Test 57

Verdict: TIME LIMIT EXCEEDED

Test 58

Verdict: TIME LIMIT EXCEEDED

Test 59

Verdict: TIME LIMIT EXCEEDED

Test 60

Verdict: TIME LIMIT EXCEEDED

Test 61

Verdict: TIME LIMIT EXCEEDED

Test 62

Verdict: TIME LIMIT EXCEEDED

Test 63

Verdict: ACCEPTED