Process Restricted Friend Requests - Practice Coding Problems

Process Restricted Friend Requests - Problem

Imagine you're managing a social network where people can send friend requests, but some pairs of users are forbidden from being connected - either directly or indirectly through mutual friends!

You have n people labeled from 0 to n-1, initially with no friendships. You're given:

Restrictions: A list of pairs [xi, yi] who cannot be friends (directly or through a chain of mutual friends)
Friend Requests: A sequence of requests [uj, vj] processed in order

Your goal is to determine which friend requests can be approved without violating any restrictions. Each successful request creates a permanent friendship that affects all future requests.

Key Challenge: When two people become friends, their entire friend groups merge! You must ensure that no restricted pairs end up in the same connected group.

Input & Output

example_1.py — Basic restrictions

$ Input: n = 3, restrictions = [[0,1]], requests = [[0,2],[2,1],[0,1]]

› Output: [true,false,false]

💡 Note: Request [0,2]: No restriction between 0 and 2, approve. Request [2,1]: Would connect groups {0,2} and {1}, but (0,1) restricted, reject. Request [0,1]: Direct restriction (0,1), reject.

example_2.py — Indirect restrictions

$ Input: n = 5, restrictions = [[0,1],[1,2],[2,3]], requests = [[0,4],[1,2],[3,1],[3,4]]

› Output: [true,false,false,false]

💡 Note: Multiple restrictions create complex constraint network. Request [0,4] is safe. [1,2] directly restricted. [3,1] restricted. [3,4] would indirectly connect restricted pairs through 0.

example_3.py — No restrictions violated

$ Input: n = 4, restrictions = [[0,2]], requests = [[1,3],[0,1],[2,3]]

› Output: [true,true,false]

💡 Note: First two requests create groups {0,1} and {2,3}. The third request [2,3] would merge these groups, putting restricted pair (0,2) together, so it's rejected.

Visualization

Tap to expand

Understanding the Visualization

Network Setup

Initialize agents as isolated nodes with forbidden communication pairs marked

Connection Request

Agent requests secure communication channel with another agent

Security Check

Verify that establishing connection won't create forbidden indirect paths

Decision

Approve and establish connection, or reject to maintain security

Key Takeaway

🎯 Key Insight: Union-Find efficiently tracks connected components while restriction validation ensures security constraints are never violated, even indirectly.

Time & Space Complexity

Time Complexity

⏱️

O(m * (r + α(n)))

For m requests, each requires checking r restrictions plus Union-Find operations with inverse Ackermann time complexity

✓ Linear Growth

Space Complexity

O(n)

Union-Find parent and rank arrays

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
0 ≤ restrictions.length ≤ 1000
restrictions[i].length == 2
0 ≤ x_i, y_i ≤ n - 1
x_i ≠ y_i
1 ≤ requests.length ≤ 1000
requests[j].length == 2
0 ≤ u_j, v_j ≤ n - 1
u_j ≠ v_j
All restrictions and requests contain distinct pairs

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses Union-Find (Disjoint Set Union) with path compression to efficiently track friend groups. For each request, we first check if the union would violate any restrictions by testing whether any restricted pairs would end up in the same connected component. The key insight is to validate before merging rather than maintaining complex constraint graphs.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find with Restriction Validation (Optimal)	O(m * (r + α(n)))	O(n)	Use Union-Find data structure with pre-merge restriction checking
Brute Force with Manual Group Tracking	O(n³)	O(n²)	Track groups manually and check all pairs before merging

Union-Find with Restriction Validation (Optimal) — Algorithm Steps

Initialize Union-Find data structure with path compression and union by rank
For each friend request, find the root representatives of both people
If already in same component, approve (they're already friends)
Otherwise, check each restriction: would merging put any restricted pair together?
If no violations, perform union and approve; otherwise reject

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up Union-Find with each person as their own parent

Find Roots

For request [u,v], find root representatives with path compression

Check Restrictions

Test each restriction: would union put restricted pairs in same component?

Union/Reject

If safe, perform union by rank; otherwise reject request

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct UnionFind {
    int* parent;
    int* rank;
    int n;
};

struct UnionFind* createUF(int n) {
    struct UnionFind* uf = malloc(sizeof(struct UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = calloc(n, sizeof(int));
    uf->n = n;
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    return uf;
}

int find(struct UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(struct UnionFind* uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    
    if (uf->rank[px] < uf->rank[py]) {
        int temp = px; px = py; py = temp;
    }
    uf->parent[py] = px;
    if (uf->rank[px] == uf->rank[py]) {
        uf->rank[px]++;
    }
}

bool* friendRequests(int n, int** restrictions, int restrictionsSize, int* restrictionsColSize,
                    int** requests, int requestsSize, int* requestsColSize, int* returnSize) {
    struct UnionFind* uf = createUF(n);
    bool* result = malloc(requestsSize * sizeof(bool));
    *returnSize = requestsSize;
    
    for (int i = 0; i < requestsSize; i++) {
        int u = requests[i][0], v = requests[i][1];
        int rootU = find(uf, u), rootV = find(uf, v);
        
        if (rootU == rootV) {
            result[i] = true;
            continue;
        }
        
        bool canUnion = true;
        for (int j = 0; j < restrictionsSize; j++) {
            int x = restrictions[j][0], y = restrictions[j][1];
            int rootX = find(uf, x), rootY = find(uf, y);
            if ((rootX == rootU && rootY == rootV) ||
                (rootX == rootV && rootY == rootU)) {
                canUnion = false;
                break;
            }
        }
        
        if (canUnion) {
            unionSets(uf, u, v);
            result[i] = true;
        } else {
            result[i] = false;
        }
    }
    
    free(uf->parent);
    free(uf->rank);
    free(uf);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * (r + α(n)))

For m requests, each requires checking r restrictions plus Union-Find operations with inverse Ackermann time complexity

✓ Linear Growth

Space Complexity

O(n)

Union-Find parent and rank arrays

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
0 ≤ restrictions.length ≤ 1000
restrictions[i].length == 2
0 ≤ x_i, y_i ≤ n - 1
x_i ≠ y_i
1 ≤ requests.length ≤ 1000
requests[j].length == 2
0 ≤ u_j, v_j ≤ n - 1
u_j ≠ v_j
All restrictions and requests contain distinct pairs

28.4K Views

Medium Frequency

~25 min Avg. Time

842 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Union-Find with Restriction Validation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler