Link Cut Tree

content/graph/LCT.h

@@ -0,0 +1,98 @@
+/**
+ * Author: 
+ * Description: link-cut Tree. Supports BST-like 
+ * augmentations. (Can be used in place of HLD).
+ * Current implementation supports update value at a node,
+ * and query max on a path.
+ * Tested on: http://acm.timus.ru/problem.aspx?num=1553
+ * Status: Passes existing fuzz tests (with function names modified).
+ */
+struct Node {
+	bool flip = 0;
+	Node *pp, *p, *c[2]; // path parent, parent, children
+	// add stuff
+	int val = 0, cval = 0, ind;
+	Node() { pp = p = c[0] = c[1] = 0; }
+	void push() {
+		if (flip) {
+			rep(i, 0, 2) if(c[i]) c[i]->flip ^= 1;
+			swap(c[0], c[1]); flip = 0;
+		}
+	}
+	void pull() {
+		cval = val;
+		rep(i, 0, 2) if(c[i]) c[i]->push(), cval = max(cval, c[i]->cval);
+	}
+	void rot(bool t) {
+		Node *y = p, *z = y->p;
+		if (z) z->c[z->c[1] == y] = this;
+		y->c[!t] = c[t];
+		if (c[t]) c[t]->p = y;
+		c[t] = y; p = z;
+		y->p = this;
+		y->pull();
+	}
+	void xiao() {
+		if (p) p->xiao(), pp = p->pp;
+		push();
+	}
+	void splay() {
+		xiao();
+		while (p) {
+			Node* y = p; Node *z = y->p;
+			bool t1 = (y->c[1] != this);
+			if (z) {
+				bool t2 = (z->c[1] != y);
+				if (t1 == t2) y->rot(t2), rot(t1);
+				else rot(t1), rot(t2);
+			} else rot(t1);
+		}
+		pull();
+	}
+	Node* access() {
+		for (Node *y = 0, *z = this; z; y = z, z = z->pp) {
+			z->splay();
+			if (z->c[1]) z->c[1]->pp = z, z->c[1]->p = 0;
+			z->c[1] = y;
+			if (y) y->p = z;
+			z->pull();
+		}
+		splay();
+		return this;
+	}
+	Node* makeRoot() {
+		access()->flip ^= 1;
+		return this;
+	}
+};
+struct LinkCut {
+	vector<Node> nodes;
+	LinkCut(int N) : nodes(N) { rep(i, 0, N) nodes[i].ind = i; }
+	int findRoot(int u) {
+		Node *x = nodes[u].access();
+		while(x->c[0]) x = x->c[0];
+		return x->ind;
+	}
+	bool cut(int u, int v) { /// start-hash
+		Node *y = nodes[v].makeRoot();
+		Node *x = nodes[u].access();
+		if (x->c[0] != y || y->c[1])
+			return false;
+		x->c[0] = y->p = y->pp = 0;
+		x->pull();
+		return true;
+	} /// end-hash
+	bool isConnected(int u, int v) { return findRoot(u) == findRoot(v); }
+	bool link(int u, int v) {
+		if (isConnected(u, v)) return false;
+		nodes[u].makeRoot()->pp = &nodes[v];
+		return true;
+	}
+	void update(int u, int c) {
+		nodes[u].access()->val += c;
+	}
+	int query(int u, int v) { // Find max on the path from u to v.
+		nodes[v].makeRoot();
+		return nodes[u].access()->cval;
+	}
+};

fuzz-tests/data-structures/LinkCutTree.cpp

@@ -10,9 +10,18 @@ typedef long long ll;
 typedef pair<int, int> pii;
 typedef vector<int> vi;
 
-#include "../../content/graph/LinkCutTree.h"
+#include "../../content/graph/LCT.h"
 #include "../../content/data-structures/UnionFind.h"
 
+bool dfs(vi &path, bitset<20> &vis, vector<set<int>> &g, int a, int &b) {
+	path.push_back(a);
+	vis[a] = 1;
+	if(a == b) return true;
+	trav(u, g[a]) if(!vis[u]) if (dfs(path, vis, g, u, b)) return true;
+	path.pop_back();
+	return false;
+}
+
 int main() {
 	srand(2);
 	LinkCut lczero(0);
@@ -21,18 +30,26 @@ int main() {
 		LinkCut lc(N);
 		UF uf(N);
 		vector<pii> edges;
+		vector<set<int>> g(N);
+		vector<int> val(N);
+		bitset<20> vis;
+		queue<int> q;
+		vi cc;
+		vi path;
 		rep(it2,0,1000) {
-			int v = (rand() >> 4) & 3;
+			int v = (rand() >> 4) & 7;
 			if (v == 0 && !edges.empty()) { // remove
 				int r = (rand() >> 4) % sz(edges);
 				pii ed = edges[r];
 				swap(edges[r], edges.back());
 				edges.pop_back();
+				g[ed.first].erase(ed.second);
+				g[ed.second].erase(ed.first);
 				if (rand() & 16)
 					lc.cut(ed.first, ed.second);
 				else
 					lc.cut(ed.second, ed.first);
-			} else {
+			} else if(v & 1) {
 				int a = (rand() >> 4) % N;
 				int b = (rand() >> 4) % N;
 				uf.e.assign(N, -1);
@@ -41,9 +58,33 @@ int main() {
 				if (!c && v != 1) {
 					lc.link(a, b);
 					edges.emplace_back(a, b);
+					g[a].emplace(b); g[b].emplace(a);
 				} else {
-					assert(lc.connected(a, b) == c);
+					assert(lc.isConnected(a, b) == c);
+				}
+			} else if (v & 2) {
+				int a = (rand() >> 4) % N;
+				int b = rand() % 10000;
+				val[a] += b;
+				lc.update(a, b);
+			} else {
+				int a = (rand() >> 4) % N;
+				vis.reset(), queue<int>().swap(q), vi().swap(cc);
+				q.push(a);
+				while(sz(q)) {
+					int u = q.front(); q.pop();
+					vis[u] = 1;
+					cc.push_back(u);
+					trav(e, g[u]) if(!vis[e]) q.push(e);
 				}
+				int r = (rand() >> 4) % sz(cc);
+				int b = cc[r];
+				vis.reset();
+				vi().swap(path);
+				assert(dfs(path, vis, g, a, b));
+				int mx = 0;
+				trav(x, path) mx = max(mx, val[x]);
+				assert(lc.query(a, b) == mx);
 			}
 		}
 	}