diff --git a/data_structures/dsu_path_compression.cpp b/data_structures/dsu_path_compression.cpp
index bbdc2a9a9..f13f9b10b 100644
--- a/data_structures/dsu_path_compression.cpp
+++ b/data_structures/dsu_path_compression.cpp
@@ -1,25 +1,26 @@
 /**
  * @file
- * @brief [DSU (Disjoint sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
+ * @brief [DSU (Disjoint
+ * sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
  * @details
  * It is a very powerful data structure that keeps track of different
- * clusters(sets) of elements, these sets are disjoint(doesnot have a common element).
- * Disjoint sets uses cases : for finding connected components in a graph,
- * used in Kruskal's algorithm for finding Minimum Spanning tree.
+ * clusters(sets) of elements, these sets are disjoint(doesnot have a common
+ * element). Disjoint sets uses cases : for finding connected components in a
+ * graph, used in Kruskal's algorithm for finding Minimum Spanning tree.
  * Operations that can be performed:
  * 1) UnionSet(i,j): add(element i and j to the set)
  * 2) findSet(i): returns the representative of the set to which i belogngs to.
- * 3) get_max(i),get_min(i) : returns the maximum and minimum 
- * Below is the class-based approach which uses the heuristic of path compression.
- * Using path compression in findSet(i),we are able to get to the representative of i
- * in O(1) time.
+ * 3) get_max(i),get_min(i) : returns the maximum and minimum
+ * Below is the class-based approach which uses the heuristic of path
+ * compression. Using path compression in findSet(i),we are able to get to the
+ * representative of i in O(1) time.
  * @author [AayushVyasKIIT](https://github.com/AayushVyasKIIT)
  * @see dsu_union_rank.cpp
  */
 
+#include <cassert>   /// for assert
 #include <iostream>  /// for IO operations
 #include <vector>    /// for std::vector
-#include <cassert>  /// for assert
 
 using std::cout;
 using std::endl;
@@ -29,139 +30,136 @@ using std::vector;
  * @brief Disjoint sets union data structure, class based representation.
  * @param n number of elements
  */
-class dsu{
-    private:
-        vector<uint64_t> p; ///<keeps track of the parent of ith element
-        vector<uint64_t> depth; ///<tracks the depth(rank) of i in the tree
-        vector<uint64_t> setSize;///<size of each chunk(set)
-        vector<uint64_t> maxElement;/// <maximum of each set to which i belongs to
-        vector<uint64_t> minElement;/// <minimum of each set to which i belongs to
-    public:
-        /**
-        * @brief contructor for initialising all data members.
-        * @param n number of elements
-        */
-        explicit dsu(uint64_t n){
-            p.assign(n,0);
-            /// initially, all of them are their own parents
-            for(uint64_t i=0;i<n;i++){
-                p[i] = i;
-            }
-            /// initially all have depth are equals to zero
-            depth.assign(n,0);
-            maxElement.assign(n,0);
-            minElement.assign(n,0);
-            for(uint64_t i=0;i<n;i++){
-                depth[i] = 0;
-                maxElement[i] = i;
-                minElement[i] = i;
-            }
-            setSize.assign(n,0);
-            /// initially set size will be equals to one
-            for(uint64_t i=0;i<n;i++){
-                setSize[i]=1;
-            }
+class dsu {
+ private:
+    vector<uint64_t> p;           ///< keeps track of the parent of ith element
+    vector<uint64_t> depth;       ///< tracks the depth(rank) of i in the tree
+    vector<uint64_t> setSize;     ///< size of each chunk(set)
+    vector<uint64_t> maxElement;  /// <maximum of each set to which i belongs to
+    vector<uint64_t> minElement;  /// <minimum of each set to which i belongs to
+ public:
+    /**
+     * @brief contructor for initialising all data members.
+     * @param n number of elements
+     */
+    explicit dsu(uint64_t n) {
+        p.assign(n, 0);
+        /// initially, all of them are their own parents
+        for (uint64_t i = 0; i < n; i++) {
+            p[i] = i;
+        }
+        /// initially all have depth are equals to zero
+        depth.assign(n, 0);
+        maxElement.assign(n, 0);
+        minElement.assign(n, 0);
+        for (uint64_t i = 0; i < n; i++) {
+            depth[i] = 0;
+            maxElement[i] = i;
+            minElement[i] = i;
+        }
+        setSize.assign(n, 0);
+        /// initially set size will be equals to one
+        for (uint64_t i = 0; i < n; i++) {
+            setSize[i] = 1;
+        }
+    }
+
+    /**
+     * @brief Method to find the representative of the set to which i belongs
+     * to, T(n) = O(1)
+     * @param i element of some set
+     * @returns representative of the set to which i belongs to.
+     */
+    uint64_t findSet(uint64_t i) {
+        /// using path compression
+        if (p[i] == i) {
+            return i;
+        }
+        return (p[i] = findSet(p[i]));
+    }
+    /**
+     * @brief Method that combines two disjoint sets to which i and j belongs to
+     * and make a single set having a common representative.
+     * @param i element of some set
+     * @param j element of some set
+     * @returns void
+     */
+    void UnionSet(uint64_t i, uint64_t j) {
+        /// check if both belongs to the same set or not
+        if (isSame(i, j)) {
+            return;
         }
 
-        /**
-         * @brief Method to find the representative of the set to which i belongs to, T(n) = O(1)
-         * @param i element of some set
-         * @returns representative of the set to which i belongs to. 
-         */
-        uint64_t findSet(uint64_t i){
-            /// using path compression
-            if(p[i]==i){
-                return i;
-            }
-            return (p[i] = findSet(p[i]));
-        }
-        /**
-         * @brief Method that combines two disjoint sets to which i and j belongs to 
-         * and make a single set having a common representative.
-         * @param i element of some set
-         * @param j element of some set
-         * @returns void
-        */
-        void UnionSet(uint64_t i,uint64_t j){
-            /// check if both belongs to the same set or not
-            if(isSame(i,j)){
-                return;
-            }
+        // we find the representative of the i and j
+        uint64_t x = findSet(i);
+        uint64_t y = findSet(j);
 
-            //we find the representative of the i and j
-            uint64_t x = findSet(i);
-            uint64_t y = findSet(j);
+        // always keeping the min as x
+        // shallow tree
+        if (depth[x] > depth[y]) {
+            std::swap(x, y);
+        }
+        // making the shallower root's parent the deeper root
+        p[x] = y;
 
-            //always keeping the min as x
-            //shallow tree
-            if(depth[x]>depth[y]){
-                std::swap(x,y);
-            }
-            //making the shallower root's parent the deeper root
-            p[x] = y;
-            
-            //if same depth then increase one's depth
-            if(depth[x] == depth[y]){
-                depth[y]++;
-            }
-            //total size of the resultant set.  
-            setSize[y] += setSize[x];
-            //changing the maximum elements
-            maxElement[y] = std::max(maxElement[x],maxElement[y]);
-            minElement[y] = std::min(minElement[x],minElement[y]);
+        // if same depth then increase one's depth
+        if (depth[x] == depth[y]) {
+            depth[y]++;
         }
-        /**
-         * @brief A utility function which check whether i and j belongs to
-         * same set or not
-         * @param i element of some set
-         * @param j element of some set
-         * @returns `true` if element `i` and `j` ARE in the same set
-         * @returns `false` if element `i` and `j` are NOT in same set
-         */
-        bool isSame(uint64_t i,uint64_t j){
-            if(findSet(i) == findSet(j)){
-                return true;
-            }
-            return false;
+        // total size of the resultant set.
+        setSize[y] += setSize[x];
+        // changing the maximum elements
+        maxElement[y] = std::max(maxElement[x], maxElement[y]);
+        minElement[y] = std::min(minElement[x], minElement[y]);
+    }
+    /**
+     * @brief A utility function which check whether i and j belongs to
+     * same set or not
+     * @param i element of some set
+     * @param j element of some set
+     * @returns `true` if element `i` and `j` ARE in the same set
+     * @returns `false` if element `i` and `j` are NOT in same set
+     */
+    bool isSame(uint64_t i, uint64_t j) {
+        if (findSet(i) == findSet(j)) {
+            return true;
         }
-        /**
-         * @brief prints the minimum, maximum and size of the set to which i belongs to
-         * @param i element of some set
-         * @returns void
-         */
-        vector<uint64_t> get(uint64_t i){
-            vector<uint64_t> ans;
-            ans.push_back(get_min(i));
-            ans.push_back(get_max(i));
-            ans.push_back(size(i));
-            return ans;
-
-        }
-        /**
-         * @brief A utility function that returns the size of the set to which i belongs to
-         * @param i element of some set
-         * @returns size of the set to which i belongs to
-         */
-        uint64_t size(uint64_t i){
-            return setSize[findSet(i)];
-        }
-        /**
-         * @brief A utility function that returns the max element of the set to which i belongs to
-         * @param i element of some set
-         * @returns maximum of the set to which i belongs to
-         */
-        uint64_t get_max(uint64_t i){
-            return maxElement[findSet(i)];
-        }
-        /**
-         * @brief A utility function that returns the min element of the set to which i belongs to
-         * @param i element of some set
-         * @returns minimum of the set to which i belongs to 
-         */
-        uint64_t get_min(uint64_t i){
-            return minElement[findSet(i)];
-        }
-
+        return false;
+    }
+    /**
+     * @brief prints the minimum, maximum and size of the set to which i belongs
+     * to
+     * @param i element of some set
+     * @returns void
+     */
+    vector<uint64_t> get(uint64_t i) {
+        vector<uint64_t> ans;
+        ans.push_back(get_min(i));
+        ans.push_back(get_max(i));
+        ans.push_back(size(i));
+        return ans;
+    }
+    /**
+     * @brief A utility function that returns the size of the set to which i
+     * belongs to
+     * @param i element of some set
+     * @returns size of the set to which i belongs to
+     */
+    uint64_t size(uint64_t i) { return setSize[findSet(i)]; }
+    /**
+     * @brief A utility function that returns the max element of the set to
+     * which i belongs to
+     * @param i element of some set
+     * @returns maximum of the set to which i belongs to
+     */
+    uint64_t get_max(uint64_t i) { return maxElement[findSet(i)]; }
+    /**
+     * @brief A utility function that returns the min element of the set to
+     * which i belongs to
+     * @param i element of some set
+     * @returns minimum of the set to which i belongs to
+     */
+    uint64_t get_min(uint64_t i) { return minElement[findSet(i)]; }
 };
 /**
  * @brief Self-implementation Test case #1
@@ -169,16 +167,16 @@ class dsu{
  */
 static void test1() {
     /* the minimum, maximum and size of the set*/
-    uint64_t n = 10;///< number of items
-    dsu d(n+1);///< object of class disjoint sets
-    //set 1
-    d.UnionSet(1,2); //performs union operation on 1 and 2
-    d.UnionSet(1,4); //performs union operation on 1 and 4
-    vector<uint64_t> ans = {1,4,3};
-    for(uint64_t i=0;i<ans.size();i++){
-        assert(d.get(4).at(i) == ans[i]); //makes sure algorithm works fine
+    uint64_t n = 10;  ///< number of items
+    dsu d(n + 1);     ///< object of class disjoint sets
+    // set 1
+    d.UnionSet(1, 2);  // performs union operation on 1 and 2
+    d.UnionSet(1, 4);  // performs union operation on 1 and 4
+    vector<uint64_t> ans = {1, 4, 3};
+    for (uint64_t i = 0; i < ans.size(); i++) {
+        assert(d.get(4).at(i) == ans[i]);  // makes sure algorithm works fine
     }
-    cout << "Test case# 1: passed"<<endl;
+    cout << "Test case# 1: passed" << endl;
 }
 /**
  * @brief Self-implementation Test case #2
@@ -186,30 +184,29 @@ static void test1() {
  */
 static void test2() {
     /* the minimum, maximum and size of the set */
-    uint64_t n = 10;///< number of items
-    dsu d(n+1);///< object of class disjoint sets
-    //set 1
-    d.UnionSet(3,5);
-    d.UnionSet(5,6);
-    d.UnionSet(5,7);
-    vector<uint64_t> ans = {3,7,4};
-    for(uint64_t i=0;i<ans.size();i++){
-        assert(d.get(3).at(i) == ans[i]); //makes sure algorithm works fine
+    uint64_t n = 10;  ///< number of items
+    dsu d(n + 1);     ///< object of class disjoint sets
+    // set 1
+    d.UnionSet(3, 5);
+    d.UnionSet(5, 6);
+    d.UnionSet(5, 7);
+    vector<uint64_t> ans = {3, 7, 4};
+    for (uint64_t i = 0; i < ans.size(); i++) {
+        assert(d.get(3).at(i) == ans[i]);  // makes sure algorithm works fine
     }
-    cout << "Test case# 2: passed"<<endl;
+    cout << "Test case# 2: passed" << endl;
 }
 
-
 /**
  * @brief Main function
  * @returns 0 on exit
  * */
-int main(){
-    uint64_t n = 10;///< number of items
-    dsu d(n+1);///< object of class disjoint sets
+int main() {
+    uint64_t n = 10;  ///< number of items
+    dsu d(n + 1);     ///< object of class disjoint sets
+
+    test1();  //< test case# 1
+    test2();  //< test case# 2
 
-    test1(); //< test case# 1
-    test2(); //< test case# 2
-    
     return 0;
 }
\ No newline at end of file