docs: Add application and images

Author: 4ndrelim

docs/assets/images/QuickFind.png

@@ -3,11 +3,14 @@
 ## Background
 
 A disjoint-set structure also known as a union-find or merge-find set, is a data structure
-keeps track of a partition of a set into disjoint (non-overlapping) subsets. In CS2040s, this
+keeps track of a partition of a set into disjoint (non-overlapping) subsets. 
+
+In CS2040s, this
 is introduced in the context of checking for dynamic connectivity. For instance, Kruskal's algorithm
-in graph theory to find minimum spanning tree of the graph utilizes disjoint set to efficiently
-query if there exists a path between 2 nodes. <br>
-It supports 2 main operations:
+in graph theory to find minimum spanning tree of a graph utilizes disjoint set to efficiently
+query if there already exists a path between 2 nodes.
+
+Generally, there are 2 main operations:
 
 1. Union: Join two subsets into a single subset
 2. Find: Determine which subset a particular element is in. In practice, this is often done to check
@@ -17,16 +20,26 @@ The Disjoint Set structure is often introduced in 3 parts, with each iteration b
 previous either in time or space complexity (or both). More details can be found in the respective folders. 
 Below is a brief overview:
 
-1. Quick Find - Elements are assigned a component identity. 
+1. **Quick Find** - Elements are assigned a component identity. 
 Querying for connectivity and updating usually tracked with an internal array.
 
-2. Quick Union - Component an element belongs to is now tracked with a tree structure. Nothing to enforce
+2. **Quick Union** - Component an element belongs to is now tracked with a tree structure. Nothing to enforce
 a balanced tree and hence complexity does not necessarily improve
    - Note, this is not implemented but details can be found under weighted union folder.
 
-3. Weighted Union - Same idea of using a tree, but constructed in a way that the tree is balanced, leading to improved
+3. **Weighted Union** - Same idea of using a tree, but constructed in a way that the tree is balanced, leading to improved
 complexities. Can be further augmented with path compression.
 
+## Applications
+Because of its efficiency and simplicity in implementing, Disjoint Set structures are widely used in practice:
+1. As mentioned, it is often sued as a helper structure for Kruskal's MST algorithm
+2. It can be used in the context of network connectivity
+   - Managing a network of computers 
+   - Or even analyse social networks, finding communities and determining if two users are connected through a chain
+3. Can be part of clustering algorithms to group data points based on similarity - useful for ML
+4. It can be used to detect cycles in dependency graphs, e.g, software dependency management systems
+5. It can be used for image processing, in labelling different connected components of an image
+
 ## Notes
 Disjoint Set is a data structure designed to keep track of a set of elements partitioned into a number of 
 non-overlapping subsets. It is not suited for handling duplicates and so our implementation ignores duplicates.

docs/assets/images/WeightedUnion.png

@@ -2,7 +2,14 @@
 
 ## Background
 Every object will be assigned a component identity. The implementation of Quick Find often involves
-an underlying array or hash map that tracks the component identity of each object. Here, we use a hash map.
+an underlying array or hash map that tracks the component identity of each object. 
+Our implementation uses a hash map (to easily handle the case when objects aren't integers).
+
+<div align="center">
+    <img src="../../../../../../docs/assets/images/QuickFind.png" width="50%">
+    <br>
+    Credits: CS2040s Lecture Slides
+</div>
 
 ### Union
 Between the two components, decide on the component d, to represent the combined set. Let the other

docs/assets/images/WeightedUnionLeetCode.png

@@ -26,6 +26,7 @@ are balanced.
 **Space**: O(n), implementation still involves wrapping the n elements with some structure / wrapper (e.g. Node class).
 
 # Weighted Union
+
 ## Background
 Now, we improve upon the Quick Union structure by ensuring trees constructed are 'balanced'. Balanced
 trees have a nice property that the height of the tree will be upper-bounded by O(log(n)). This considerably speeds
@@ -34,6 +35,12 @@ We additionally track the size of each tree and ensure that whenever there is a
 tree becomes a child of the larger tree.**
 It can be mathematically shown the height of the tree is bounded by O(log(n)).
 
+<div align="center">
+    <img src="../../../../../../docs/assets/images/WeightedUnion.png" width="50%">
+    <br>
+    Credits: CS2040s Lecture Slides
+</div>
+
 ### Intuition - Why It Works
 First, it is crucial to know that Weighted Union's efficiency relies on careful **construction** of the trees. <br>
 Every element / object starts off in its own tree (i.e. its own component). When two components are merged, the smaller 
@@ -71,3 +78,9 @@ Interested readers can find out more [here](https://dl.acm.org/doi/pdf/10.1145/3
 **Space**: O(n)
 
 ## Notes
+### Sample Demo - LeetCode 684: Redundant Connections
+The 'objects' in the question are given to be integers. Using int arrays instead of HashMap mapping in our 
+implementation would suffice. But below uses the code exactly from our implementation to show its versatility.
+
+<img src="../../../../../../docs/assets/images/WeightedUnionLeetCode.png">
+