from collections import deque
from collections import defaultdict

def watched_videos_by_friends(watched_videos, friends, id, level):
    visited = set()
    q = deque([(id, 0)])
    video_freq = defaultdict(int)

    while q:
        current_id, current_level = q.popleft()

        if current_level == level:
            for video in watched_videos[current_id]:
                video_freq[video] += 1
        elif current_level < level:
            for friend_id in friends[current_id]:
                if friend_id not in visited:
                    visited.add(friend_id)
                    q.append((friend_id, current_level + 1))

    result = sorted(video_freq.keys(), key=lambda x: (video_freq[x], x))

    return result

The algorithm works as follows: 1. Initialize a visited set to keep track of the visited person ids, and a queue, which stores pairs containing the person id and the level or search depth. 2. Push the given id and level 0 onto the queue and mark the id visited. 3. While there are still unprocessed items in the queue, check the current level of the person in the queue. a) If the current level is equal to the given level, increment the count of each video watched by this person in a frequency map. b) If the current level is less than the given level, iterate through the friends of the current person and push those friends' ids in the queue with the incremented level if they haven't been visited yet, and mark them visited. 4. Create a result list from the keys in the frequency map. 5. Sort the result list based on the frequency of the videos and their names. 6. Return the sorted result list.

This algorithm has a breadth-first search (BFS) traversal through the connections, which helps in finding the shortest path.

#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <algorithm>
#include <string>

using namespace std;

vector<string> watchedVideosByFriends(vector<vector<string>>& watchedVideos, vector<vector<int>>& friends, int id, int level) {
    unordered_set<int> visited;
    queue<pair<int, int>> q;
    unordered_map<string, int> video_freq;

    q.push({id, 0});
    visited.insert(id);

    while (!q.empty()) {
        int current_id = q.front().first;
        int current_level = q.front().second;
        q.pop();

        if (current_level == level) {
            for (const string& video : watchedVideos[current_id]) {
                video_freq[video]++;
            }
        } else if (current_level < level) {
            for (int friend_id : friends[current_id]) {
                if (visited.find(friend_id) == visited.end()) {
                    visited.insert(friend_id);
                    q.push({friend_id, current_level + 1});
                }
            }
        }
    }

    vector<string> result;
    for (const auto& p : video_freq) {
        result.push_back(p.first);
    }

    sort(result.begin(), result.end(), [&video_freq](const string& a, const string& b) {
        if (video_freq[a] == video_freq[b]) {
            return a < b;
        } else {
            return video_freq[a] < video_freq[b];
        }
    });

    return result;
}

The algorithm works as follows: 1. Initialize a visited set to keep track of the visited person ids, and a queue, which stores pairs containing the person id and the level or search depth. 2. Push the given id and level 0 onto the queue and mark the id visited. 3. While there are still unprocessed items in the queue, check the current level of the person in the queue. a) If the current level is equal to the given level, increment the count of each video watched by this person in a frequency map. b) If the current level is less than the given level, iterate through the friends of the current person and push those friends' ids in the queue with the incremented level if they haven't been visited yet, and mark them visited. 4. Create a result list from the keys in the frequency map. 5. Sort the result list based on the frequency of the videos and their names. 6. Return the sorted result list.

This algorithm has a breadth-first search (BFS) traversal through the connections, which helps in finding the shortest path.