处理含限制条件的好友请求

标签: 并查集 图

难度: Hard

给你一个整数 n ，表示网络上的用户数目。每个用户按从 0 到 n - 1 进行编号。

给你一个下标从 0 开始的二维整数数组 restrictions ，其中 restrictions[i] = [xi, yi] 意味着用户 xi 和用户 yi 不能 成为 朋友 ，不管是 直接 还是通过其他用户 间接 。

最初，用户里没有人是其他用户的朋友。给你一个下标从 0 开始的二维整数数组 requests 表示好友请求的列表，其中 requests[j] = [uj, vj] 是用户 uj 和用户 vj 之间的一条好友请求。

如果 uj 和 vj 可以成为 朋友 ，那么好友请求将会 成功 。每个好友请求都会按列表中给出的顺序进行处理（即，requests[j] 会在 requests[j + 1] 前）。一旦请求成功，那么对所有未来的好友请求而言， uj 和 vj 将会 成为直接朋友 。

返回一个 布尔数组 result ，其中元素遵循此规则：如果第 j 个好友请求 成功 ，那么 result[j] 就是 true ；否则，为 false 。

注意：如果 uj 和 vj 已经是直接朋友，那么他们之间的请求将仍然 成功 。

示例 1：

输入：n = 3, restrictions = [[0,1]], requests = [[0,2],[2,1]]
输出：[true,false]
解释：
请求 0 ：用户 0 和 用户 2 可以成为朋友，所以他们成为直接朋友。 
请求 1 ：用户 2 和 用户 1 不能成为朋友，因为这会使 用户 0 和 用户 1 成为间接朋友 (1--2--0) 。

示例 2：

输入：n = 3, restrictions = [[0,1]], requests = [[1,2],[0,2]]
输出：[true,false]
解释：
请求 0 ：用户 1 和 用户 2 可以成为朋友，所以他们成为直接朋友。 
请求 1 ：用户 0 和 用户 2 不能成为朋友，因为这会使 用户 0 和 用户 1 成为间接朋友 (0--2--1) 。

示例 3：

输入：n = 5, restrictions = [[0,1],[1,2],[2,3]], requests = [[0,4],[1,2],[3,1],[3,4]]
输出：[true,false,true,false]
解释：
请求 0 ：用户 0 和 用户 4 可以成为朋友，所以他们成为直接朋友。 
请求 1 ：用户 1 和 用户 2 不能成为朋友，因为他们之间存在限制。
请求 2 ：用户 3 和 用户 1 可以成为朋友，所以他们成为直接朋友。 
请求 3 ：用户 3 和 用户 4 不能成为朋友，因为这会使 用户 0 和 用户 1 成为间接朋友 (0--4--3--1) 。

提示：

  • 2 <= n <= 1000
  • 0 <= restrictions.length <= 1000
  • restrictions[i].length == 2
  • 0 <= xi, yi <= n - 1
  • xi != yi
  • 1 <= requests.length <= 1000
  • requests[j].length == 2
  • 0 <= uj, vj <= n - 1
  • uj != vj

Submission

运行时间: 203 ms

内存: 17.2 MB

class Solution:
    def friendRequests(self, n: int, restrictions: List[List[int]], requests: List[List[int]]) -> List[bool]:
        fri = defaultdict(set)
        res = defaultdict(set)
        for a, b in restrictions:
            res[a].add(b)
            res[b].add(a)
        for i in range(n):
            fri[i].add(i)
        ans = []
        for a, b in requests:
            if b in fri and a in fri[b]:
                ans.append(True)
                continue
            if (fri[a] & res[b]) or (fri[b] & res[a]):
                ans.append(False)
                continue
            fri[a] |= fri[b]
            res[a] |= res[b]
            for x in fri[a]:
                fri[x] = fri[a]
                res[x] = res[a]
            ans.append(True)
        return ans

Explain

此题解使用了两个字典 `fri` 和 `res` 来存储朋友关系和限制条件。其中 `fri` 的键是用户编号，值是该用户的朋友集合；`res` 的键是用户编号，值是与该用户存在限制的用户集合。处理好友请求时，如果两个用户已经是直接朋友，则请求成功；如果两用户之间存在间接限制，请求失败；否则，更新双方的朋友集和限制集，并将新的朋友关系传播到相关用户，最后标记此请求为成功。

时间复杂度: O(m * n)

空间复杂度: O(n^2)

class Solution:
    def friendRequests(self, n: int, restrictions: List[List[int]], requests: List[List[int]]) -> List[bool]:
        fri = defaultdict(set)  # 用户的朋友集
        res = defaultdict(set)  # 用户的限制集
        for a, b in restrictions:
            res[a].add(b)
            res[b].add(a)
        for i in range(n):
            fri[i].add(i)  # 初始化每个用户至少与自己是朋友
        ans = []
        for a, b in requests:
            if b in fri and a in fri[b]:  # 如果已经是朋友，则请求成功
                ans.append(True)
                continue
            if (fri[a] & res[b]) or (fri[b] & res[a]):  # 检查是否存在间接限制
                ans.append(False)
                continue
            fri[a] |= fri[b]  # 合并朋友集
            res[a] |= res[b]  # 合并限制集
            for x in fri[a]:  # 更新所有相关用户的朋友集和限制集
                fri[x] = fri[a]
                res[x] = res[a]
            ans.append(True)
        return ans

Explore

通过在更新一个用户的朋友集和限制集后，遍历该用户现有的朋友集中的每一个成员，并将每个成员的朋友集和限制集设置为更新后的集合，从而保证所有相关联用户的数据同步。这种方法虽然简单，但可能在大规模数据中效率较低，因为每次更新都需要进行广泛的遍历和更新操作。

算法通过检查两个用户各自的限制集合与对方的朋友集合是否有交集来确定是否存在间接限制。具体来说，如果用户 A 的限制集中的任何一个用户是用户 B 的朋友，或者用户 B 的限制集中的任何一个用户是用户 A 的朋友，那么就判定存在间接限制，此时好友请求失败。

使用集合合并操作虽然直观且易于理解，但在大数据量时，每次合并操作都可能涉及大量元素的复制，这会导致效率较低。一种更优的数据结构是并查集（Union-Find），它可以更高效地处理动态连通性问题，尤其是在合并集合和查询集合的根元素时，通过路径压缩和按秩合并可以显著提升效率。

在当前的算法实现中，这种多重间接关系的处理是通过逐步更新每个用户的限制集来实现的。当用户 A 和 B 成为朋友时，他们的限制集会合并，因此任何后续的好友请求都会检查这个更新后的限制集。如果存在如上述的复杂间接关系，算法会在合并朋友集的同时合并限制集，并在后续的请求中考虑这些合并后的限制集来判断是否能够添加新的朋友关系。这种方式确保了即使在多重间接关系的情况下也能正确处理限制。