Find if Path Exists in Graph

class Solution {
    vector<int> parent;
    int find(int 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:
    bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
        parent.resize(n);
        iota(parent.begin(), parent.end(), 0);
        for (auto& e : edges) unite(e[0], e[1]);
        return find(source) == find(destination);
    }
};

func validPath(n int, edges [][]int, source int, destination int) bool {
    parent := make([]int, n)
    for i := range parent {
        parent[i] = i
    }
    var find func(int) int
    find = func(x int) int {
        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 _, e := range edges {
        unite(e[0], e[1])
    }
    return find(source) == find(destination)
}

from typing import List

class Solution:
    def validPath(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
        parent = list(range(n))

        def find(x: int) -> int:
            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 a, b in edges:
            unite(a, b)
        return find(source) == find(destination)

function validPath(n, edges, source, destination) {
    const parent = Array.from({ length: n }, (_, i) => i);
    const find = (x) => {
        while (parent[x] !== x) {
            parent[x] = parent[parent[x]];
            x = parent[x];
        }
        return x;
    };
    const unite = (a, b) => {
        parent[find(a)] = find(b);
    };
    for (const [a, b] of edges) unite(a, b);
    return find(source) === find(destination);
}

class Solution {
    private int[] parent;

    public boolean validPath(int n, int[][] edges, int source, int destination) {
        parent = new int[n];
        for (int i = 0; i < n; i++) parent[i] = i;
        for (int[] e : edges) unite(e[0], e[1]);
        return find(source) == find(destination);
    }

    private int find(int x) {
        while (parent[x] != x) {
            parent[x] = parent[parent[x]];
            x = parent[x];
        }
        return x;
    }

    private void unite(int a, int b) {
        parent[find(a)] = find(b);
    }
}

function validPath(n: number, edges: number[][], source: number, destination: number): boolean {
    const parent: number[] = Array.from({ length: n }, (_, i) => i);
    const find = (x: number): number => {
        while (parent[x] !== x) {
            parent[x] = parent[parent[x]];
            x = parent[x];
        }
        return x;
    };
    const unite = (a: number, b: number): void => {
        parent[find(a)] = find(b);
    };
    for (const [a, b] of edges) unite(a, b);
    return find(source) === find(destination);
}