Hello Codeforces,

Recently I was solving some more problems and came across IPSC 2015 G, Generating Synergy. I think the problem and my alternative solution are pretty cool.

TLDR: Store decreasing maxdepth monostack in each segtree node, for query, binary search $$$log N$$$ monostacks and get maximum update.

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1e6+5;
const ll mod = 1e9+7;
int uc[maxn], ul[maxn], N, C, Q, tin[maxn], tout[maxn], lv[maxn], rv[maxn], ct, cl;
vector<int> tr[maxn], st[4 * maxn];
void upd(int l, int r, int q, int x = 1, int tl = 1, int tr = N) {
	if(l > r) return;
	if(tl == l and tr == r) {
		//if earler update has lower maxdepth,
		//it will be completely overwritten by current update
		//so no need to store it anymore 
		while(st[x].size() and ul[st[x].back()] <= ul[q]) {
			st[x].pop_back();
		}
		st[x].push_back(q);
		return;
	}
	int tm = (tl+tr)/2;
	upd(l, min(tm, r), q, x*2, tl, tm);
	upd(max(tm+1,l), r, q, x*2+1, tm+1, tr);
}
int ask(int pos, int x = 1, int tl = 1, int tr = N) {
	//ans: latest update in segtree node x that applies to query node
	//which is last i in st[x] such that updatedepth[i] >= level[query node]  
	auto pp = partition_point(begin(st[x]), end(st[x]), [&](int i) {
		return ul[i] >= lv[rv[pos]];
	});
	int ans = pp == begin(st[x]) ? -1 : *prev(pp);
	if(tl == tr) return ans;
	int tm = (tl+tr)/2;
	if(pos <= tm) return max(ans, ask(pos, x*2, tl, tm));
	else return max(ans, ask(pos, x*2+1, tm+1, tr));
}
void eulertour(int x) {
	tin[x] = ++ct; 
	rv[ct] = x, lv[x] = ++cl;
	for(int e : tr[x]) eulertour(e);
	tout[x] = ct; --cl;	
}
signed main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cin >> N >> C >> Q;
	for(int i = 2; i <= N; i++) {
		int s; cin >> s;
		tr[s].push_back(i);
	}
	eulertour(1);
	ll res = 0;
	for(int g = 1; g <= Q; g++) {
		int a, l, co; cin >> a >> l >> co;
		if(co == 0) {
			int ek = ask(tin[a]);
			ll k = ek == -1 ? 1 : uc[ek];
			res += g * k; res %= mod;
		} else {
			uc[g] = co; ul[g] = lv[a] + l;
			upd(tin[a], tout[a], g);
		}
	}
	cout << res << '\n';
}

Abridged problem version: You are given a tree of $$$N$$$ nodes, rooted at node $$$1$$$. Initially, the value of all nodes is $$$1$$$. Handle $$$Q$$$ operations of 2 possible types:

• Update all nodes in subtree of node $$$a$$$ and depth $$$\le dep_a + l$$$ with value c. $$$dep_a$$$ (depth of node a) is defined to be number of nodes on the path from node $$$a$$$ to root node. So the root has depth $$$1$$$, the root's direct children have depth $$$2$$$...etc...
• Find the value of node $$$a$$$.

We first apply Euler Tour Technique. Then the original update operation is represented by updating all positions in $$$[tin_a, tout_a]$$$ with depth $$$\le dep_a + l$$$ (in other words, a maxdepth of $$$dep_a + l$$$), the query operation is to find value of position $$$tin_a$$$.

Then, let's try to incorporate segment tree (after all, this problem is basically Range Update Point Query). From now, we refer to nodes in the original tree as "positions" to avoid confusion with nodes in the segment tree. Each segment tree node will represent a range of positions, to do this we store in each node a resizable array (like std::vector).

For updates we "push" the update information to $$$O(log N)$$$ nodes.

For queries, we are tasked with finding the LRU (latest relevant update) of some position $$$a$$$. In other words, the latest update which changes the value of position $$$a$$$, i.e. has a maxdepth $$$>= dep_a$$$ and has been pushed to a segment tree node which contains $$$a$$$ (any update that has a chance of changing value of $$$a$$$ must have been pushed to a segtree node which contains position $$$a$$$.). There are ~$$$log N$$$ such nodes.

For each query you can independently find the LRU of each of the $$$log N$$$ nodes and then get the latest one. For each node, iterate through all updates pushed to that node and check their maxdepth. Then maximum time of the updates that satisfy the maxdepth constraint is the LRU for that node. But this approach is too slow :(

However!

When pushing an update to some segtree node, we know that all preexisting updates (in that node) with a $$$\le$$$ maxdepth will never be the LRU (it is trivial to prove this by contradiction). In other words, the only way a previous update can be the LRU is if it has a strictly greater maxdepth than our current update. So we can delete all updates that don't have a strictly greater maxdepth. Provided we push updates to the back of the node's std::vector, it is also trivial to prove by induction that the updates we can delete will form a suffix of this vector (the invariant is that $$$maxdepth_{v_1} > maxdepth_{v_2} > maxdepth_{v_3}...$$$). Another invariant is $$$time_{v_1} < time_{v_2} < time_{v_3}...$$$, because later updates are pushed to the back, after earlier updates.

Basically, in each segment tree node we will maintain a monotonic stack sorted by decreasing order of maxdepth and increasing order of time. We push $$$O(QlogN)$$$ updates to nodes. $$$O(logN)$$$ times for each update. Since each pushed update is deleted at most once, we delete $$$O(QlogN)$$$ updates. In total, time complexity of updates is $$$O(QlogN)$$$.

The final observation:

With respect to a query position $$$a$$$ and a segtree node $$$x$$$ (which represents a range that contains $$$a$$$), the LRU of $$$x$$$ is the last update in std::vector of $$$x$$$ such that the update has a maxdepth $$$\ge dep_{a}$$$. Any updates after that will not be relevant to $$$a$$$ (maxdepth too small), and any updates before are relevant, but not the latest.

Because the std::vector is already sorted by maxdepth, you can binary search it to find the node's LRU. You need to find the LRU of $$$log N$$$ nodes for each query, so each query is completed in $$$O(log Q) * O(log N)$$$ which is $$$O(log^{2}N)$$$.

Our time complexity is $$$O(QlogN) + O(Qlog^{2}N)$$$ which is $$$O(Nlog^{2}N)$$$.

P.S: Thank you for reading my 2nd Codeforces blog post. I'm still learning the style of solution blogs around here, so if I overexplained something or didn't explain something well enough, please tell me in the comments. Other feedback is also greatly appreciated. Have a nice day :)

Further reading: Official editorial, which uses 2D Segment Tree