Obtenga videos vistos por sus amigos

Hay  n personas, cada persona tiene una identificación única   entre  0 y  n-1. Dadas las matrices  watchedVideos y  friends, donde  watchedVideos[i] y  friends[i] contienen la lista de videos vistos y la lista de amigos respectivamente para la persona con  id = i.

El nivel  1  de los videos son videos vistos por sus amigos, el nivel  2  de videos son videos vistos por los amigos de sus amigos, etc. En general, el nivel  k de los videos son videos vistos por personas con la ruta más corta  exactamente  igual a la  k suya. Dado su  id y el  level de videos, devuelva la lista de videos ordenados por sus frecuencias (en aumento). Para videos con la misma frecuencia, ordénelos alfabéticamente de menor a mayor. 

 

Ejemplo 1:

Entrada : watchVideos = [["A", "B"], ["C"], ["B", "C"], ["D"]], amigos = [[1,2], [0, 3], [0,3], [1,2]], id = 0, nivel = 1
 Salida: ["B", "C"] 
 Explicación:  
Tiene id = 0 (color verde en la figura) y su los amigos son (color amarillo en la figura): 
Persona con identificación = 1 - >watchVideos = ["C"]  
Persona con identificación = 2 - >watchVideos = ["B", "C"]  
Las frecuencias de observación de videos por parte de sus amigos son :  
B -> 1  
C -> 2

Idea: El significado del título es más difícil de entender. Después de que esté claro, es probable que los amigos representen un gráfico, y luego le den un punto de partida, un nivel, es decir, una serie de amigos después de BFS, y luego cuenten las películas de estos amigos, y emitan según la frecuencia de pequeño a grande , Y luego genera la misma frecuencia en orden alfabético;

class Solution {
    private class Node {
        public String movie;
        public int fre;
        public Node (String movie, int fre) {
            this.movie = movie;
            this.fre = fre;
        }
    }
    
    public class NodeComparator implements Comparator<Node> {
        @Override
        public int compare(Node a, Node b) {
            if(a.fre != b.fre) {
                return a.fre - b.fre;
            } else {
                return a.movie.compareTo(b.movie);
            }
        }
    }
    
    public List<String> watchedVideosByFriends( List<List<String>> watchedVideos, 
                                                int[][] friends, 
                                                int id, 
                                                int level) {
        HashMap<Integer, HashSet<Integer>> graph = new HashMap<>();
        for(int i = 0; i < friends.length; i++) {
            int person = i;
            for(int j = 0; j  < friends[i].length; j++) {
                int friend = friends[i][j];
                graph.putIfAbsent(person, new HashSet<Integer>());
                graph.putIfAbsent(friend, new HashSet<Integer>());
                graph.get(person).add(friend);
                graph.get(friend).add(person);
            }
        }
        
        List<Integer> friendAtLevel = bfs(graph, id, level);
        HashMap<String, Integer> hashmap = new HashMap<>();
        for(Integer index: friendAtLevel) {
            List<String> list = watchedVideos.get(index);
            for(String movie: list) {
                if(hashmap.containsKey(movie)) {
                    hashmap.put(movie, hashmap.get(movie) + 1);
                } else {
                    hashmap.put(movie, 1);
                }
            }
        }
        
        List<Node> watchedmovies = new ArrayList<Node>();
        for(String movie: hashmap.keySet()) {
            watchedmovies.add(new Node(movie, hashmap.get(movie)));
        }
        Collections.sort(watchedmovies, new NodeComparator());
        
        List<String> result = new ArrayList<String>();
        for(int i = 0; i < watchedmovies.size(); i++) {
            result.add(watchedmovies.get(i).movie);
        }
        return result;
    }
    
    private List<Integer> bfs(HashMap<Integer, 
                              HashSet<Integer>> graph,
                             int start, int k) {
        List<Integer> result = new ArrayList<Integer>();
        Queue<Integer> queue = new LinkedList<Integer>();
        HashSet<Integer> visited = new HashSet<Integer>();
        queue.offer(start);
        visited.add(start);
        
        int step = 0;
        boolean find = false;
        while(!queue.isEmpty() && !find) {
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                Integer head = queue.poll();
                if(step == k) {
                    result.add(head);
                    find = true;
                    continue;
                } 
                for(Integer neighbor: graph.get(head)) {
                    if(!visited.contains(neighbor)) {
                        visited.add(neighbor);
                        queue.offer(neighbor);
                    }
                }
            }
            step++;
        }
        return result;
    }
}