UF bug fix, exercises (comp crashed; git probs)

Author: lee-naish

src/algorithms/controllers/unionFindFind.js

@@ -37,7 +37,7 @@ export default {
 
     // restoring the visualisers
     chunker.add(
-      `while n != parent[n]`,
+      `Find(n)`,
       (vis, parentArray) => {
         vis.array.set([N_ARRAY, parentArray], 'unionFind');
         vis.tree.setNTree(realNodes, realEdges, nodes, edges);
@@ -231,7 +231,7 @@ export default {
           vis.tree.addEdge(grandparent, n);
           vis.tree.layout();
         },
-        [n, parentArr[parentArr[n]]]
+        [n, parentArr[n]]
       );
 
       chunker.add(

src/algorithms/controllers/unionFindUnion.js

@@ -1,3 +1,6 @@
+// XXX maybe get rid of some of the animation steps where there are
+// multiple steps for a single line of code (generally using the last
+// step is sufficient)
 /* eslint-disable eqeqeq */
 /* eslint-disable no-plusplus */
 /* eslint-disable no-param-reassign */

src/algorithms/explanations/UFExp.md

@@ -32,7 +32,7 @@ Extra information is maintained for each subset so Union can reduce the
 height and when Find traverses a path from a node to the root, we take
 the opportunity to reduce the length of the path for future calls to Find
 (the tree height is reduced and the "width" is increased by having more
-children for some nodes).
+children for some nodes - see below).
 
 Interestingly, the extra information used to reduce the height is only
 approximate and the method used to reduce path lengths is not as thorough
@@ -42,4 +42,19 @@ nodes point directly to the root. It has been shown that no matter how
 large the set is, Find has takes very close to constant time on average
 (the inverse of the Ackerman function to be precise).  In this animation
 we allow path compression to be disabled so you can experiment to see
-how much this aspect of the algorithm reduces tree height.
+how much this aspect of the algorithm reduces tree height.
+
+## Path compression in Find
+
+The method of path compression used here is that whenever we are at a
+node, searching upwards to find the root of the tree, we change the parent
+of the node to be the (previous) grandparent.
+
+## Union by rank
+
+When two trees are joined in a Union operation, we want to minimise the
+height of the resulting tree.  This can be done by making the shorter
+tree a subtree of the taller tree. Here we maintain the *rank* of each
+tree, which is an approximation (an upper bound) on the height. Each
+tree starts with rank 1 and when two trees of equal rank are joined, the
+rank of the resulting tree is incremented.

src/algorithms/extra-info/UFInfo.md

@@ -4,4 +4,26 @@
 
 <a href="https://www.geeksforgeeks.org/introduction-to-disjoint-set-data-structure-or-union-find-algorithm/" target="_blank"><span style="color:blue">**geeksforgeeks.com**</span></a>
 
-<a href="https://cp-algorithms.com/data_structures/disjoint_set_union.html" target="_blank"><span style="color:blue">**cp-algorithms.com**</span></a>
+<a href="https://cp-algorithms.com/data_structures/disjoint_set_union.html" target="_blank"><span style="color:blue">**cp-algorithms.com**</span></a>
+
+## Exercises/Exploration
+
+Rather than using the *rank* of each tree, we could use the precise
+*height* of the tree.  What are the potential advantages and
+disadvantages of this?
+
+The path compression used here approximately halves the length of the
+path from a node to the root.  Instead, it would be possible to reduce
+the path length to at most one.  How could this be done and what are
+the potential advantages and disadvantages of this?
+
+Find a sequence of union operations that results in all 10 elements
+being in the same set but maximizes the height of the resulting tree.
+Does path compression make a difference in this case?
+
+Find a sequence of union operations that results in all 10 elements
+being in the same set but maximizes the height of the resulting tree
+when path compression is off but gives an almost optimal result with
+path compression on. How many extra elements would be needed to have the
+result optimal with path compression?
+