HLD solution for Promotion Counting(Platinum)

solutions/gold/usaco-696.mdx

@@ -3,6 +3,7 @@ id: usaco-696
 source: USACO Platinum 2017 January
 title: Promotion Counting
 author: Benjamin Qi, Timothy Gao, William Yuan
+contributors: Vaishnav Krishnan
 ---
 
 [Official Editorial (Java)](http://www.usaco.org/current/data/sol_promote_platinum_jan17.html)
@@ -306,10 +307,117 @@ int main() {
 </CPPSection>
 </LanguageSection>
 
-<IncompleteSection>
+## Solution 3: HLD
 
-Add Centroid Decomp/HLD Solution
+**Time Complexity:** $\mathcal{O}(N\log ^2N)$
+
+Sort the nodes from largest to smallest value, do path updates from each node to the root.
+
+<LanguageSection>
+<CPPSection>
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class segTree {
+  private:
+	vector<int> segtree;
 
-Sort nodes from largest to smallest value, do path updates from itself the root.
+  public:
+	segTree(int N) {
+		if (__builtin_popcount(N) > 1) N = 1 << (32 - __builtin_clz(N));
+		segtree.resize(N << 1, 0);
+	}
+	void update(int i, int val) {
+		for (i += (int)segtree.size() >> 1; i > 0; i >>= 1) segtree[i] += val;
+	}
+	int query(int l, int r) {
+		int ans = 0;
+		for (l += (int)segtree.size() >> 1, r += ((int)segtree.size() >> 1) + 1; l < r;
+		     l >>= 1, r >>= 1) {
+			if (l & 1) ans += segtree[l++];
+			if (r & 1) ans += segtree[--r];
+		}
+		return ans;
+	}
+};
 
-</IncompleteSection>
+void dfs_hld(vector<vector<int>> &edges, vector<vector<int>> &heavy_paths,
+             vector<int> &depth, vector<int> &sizes, int start) {
+	int heavy_child = -1;
+	++sizes[start];
+	for (int i : edges[start]) {
+		depth[i] = depth[start] + 1;
+		dfs_hld(edges, heavy_paths, depth, sizes, i);
+		sizes[start] += sizes[i];
+		if (heavy_child == -1 || sizes[heavy_child] < sizes[i]) heavy_child = i;
+	}
+	if (heavy_child != -1) {
+		swap(heavy_paths[start], heavy_paths[heavy_child]);
+		heavy_paths[start].push_back(heavy_child);
+	}
+}
+
+int main() {
+	ios_base::sync_with_stdio(false);
+	cin.tie(nullptr);
+	freopen("promote.in", "r", stdin);
+	freopen("promote.out", "w", stdout);
+	int N;
+	cin >> N;
+	vector<pair<int, int>> cow_proficiency(N, pair<int, int>());
+	for (int i = 0; i < N; ++i) {
+		cin >> cow_proficiency[i].first;
+		cow_proficiency[i].second = i;
+	}
+	vector<vector<int>> edges(N, vector<int>()), heavy_paths(N, vector<int>());
+
+	vector<int> sizes(N, 0), heavy_index(N, -1), path_index(N, -1), depth(N, 0),
+	    parents(N, -1), ans(N, 0), cur_ans(N, 0);
+
+	for (int i = 1; i < N; ++i) {
+		cin >> parents[i];
+		edges[--parents[i]].push_back(i);
+	}
+
+	dfs_hld(edges, heavy_paths, depth, sizes, 0);
+	vector<segTree> segtrees(N, segTree(0));
+	for (int i = 0; i < N; ++i) {
+		reverse(heavy_paths[i].begin(), heavy_paths[i].end());
+		for (int j = 0; j < (int)heavy_paths[i].size(); ++j) {
+			heavy_index[heavy_paths[i][j]] = i;
+			path_index[heavy_paths[i][j]] = j;
+		}
+		segtrees[i] = segTree((int)heavy_paths[i].size());
+	}
+
+	sort(cow_proficiency.begin(), cow_proficiency.end(), greater<pair<int, int>>());
+	for (auto &p : cow_proficiency) {
+		if (heavy_index[p.second] != -1) {
+			ans[p.second] =
+			    segtrees[heavy_index[p.second]].query(0, path_index[p.second]);
+		} else ans[p.second] = cur_ans[p.second];
+		p.second = parents[p.second];
+		while (p.second >= 0) {
+			if (heavy_index[p.second] != -1) {
+				segtrees[heavy_index[p.second]].update(0, 1);
+				if (path_index[p.second] + 1 <
+				    (int)heavy_paths[heavy_index[p.second]].size()) {
+					segtrees[heavy_index[p.second]].update(path_index[p.second] + 1,
+					                                       -1);
+				}
+				p.second = parents[heavy_paths[heavy_index[p.second]][0]];
+			} else {
+				++cur_ans[p.second];
+				p.second = parents[p.second];
+			}
+		}
+	}
+	for (int i = 0; i < N; ++i) cout << ans[i] << '\n';
+	return 0;
+}
+```
+
+</CPPSection>
+</LanguageSection>