class DisjointSet:
    def __init__(self, arr = []):
        self.parent = {x : x for x in arr}
        self.rank = {x : 0 for x in arr}
        self.size = {x : 1 for x in arr}

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
    
    def union(self, x, y):
        if x not in self.parent:
            self.parent[x] = x
            self.rank[x] = 0
            self.size[x] = 1

        if y not in self.parent:
            self.parent[y] = y
            self.rank[y] = 0
            self.size[y] = 1

        rootX = self.find(x)
        rootY = self.find(y)

        if rootX != rootY:        
            if self.rank[rootX] > self.rank[rootY]:
                self.parent[rootY] = rootX
                self.size[rootX] += self.size[rootY]           
            elif self.rank[rootX] < self.rank[rootY]:
                self.parent[rootX] = rootY
                self.size[rootY] += self.size[rootX]
            else:
                self.parent[rootY] = rootX
                self.rank[rootX] += 1
                self.size[rootX] += self.size[rootY]

def componentsInGraph(gb):
    ds = DisjointSet()
    min_nodes = 15_001
    max_nodes = 0

    for x, y in gb:
        ds.union(x, y)

    for s in ds.size:
        if ds.parent[s] == s:
            if ds.size[s] > 1:
                min_nodes = min(min_nodes, ds.size[s])
                max_nodes = max(max_nodes, ds.size[s])

    return [min_nodes, max_nodes]

function bfs(graph: number[][], start: number):number[] {
    const queue: number[] = [start];
    const visited = new Set<number>();

    while (queue.length > 0) {
        const selectedNode = queue.pop();
        if (!visited.has(selectedNode)) {
            visited.add(selectedNode);

            for (let node of graph) {
                if (node[0] == selectedNode) {
                    queue.push(node[1]);
                }
                if (node[1] == selectedNode) {
                    queue.push(node[0]);
                }
            }
        }
    }

    return Array.from(visited)

}

function componentsInGraph(gb: number[][]): number[] {
    // Write your code here
    const nodes = new Set<number>();
    for (let g of gb) {
        nodes.add(g[0]);
        nodes.add(g[1]);
    }

     let max = 0;
    let min = nodes.size  ;
    nodes.forEach((index) => {
        // if(index > nodes.size / 2){return}
        const bfsssss = bfs(gb, index);
        bfsssss.forEach(b => nodes.delete(b));
        const value = bfsssss.length;
        if (value > max) {
            max = value;
        }
        if (value < min && value > 1) {
            min = value;
        }
    })
    // console.log([min,max]);

    return [min, max];
}

public static List<Integer> componentsInGraph(List<List<Integer>> gb) {
        Map<Integer, Set<Integer>> map = new HashMap<>();
        for(List<Integer> line : gb) {
            int p1 = line.get(0);
            int p2 = line.get(1);
            Set<Integer> s1 = map.get(p1);
            Set<Integer> s2 = map.get(p2);
            if(s1 == null || s2 == null) {
                Set<Integer> s = (s1 == null) ? s2 : s1;
                if(s == null) {
                    s = new HashSet<>();
                }
                s.add(p1);
                s.add(p2);
                map.put(p1, s);
                map.put(p2, s);
            } else {
                if(s1 != s2) {
                    s1.addAll(s2);
                    for(int i: s2) {
                        map.put(i, s1);
                    }
                    map.put(p2, s1);
                }
            }
        }
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for(Set<Integer> s: map.values()) {
            min = Math.min(min, s.size());
            max = Math.max(max, s.size());
        }
        return Arrays.asList(min, max);
    }