Input: edges = [[1,2],[1,3],[2,3]]
Output: [2,3]

class UnionFind {

    /**
     * @summary We're going to generate a UnionFind data structure.
     * Union Find is a special data-structure that can be used to form
     * a disjoint set (A tree). For this solution, we're going to use
     * the Rank variant of Union Find. All this mean's is that we keep
     * track the number of nodes a given tree has. It allows us to merge
     * trees that will require the minimal amount of work (Increases
     * the Amortized Complexity).
     *
     * @param  {Array} edges [[node, edge_to_connect_to], [node, edge_to_connect_to]]
     */
    constructor(edges) {

        // Create a array of Ranks (Index -> Tree Size)
        // Looks Like: [1,1,1,1]
        // (Each node is a tree of size 1 by default)
        this.ranks = new Array(edges.length).fill(1);

        // Create a array of Parents (Index -> Index of Parent)
        // If we keep following the parent, we'll eventually find
        // the root of the tree.
        // Looks Like: [0,1,2,3]
        // (Each node's parent is itself by default, as it's the root of it's tree)
        this.parents = Array.from(Array(edges.length).keys());
    }

    /**
     * @summary Find the root of a given node, we do this by asking the parents
     * list 'Who's the parent of this node's index?', we repeat this until the parent
     * of the node is itself. Meaning, we have reached the root of the tree.
     * We have also utilized a concept called 'Path Compression'. This mean's
     * instead of going up the tree one node at a time, we go up the tree 2 nodes
     * at a time. Tree height should be very small due to the 'rank' concept.
     *
     * Time Complexity: Amortized O(1) (Best, tree height is small)
       *              : O(log n) (Average)
       *              : O(n) (Worst, linked list tree)
     *
     * Space Complexity: O(1) (Finding allocated no space)
     *
     * Technically, we rate an algorithm by it's worst case. Thus this is
     * O(n) in time. But it's such a rare case that we don't care, so it's better
     * to use the amortized case of O(1)
     *
     * @param  {Number} index (Index of node in [Parents, Ranks, Edges])
     * @return {Number}       (Index of parent, the root node of the tree)
     */
    find(index) {
        // Get parent of node
        let parent = this.parents[index];

        // Keep getting parents until we reach the root of the tree
        while (parent != this.parents[parent]) {
            // Path Compression
            parent = this.parents[this.parents[parent]];
        }
        return parent;
    }

    /**
     * @summary Merge two trees by connecting the root of the  tree by rank.
     * What this mean's, is we're going to find the parents of both of the supplied
     * nodes, and then figure out which tree is larger. We then connect the root of
     * the smaller tree to the root of the larger tree.
     * Why? Because, during the Find() operation, we want to reduce the number of
     * steps required to get to the root of a given tree. By merging smaller into larger
     * we won't need as many steps to find the root of a given parent.
     *
     * This is called Union by Rank. Rank meaning, size of a given tree. When you combine
     * Path Compression and Union by Rank, you get a amortized O(1) time complexity.
     *
     * Time and Space Complexity is the same as Find() as we utilise that function.
     *
     * @param  {Number} n1 (Index of node 1)
     * @param  {Number} n2 (Index of node 2)
     * @return {Boolean}   (False if nodes are already in the same tree)
     */
    union(n1, n2) {

        // Find the parents of each node.
        const n1_parent = this.find(n1);
        const n2_parent = this.find(n2);

        // Are the nodes already in the same tree?
        // REDUNDANT CONNECTION!!!
        if (n1_parent === n2_parent) return false;

        // Union by rank, merge smallest into largest.
        if (this.ranks[n1_parent] > this.ranks[n2_parent]) {
            // Update parent and ranks
            this.parents[n2_parent]  = n1_parent;
            this.ranks  [n2_parent] += this.ranks[n1_parent];
        } else {
            // Merge n1 into n2
            this.parents[n1_parent]  = n2_parent;
            this.ranks  [n1_parent] += this.ranks[n2_parent];
        }

        // Successfully merged. Ranks and parents updated
        return true;
    }
}

/**
 * @param {number[][]} edges
 * @return {number[]}
 */
var findRedundantConnection = function (edges) {
    // The basic premise of this solution is
    // to use UnionFind to find the redundant edge.
    // UnionFind will attempt to create a tree by merging nodes
    // together. If at any point, two nodes are already connected,
    // meaning, they're in the same tree, we have found the redundant connection.

    // We're going to initialize a Union Find data structure
    // so we can attempt to build our tree.
    const Union_Find = new UnionFind(edges);

    // Let's build our tree.
    // Union each node and their edges together.
    // If at any point, a node and edge are already in the same Tree.
    // END loop, we found the redundant connection.
    for (const [node, edge] of edges) {
        if (!Union_Find.union(node, edge)) return [node, edge];
    }
};