Most Stones Removed with Same Row or Column

class Solution {
    unordered_map<int,int> parent;
    int find(int x) {
        if (!parent.count(x)) parent[x] = x;
        while (parent[x] != x) { parent[x] = parent[parent[x]]; x = parent[x]; }
        return x;
    }
    void unite(int a, int b) { parent[find(a)] = find(b); }
public:
    int removeStones(vector<vector<int>>& stones) {
        for (auto& s : stones) unite(s[0], s[1] + 10001);
        unordered_set<int> roots;
        for (auto& s : stones) roots.insert(find(s[0]));
        return stones.size() - roots.size();
    }
};

func removeStones(stones [][]int) int {
    parent := map[int]int{}
    var find func(int) int
    find = func(x int) int {
        if _, ok := parent[x]; !ok {
            parent[x] = x
        }
        for parent[x] != x {
            parent[x] = parent[parent[x]]
            x = parent[x]
        }
        return x
    }
    unite := func(a, b int) {
        parent[find(a)] = find(b)
    }
    for _, s := range stones {
        unite(s[0], s[1]+10001)
    }
    roots := map[int]bool{}
    for _, s := range stones {
        roots[find(s[0])] = true
    }
    return len(stones) - len(roots)
}

from typing import List

class Solution:
    def removeStones(self, stones: List[List[int]]) -> int:
        parent: dict[int, int] = {}

        def find(x: int) -> int:
            if x not in parent:
                parent[x] = x
            while parent[x] != x:
                parent[x] = parent[parent[x]]
                x = parent[x]
            return x

        def unite(a: int, b: int) -> None:
            parent[find(a)] = find(b)

        for r, c in stones:
            unite(r, c + 10001)
        roots = {find(r) for r, _ in stones}
        return len(stones) - len(roots)

function removeStones(stones) {
    const parent = new Map();
    const find = (x) => {
        if (!parent.has(x)) parent.set(x, x);
        while (parent.get(x) !== x) {
            parent.set(x, parent.get(parent.get(x)));
            x = parent.get(x);
        }
        return x;
    };
    const unite = (a, b) => {
        parent.set(find(a), find(b));
    };
    for (const [r, c] of stones) unite(r, c + 10001);
    const roots = new Set();
    for (const [r] of stones) roots.add(find(r));
    return stones.length - roots.size;
}

class Solution {
    private Map<Integer, Integer> parent = new HashMap<>();

    public int removeStones(int[][] stones) {
        for (int[] s : stones) unite(s[0], s[1] + 10001);
        Set<Integer> roots = new HashSet<>();
        for (int[] s : stones) roots.add(find(s[0]));
        return stones.length - roots.size();
    }

    private int find(int x) {
        if (!parent.containsKey(x)) parent.put(x, x);
        while (parent.get(x) != x) {
            parent.put(x, parent.get(parent.get(x)));
            x = parent.get(x);
        }
        return x;
    }

    private void unite(int a, int b) {
        parent.put(find(a), find(b));
    }
}

function removeStones(stones: number[][]): number {
    const parent = new Map<number, number>();
    const find = (x: number): number => {
        if (!parent.has(x)) parent.set(x, x);
        while (parent.get(x)! !== x) {
            parent.set(x, parent.get(parent.get(x)!)!);
            x = parent.get(x)!;
        }
        return x;
    };
    const unite = (a: number, b: number): void => {
        parent.set(find(a), find(b));
    };
    for (const [r, c] of stones) unite(r, c + 10001);
    const roots = new Set<number>();
    for (const [r] of stones) roots.add(find(r));
    return stones.length - roots.size;
}