Redundant Connection — Union-Find Cycle Detection

class Solution:
    def findRedundantConnection(self, edges: list[list[int]]) -> list[int]:
        parent=list(range(len(edges)+1))
        rank=[0]*(len(edges)+1)
        def find(x):
            while parent[x]!=x: parent[x]=parent[parent[x]]; x=parent[x]
            return x
        def union(a,b):
            a,b=find(a),find(b)
            if a==b: return False
            if rank[a]<rank[b]: a,b=b,a
            parent[b]=a
            if rank[a]==rank[b]: rank[a]+=1
            return True
        for u,v in edges:
            if not union(u,v): return [u,v]
        return []

class Solution {
    int parent[1001],rnk[1001]={};
    int find(int x){return parent[x]==x?x:(parent[x]=find(parent[x]));}
    bool unite(int a,int b){
        a=find(a);b=find(b);if(a==b)return false;
        if(rnk[a]<rnk[b])swap(a,b);
        parent[b]=a;if(rnk[a]==rnk[b])rnk[a]++;return true;
    }
public:
    vector<int> findRedundantConnection(vector<vector<int>>& edges){
        iota(parent,parent+1001,0);
        for(auto& e:edges) if(!unite(e[0],e[1])) return e;
        return {};
    }
};