Number of operations to make network connected

import java.util.*;

class DisjointSet {
    /* To store the ranks, parents and 
    sizes of different set of vertices */
    int[] rank, parent, size;

    // Constructor
    DisjointSet(int n) {
        rank = new int[n + 1];
        parent = new int[n + 1];
        size = new int[n + 1];
        for (int i = 0; i <= n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }

    // Function to find ultimate parent
    int findUPar(int node) {
        if (node == parent[node])
            return node;
        return parent[node] = findUPar(parent[node]);
    }

    // Function to implement union by rank
    void unionByRank(int u, int v) {
        int ulp_u = findUPar(u);
        int ulp_v = findUPar(v);
        if (ulp_u == ulp_v) return;
        if (rank[ulp_u] < rank[ulp_v]) {
            parent[ulp_u] = ulp_v;
        }
        else if (rank[ulp_v] < rank[ulp_u]) {
            parent[ulp_v] = ulp_u;
        }
        else {
            parent[ulp_v] = ulp_u;
            rank[ulp_u]++;
        }
    }

    // Function to implement union by size
    void unionBySize(int u, int v) {
        int ulp_u = findUPar(u);
        int ulp_v = findUPar(v);
        if (ulp_u == ulp_v) return;
        if (size[ulp_u] < size[ulp_v]) {
            parent[ulp_u] = ulp_v;
            size[ulp_v] += size[ulp_u];
        }
        else {
            parent[ulp_v] = ulp_u;
            size[ulp_u] += size[ulp_v];
        }
    }
}

// Solution class
class Solution{

    /* Function to get the number of 
    operations to make network connected */
    public int solve(int n, int[][] Edge){

        // Get the number of edges
        int size = Edge.length;

        /* Return -1 if connecting all 
        vertices is not possible */
        if(size < n-1) return -1;

        // Disjoint Set data structure
        DisjointSet ds = new DisjointSet(n);

        // Add all the edges in the set
        for(int i=0; i<size; i++) {
            ds.unionByRank(Edge[i][0], Edge[i][1]);
        }

        // To store count of required edges
        int count = 0;

        // Finding the number of components
        for(int i=0; i<n; i++) {
            if(ds.parent[i] == i) count++;
        }

        // Return the result
        return count-1;
    }

    public static void main(String[] args) {
        int n = 4;
        int[][] Edge = {
            {0, 1}, 
            {0, 2}, 
            {1, 2}
        };

        // Creating instance of Solution class
        Solution sol = new Solution();

        /* Function call to get the number of 
        operations to make network connected */
        int ans = sol.Solve(n, Edge);

        System.out.println("The number of operations to make network connected is: " + ans);
    }
}

class DisjointSet:
    # To store the ranks, parents and 
    # sizes of different set of vertices
    def __init__(self, n):
        self.rank = [0] * (n + 1)
        self.parent = [i for i in range(n + 1)]
        self.size = [1] * (n + 1)
    
    # Function to find ultimate parent
    def findUPar(self, node):
        if node == self.parent[node]:
            return node
        self.parent[node] = self.findUPar(self.parent[node])
        return self.parent[node]
    
    # Function to implement union by rank
    def unionByRank(self, u, v):
        ulp_u = self.findUPar(u)
        ulp_v = self.findUPar(v)
        if ulp_u == ulp_v:
            return
        if self.rank[ulp_u] < self.rank[ulp_v]:
            self.parent[ulp_u] = ulp_v
        elif self.rank[ulp_v] < self.rank[ulp_u]:
            self.parent[ulp_v] = ulp_u
        else:
            self.parent[ulp_v] = ulp_u
            self.rank[ulp_u] += 1
    
    # Function to implement union by size
    def unionBySize(self, u, v):
        ulp_u = self.findUPar(u)
        ulp_v = self.findUPar(v)
        if ulp_u == ulp_v:
            return
        if self.size[ulp_u] < self.size[ulp_v]:
            self.parent[ulp_u] = ulp_v
            self.size[ulp_v] += self.size[ulp_u]
        else:
            self.parent[ulp_v] = ulp_u
            self.size[ulp_u] += self.size[ulp_v]

# Solution class
class Solution:

    # Function to get the number of 
    # operations to make network connected
    def solve(self, n, Edge):
        
        # Get the number of edges
        size = len(Edge)
        
        # Return -1 if connecting all 
        # vertices is not possible
        if size < n - 1:
            return -1
        
        # Disjoint Set data structure
        ds = DisjointSet(n)
        
        # Add all the edges in the set
        for i in range(size):
            ds.unionByRank(Edge[i][0], Edge[i][1])
        
        # To store count of required edges
        count = 0
        
        # Finding the number of components
        for i in range(n):
            if ds.parent[i] == i:
                count += 1
        
        # Return the result
        return count - 1

# Creating instance of Solution class
sol = Solution()

# Function call to get the number of 
# operations to make network connected
n = 4
Edge = [
    [0, 1], 
    [0, 2], 
    [1, 2]
]
ans = sol.solve(n, Edge)

print("The number of operations to make network connected is:", ans)

class DisjointSet {
    /* To store the ranks, parents and 
    sizes of different set of vertices */
    constructor(n) {
        this.rank = new Array(n + 1).fill(0);
        this.parent = new Array(n + 1);
        this.size = new Array(n + 1).fill(1);
        for (let i = 0; i <= n; i++) {
            this.parent[i] = i;
        }
    }

    // Function to find ultimate parent
    findUPar(node) {
        if (node === this.parent[node])
            return node;
        return this.parent[node] = 
            this.findUPar(this.parent[node]);
    }

    // Function to implement union by rank
    unionByRank(u, v) {
        let ulp_u = this.findUPar(u);
        let ulp_v = this.findUPar(v);
        if (ulp_u === ulp_v) return;
        if (this.rank[ulp_u] < this.rank[ulp_v]) {
            this.parent[ulp_u] = ulp_v;
        }
        else if (this.rank[ulp_v] < this.rank[ulp_u]) {
            this.parent[ulp_v] = ulp_u;
        }
        else {
            this.parent[ulp_v] = ulp_u;
            this.rank[ulp_u]++;
        }
    }

    // Function to implement union by size
    unionBySize(u, v) {
        let ulp_u = this.findUPar(u);
        let ulp_v = this.findUPar(v);
        if (ulp_u === ulp_v) return;
        if (this.size[ulp_u] < this.size[ulp_v]) {
            this.parent[ulp_u] = ulp_v;
            this.size[ulp_v] += this.size[ulp_u];
        }
        else {
            this.parent[ulp_v] = ulp_u;
            this.size[ulp_u] += this.size[ulp_v];
        }
    }
}

// Solution class
class Solution {

    /* Function to get the number of 
    operations to make network connected */
    solve(n, Edge) {

        // Get the number of edges
        const size = Edge.length;

        /* Return -1 if connecting all 
        vertices is not possible */
        if (size < n - 1) return -1;

        // Disjoint Set data structure
        const ds = new DisjointSet(n);

        // Add all the edges in the set
        for (let i = 0; i < size; i++) {
            ds.unionByRank(Edge[i][0], Edge[i][1]);
        }

        // To store count of required edges
        let count = 0;

        // Finding the number of components
        for (let i = 0; i < n; i++) {
            if (ds.parent[i] === i) count++;
        }

        // Return the result
        return count - 1;
    }
}

// Creating instance of Solution class
const sol = new Solution();

/* Function call to get the number of 
 operations to make network connected */
const n = 4;
const Edge = [
    [0, 1],
    [0, 2],
    [1, 2]
];
const ans = sol.solve(n, Edge);

console.log("The number of operations to make network connected is:", ans);