Get Watched Videos by Your Friends - Practice Coding Problems

Get Watched Videos by Your Friends - Problem

Imagine a social network where everyone watches videos and has friends. You want to discover new content by exploring videos watched by people at different "friendship levels" from you.

Level 1 friends: Your direct friends
Level 2 friends: Friends of your friends
Level k friends: People exactly k friendship connections away from you

Given a person's id and a target friendship level, return all videos watched by people at that exact level, sorted by frequency (ascending) and alphabetically for ties. This is essentially finding videos in your social network at a specific "distance" using graph traversal!

Input & Output

example_1.py — Basic Social Network

$ Input: watchedVideos = [["A","B"],["C"],["B","C"],["D"]], friends = [[1,2],[0,3],[0,3],[1,2]], id = 0, level = 1

› Output: ["B","C"]

💡 Note: Person 0's friends are [1,2]. Person 1 watched ["C"], person 2 watched ["B","C"]. Videos: B(1), C(2). Sorted by frequency: ["B","C"]

example_2.py — Level 2 Friends

$ Input: watchedVideos = [["A","B"],["C"],["B","C"],["D"]], friends = [[1,2],[0,3],[0,3],[1,2]], id = 0, level = 2

› Output: ["D"]

💡 Note: Person 0's level 2 friends are [3]. Person 3 watched ["D"]. Result: ["D"]

example_3.py — Self (Level 0)

$ Input: watchedVideos = [["A","B"],["C"],["B","C"],["D"]], friends = [[1,2],[0,3],[0,3],[1,2]], id = 0, level = 0

› Output: ["A","B"]

💡 Note: Level 0 means the person themselves. Person 0 watched ["A","B"]. Sorted alphabetically: ["A","B"]

Visualization

Tap to expand

Understanding the Visualization

Start at You

Begin BFS from your position (level 0)

Find Direct Friends

Explore all your direct friends (level 1)

Expand Outward

Continue to friends of friends (level 2, 3, ...)

Collect Videos

At target level, gather all videos and sort by frequency

Key Takeaway

🎯 Key Insight: BFS naturally explores the graph level by level, making it perfect for finding people at exactly k friendship connections away. This eliminates the need to calculate distances individually and provides optimal performance.

Time & Space Complexity

Time Complexity

⏱️

O(n + m + v log v)

BFS takes O(n + m) where n is people and m is friendships, plus O(v log v) for sorting videos

⚡ Linearithmic

Space Complexity

O(n + v)

Queue and visited set take O(n), video frequency map takes O(v)

⚡ Linearithmic Space

Constraints

n == friends.length == watchedVideos.length
2 ≤ n ≤ 100
1 ≤ friends[i].length ≤ n - 1
0 ≤ friends[i][j] ≤ n - 1
0 ≤ id < n
1 ≤ level ≤ n - 1
All values in friends[i] are unique
The number of videos watched by each person is at most 100

Asked in

f Facebook 45 a Amazon 32 G Google 28 ⊞ Microsoft 22

The optimal solution uses BFS (Breadth-First Search) to traverse the friendship graph level by level. Start from the target person and explore friends at each level until reaching the desired level. Then collect videos from all people at that level, count frequencies, and sort by frequency (ascending) then alphabetically. Time complexity: O(n + m + v log v) where n is people, m is friendships, and v is unique videos.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-by-Level Traversal (Optimal)	O(n + m + v log v)	O(n + v)	Use BFS to traverse the friendship graph level by level until reaching target level
Brute Force (DFS for Each Person)	O(n * (n + m) + v log v)	O(n + v)	Check distance from target person to every other person individually

BFS Level-by-Level Traversal (Optimal) — Algorithm Steps

Initialize BFS queue with the target person at level 0
Use visited set to avoid revisiting the same person
For each level, process all people in current queue
Add their friends to next level queue
When reaching target level, collect videos and count frequencies
Sort results by frequency (ascending) then alphabetically

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with target person in queue

Level 1

Add all direct friends to queue

Level 2

Add friends of friends to queue

Target Level

Collect videos from people at target level

Code -

solution.c — C

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

// Note: Simplified C implementation
// Full implementation would require proper dynamic data structures

typedef struct {
    int* data;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, int item) {
    if (q->size < q->capacity) {
        q->rear = (q->rear + 1) % q->capacity;
        q->data[q->rear] = item;
        q->size++;
    }
}

int dequeue(Queue* q) {
    if (q->size > 0) {
        int item = q->data[q->front];
        q->front = (q->front + 1) % q->capacity;
        q->size--;
        return item;
    }
    return -1;
}

char** watchedVideosByFriends(char*** watchedVideos, int* watchedVideosSize, int** friends, int* friendSizes, int friendsSize, int id, int level, int* returnSize) {
    // Simplified implementation
    *returnSize = 0;
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m + v log v)

BFS takes O(n + m) where n is people and m is friendships, plus O(v log v) for sorting videos

⚡ Linearithmic

Space Complexity

O(n + v)

Queue and visited set take O(n), video frequency map takes O(v)

⚡ Linearithmic Space

Constraints

n == friends.length == watchedVideos.length
2 ≤ n ≤ 100
1 ≤ friends[i].length ≤ n - 1
0 ≤ friends[i][j] ≤ n - 1
0 ≤ id < n
1 ≤ level ≤ n - 1
All values in friends[i] are unique
The number of videos watched by each person is at most 100

31.2K Views

Medium Frequency

~18 min Avg. Time

890 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

BFS Level-by-Level Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler