Learning On the Way

2076. Process Restricted Friend Requests

You are given an integer n indicating the number of people in a network. Each person is labeled from 0 to n - 1.

You are also given a 0-indexed 2D integer array restrictions, where restrictions[i] = [xi, yi] means that person xi and person yi cannot become friends,either directly or indirectly through other people.

Initially, no one is friends with each other. You are given a list of friend requests as a 0-indexed 2D integer array requests, where requests[j] = [uj, vj] is a friend request between person uj and person vj.

A friend request is successful if uj and vj can be friends. Each friend request is processed in the given order (i.e., requests[j] occurs before requests[j + 1]), and upon a successful request, uj and vj become direct friends for all future friend requests.

Return a boolean array result, where each result[j] is true if the jth friend request is successful or false if it is not.

Note: If uj and vj are already direct friends, the request is still successful.

def friendRequests(self, n: int, restrictions: List[List[int]], requests: List[List[int]]) -> List[bool]:          
    uf = UnionFind(n) 
        
    restrictions = set([tuple(x) for x in restrictions]) 
                
    for a, b in requests: 
        pa, pb = uf.find(a), uf.find(b) 
        copy = list(restrictions)  # This is an optimization to shorten the restriction list 
        for c, d in copy: 
            pc, pd = uf.find(c), uf.find(d) 
            restrictions.remove((c, d))  # Need to remove first then add in case (c, d)== (pc, pd) 
            restrictions.add((pc, pd)) 
            if (pa, pb) == (pc, pd) or (pa, pb) == (pd, pc): 
                res.append(False) 
                break 
        else: 
            res.append(True) 
            uf.union(a, b) 
                                
    return res