Get Watched Videos by Your Friends solution and explanation

from collections import deque, defaultdict

def getWatchedVideosByFriends(watchedVideos, friends, id, level):
    n = len(watchedVideos)
    queue = deque([id])
    visited = set([id])
    current_level = 0
    
    while queue and current_level < level:
        for _ in range(len(queue)):
            person = queue.popleft()
            for f in friends[person]:
                if f not in visited:
                    visited.add(f)
                    queue.append(f)
        current_level += 1
    
    video_count = defaultdict(int)
    for friend in queue:
        for video in watchedVideos[friend]:
            video_count[video] += 1
    
    return sorted(video_count.keys(), key=lambda x: (video_count[x], x))

function getWatchedVideosByFriends(watchedVideos, friends, id, level) {
    let n = watchedVideos.length;
    let queue = [id];
    let visited = new Set([id]);
    let currentLevel = 0;
    
    while (queue.length && currentLevel < level) {
        let size = queue.length;
        for (let i = 0; i < size; i++) {
            let person = queue.shift();
            for (let f of friends[person]) {
                if (!visited.has(f)) {
                    visited.add(f);
                    queue.push(f);
                }
            }
        }
        currentLevel++;
    }
    
    let videoCount = {};
    for (let friend of queue) {
        for (let video of watchedVideos[friend]) {
            videoCount[video] = (videoCount[video] || 0) + 1;
        }
    }
    
    return Object.keys(videoCount).sort((a, b) => videoCount[a] === videoCount[b] ? a.localeCompare(b) : videoCount[a] - videoCount[b]);
}

import java.util.*;

public class Solution {
    public List<String> getWatchedVideosByFriends(List<List<String>> watchedVideos, List<List<Integer>> friends, int id, int level) {
        Set<Integer> visited = new HashSet<>();
        List<Integer> currLevelFriends = new ArrayList<>();
        dfs(friends, visited, id, level, currLevelFriends);
        Map<String, Integer> videoCount = new HashMap<>();
        
        for (int friendId : currLevelFriends) {
            for (String video : watchedVideos.get(friendId)) {
                videoCount.put(video, videoCount.getOrDefault(video, 0) + 1);
            }
        }
        
        List<String> result = new ArrayList<>(videoCount.keySet());
        result.sort((a, b) -> {
            int comp = Integer.compare(videoCount.get(a), videoCount.get(b));
            if (comp == 0) return a.compareTo(b);
            return comp;
        });
        return result;
    }

    private void dfs(List<List<Integer>> friends, Set<Integer> visited, int current, int level, List<Integer> currLevelFriends) {
        if (level == 0) {
            currLevelFriends.add(current);
            return;
        }
        visited.add(current);
        for (int f : friends.get(current)) {
            if (!visited.contains(f)) {
                dfs(friends, visited, f, level - 1, currLevelFriends);
            }
        }
        visited.remove(current);
    }
}

#include <iostream>
#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>

using namespace std;

void dfs(int current, vector<vector<int>>& friends, unordered_set<int>& visited, vector<int>& currLevelFriends, int level) {
    if (level == 0) {
        currLevelFriends.push_back(current);
        return;
    }
    visited.insert(current);
    for (int f : friends[current]) {
        if (!visited.count(f)) {
            dfs(f, friends, visited, currLevelFriends, level - 1);
        }
    }
    visited.erase(current);
}

vector<string> getWatchedVideosByFriends(vector<vector<string>>& watchedVideos, vector<vector<int>>& friends, int id, int level) {
    unordered_set<int> visited;
    vector<int> currLevelFriends;
    dfs(id, friends, visited, currLevelFriends, level);
    
    unordered_map<string, int> videoCount;
    for (int friendId : currLevelFriends) {
        for (string& video : watchedVideos[friendId]) {
            videoCount[video]++;
        }
    }
    
    vector<pair<string, int>> videoList(videoCount.begin(), videoCount.end());
    sort(videoList.begin(), videoList.end(), [](pair<string, int> a, pair<string, int> b) {
        return a.second == b.second ? a.first < b.first : a.second < b.second;
    });
    
    vector<string> result;
    for (auto& p : videoList) {
        result.push_back(p.first);
    }
    return result;
}

function watchedVideosByFriends(
    watchedVideos: string[][],
    friends: number[][],
    id: number,
    level: number,
): string[] {
    let q: number[] = [id];
    const n: number = friends.length;
    const vis: boolean[] = Array(n).fill(false);
    vis[id] = true;
    while (level-- > 0) {
        const nq: number[] = [];
        for (const i of q) {
            for (const j of friends[i]) {
                if (!vis[j]) {
                    vis[j] = true;
                    nq.push(j);
                }
            }
        }
        q = nq;
    }
    const cnt: { [key: string]: number } = {};
    for (const i of q) {
        for (const v of watchedVideos[i]) {
            cnt[v] = (cnt[v] || 0) + 1;
        }
    }
    const ans: string[] = Object.keys(cnt);
    ans.sort((a, b) => {
        if (cnt[a] === cnt[b]) {
            return a.localeCompare(b);
        }
        return cnt[a] - cnt[b];
    });
    return ans;
}

func watchedVideosByFriends(watchedVideos [][]string, friends [][]int, id int, level int) []string {
	q := []int{id}
	n := len(friends)
	vis := make([]bool, n)
	vis[id] = true
	for level > 0 {
		level--
		nextQ := []int{}
		for _, i := range q {
			for _, j := range friends[i] {
				if !vis[j] {
					vis[j] = true
					nextQ = append(nextQ, j)
				}
			}
		}
		q = nextQ
	}
	cnt := make(map[string]int)
	for _, i := range q {
		for _, v := range watchedVideos[i] {
			cnt[v]++
		}
	}
	ans := []string{}
	for key := range cnt {
		ans = append(ans, key)
	}
	sort.Slice(ans, func(i, j int) bool {
		if cnt[ans[i]] == cnt[ans[j]] {
			return ans[i] < ans[j]
		}
		return cnt[ans[i]] < cnt[ans[j]]
	})
	return ans
}