Social Network Analyzer - Problem

Model a social network as a graph where each person is a node and friendships are edges. Implement functionality to:

Find mutual friends between two people
Calculate degrees of separation (shortest path between two people)
Suggest friends-of-friends (people connected through exactly one mutual friend)

Given a list of friendships and two people, return their mutual friends, degrees of separation, and friend suggestions for the first person.

friendships is a 2D array where each element [a, b] represents a bidirectional friendship between person a and person b.

Input & Output

Example 1 — Basic Social Network

$ Input: friendships = [[1,2],[1,3],[2,4],[3,4],[4,5]], person1 = 1, person2 = 4

› Output: [[2,3],2,[5]]

💡 Note: Mutual friends of 1 and 4: [2,3] (both connected to 1 and 4). Degrees of separation: 2 (shortest path 1→2→4 or 1→3→4). Friend suggestions for person 1: [5] (friend of person 4, who is connected to 1's friends)

Example 2 — Direct Connection

$ Input: friendships = [[1,2],[2,3],[3,4]], person1 = 1, person2 = 2

› Output: [[],1,[3]]

💡 Note: No mutual friends (empty array). Degrees of separation: 1 (direct friends). Friend suggestions for person 1: [3] (friend of person 2)

Example 3 — Same Person

$ Input: friendships = [[1,2],[2,3]], person1 = 1, person2 = 1

› Output: [[],0,[3]]

💡 Note: Same person has 0 degrees of separation. Friend suggestions: [3] (friend of friend 2)

Constraints

1 ≤ friendships.length ≤ 1000
friendships[i].length == 2
1 ≤ person1, person2 ≤ 1000
All friendships are bidirectional

Visualization

Tap to expand

Asked in

F Facebook 85 L LinkedIn 72 G Google 45 T Twitter 38

The key insight is modeling social networks as graphs and using BFS for shortest path finding. Build an adjacency list, find mutual friends through set intersection, use BFS to guarantee shortest connection path, and explore friends-of-friends for suggestions. Best approach uses BFS optimization: Time: O(V + E), Space: O(V + E).

Common Approaches

✓ BFS Shortest Path

⏱️ Time: O(V + E) Space: O(V + E)

Build adjacency list, find mutual friends by set intersection, use BFS to find shortest path (degrees of separation), and systematically find friends-of-friends suggestions.

Brute Force

⏱️ Time: O(V²) Space: O(V + E)

Build adjacency list, then for mutual friends iterate through all friends of both people. For degrees of separation, try all possible paths using DFS until target is found. For suggestions, check all friends of friends manually.

BFS Shortest Path — Algorithm Steps

Step 1: Build adjacency list from friendships
Step 2: Find mutual friends using set intersection
Step 3: Use BFS to find shortest path between people
Step 4: Get friend suggestions from friends' connections

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list representation

BFS Queue

Use queue to explore level by level

Shortest Path

First path found is guaranteed shortest

Result

Return all social network insights

Code -

solution.c — C

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

#define MAX_PEOPLE 1000
#define MAX_FRIENDS 100
#define MAX_QUEUE 10000

int graph[MAX_PEOPLE][MAX_FRIENDS];
int friendCount[MAX_PEOPLE];

struct QueueNode {
    int person;
    int distance;
};

int bfsShortestPath(int start, int target) {
    if (start == target) return 0;
    
    struct QueueNode queue[MAX_QUEUE];
    int visited[MAX_PEOPLE] = {0};
    int front = 0, rear = 0;
    
    queue[rear++] = (struct QueueNode){start, 0};
    visited[start] = 1;
    
    while (front < rear) {
        struct QueueNode current = queue[front++];
        
        for (int i = 0; i < friendCount[current.person]; i++) {
            int neighbor = graph[current.person][i];
            
            if (neighbor == target) {
                return current.distance + 1;
            }
            
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                queue[rear++] = (struct QueueNode){neighbor, current.distance + 1};
            }
        }
    }
    
    return -1;
}

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void solution(int friendships[][2], int numFriendships, int person1, int person2) {
    // Initialize
    memset(friendCount, 0, sizeof(friendCount));
    
    // Build adjacency list
    for (int i = 0; i < numFriendships; i++) {
        int a = friendships[i][0], b = friendships[i][1];
        graph[a][friendCount[a]++] = b;
        graph[b][friendCount[b]++] = a;
    }
    
    // Find mutual friends
    int mutual[MAX_FRIENDS];
    int mutualCount = 0;
    for (int i = 0; i < friendCount[person1]; i++) {
        int friend1 = graph[person1][i];
        for (int j = 0; j < friendCount[person2]; j++) {
            if (graph[person2][j] == friend1) {
                mutual[mutualCount++] = friend1;
                break;
            }
        }
    }
    qsort(mutual, mutualCount, sizeof(int), compare);
    
    // Find degrees of separation using BFS
    int degrees = bfsShortestPath(person1, person2);
    
    // Find friend suggestions
    int suggestions[MAX_PEOPLE];
    int suggestionCount = 0;
    int isFriend[MAX_PEOPLE] = {0};
    
    // Mark direct friends
    for (int i = 0; i < friendCount[person1]; i++) {
        isFriend[graph[person1][i]] = 1;
    }
    isFriend[person1] = 1;
    
    for (int i = 0; i < friendCount[person1]; i++) {
        int friend1 = graph[person1][i];
        for (int j = 0; j < friendCount[friend1]; j++) {
            int fof = graph[friend1][j];
            if (!isFriend[fof]) {
                suggestions[suggestionCount++] = fof;
                isFriend[fof] = 1;
            }
        }
    }
    qsort(suggestions, suggestionCount, sizeof(int), compare);
    
    // Print result
    printf("[[");
    for (int i = 0; i < mutualCount; i++) {
        if (i > 0) printf(",");
        printf("%d", mutual[i]);
    }
    printf("],%d,[", degrees);
    for (int i = 0; i < suggestionCount; i++) {
        if (i > 0) printf(",");
        printf("%d", suggestions[i]);
    }
    printf("]]");
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse friendships array
    int friendships[1000][2];
    int numFriendships = 0;
    char *ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            friendships[numFriendships][0] = strtol(ptr, &ptr, 10);
            ptr++; // Skip comma
            friendships[numFriendships][1] = strtol(ptr, &ptr, 10);
            numFriendships++;
        }
        ptr++;
    }
    
    int person1, person2;
    scanf("%d", &person1);
    scanf("%d", &person2);
    
    solution(friendships, numFriendships, person1, person2);
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

BFS visits each vertex and edge exactly once

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list plus BFS queue storage

✓ Linear Space

34.5K Views

High Frequency

~25 min Avg. Time

892 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

Social Network Analyzer - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Shortest Path — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler