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

/* 
思路：
1. 使用并查集（Union-Find）来跟踪朋友关系。
2. 对于每个请求，检查两个用户是否可以成为朋友，即它们的根节点是否会违反任何限制。
3. 如果没有违反限制，则合并两个用户。
4. 返回请求是否成功的布尔数组。
5. 使用Java Stream API处理数组。
*/

import java.util.Arrays;
import java.util.stream.IntStream;

class Solution {
    private int[] parent;
    private int[] rank;

    public boolean[] friendRequests(int n, int[][] restrictions, int[][] requests) {
        parent = IntStream.range(0, n).toArray();
        rank = new int[n];
        Arrays.fill(rank, 1);
        return IntStream.range(0, requests.length)
                .mapToObj(i -> {
                    int u = requests[i][0];
                    int v = requests[i][1];
                    int pu = find(u);
                    int pv = find(v);
                    if (pu == pv) return true;
                    boolean canBeFriends = Arrays.stream(restrictions)
                            .noneMatch(restriction -> {
                                int r1 = find(restriction[0]);
                                int r2 = find(restriction[1]);
                                return (pu == r1 && pv == r2) || (pu == r2 && pv == r1);
                            });
                    if (canBeFriends) {
                        union(u, v);
                    }
                    return canBeFriends;
                })
                .mapToBoolean(Boolean::booleanValue)
                .toArray();
    }

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

    private void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX != rootY) {
            if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else if (rank[rootX] < rank[rootY]) {
                parent[rootX] = rootY;
            } else {
                parent[rootY] = rootX;
                rank[rootX]++;
            }
        }
    }
}