Sistema de autocompletado de búsqueda de diseño

Diseñe un sistema de autocompletado de búsqueda para un motor de búsqueda. Los usuarios pueden ingresar una oración (al menos una palabra y terminar con un carácter especial  '#'). Para  cada carácter  que escriben,  excepto '#' , debe devolver las  3  oraciones históricas más populares que tienen el prefijo igual que la parte de la oración ya escrita. Aquí están las reglas específicas:

1. El grado importante para una oración se define como la cantidad de veces que un usuario escribió exactamente la misma oración antes.
2. Las 3 oraciones más populares devueltas deben clasificarse por grado (la primera es la más activa). Si varias oraciones tienen el mismo grado de calor, debe usar el orden del código ASCII (una más pequeña aparece primero).
3. Si existen menos de 3 oraciones calientes, simplemente devuelve tantas como puedas.
4. Cuando la entrada es un carácter especial, significa que la oración termina y, en este caso, debe devolver una lista vacía.

Su trabajo es implementar las siguientes funciones:

La función constructora:

AutocompleteSystem(String[] sentences, int[] times): Este es el constructor. La entrada es  información histórica . Sentences es una matriz de cadenas compuesta de oraciones previamente escritas. Times es el tiempo correspondiente en que se ha escrito una oración. Su sistema debe registrar estos datos históricos.

Ahora, el usuario quiere ingresar una nueva oración. La siguiente función proporcionará el siguiente carácter que escriba el usuario:

List<String> input(char c): La entrada  c es el siguiente carácter escrito por el usuario. El carácter solo será letras minúsculas ( 'a' a  'z'), espacio en blanco ( ' ') o un carácter especial ( '#'). Además, la oración escrita anteriormente debe registrarse en su sistema. La salida serán las  3  oraciones históricas más populares que tienen el prefijo igual que la parte de la oración ya escrita.

Ejemplo:
Operación:  AutocompleteSystem (["i love you", "island", "ironman", "i love leetcode"], [5,3,2,2])
El sistema ya ha rastreado las siguientes oraciones y sus correspondientes tiempos:
"i love you" :  5 tiempos
"island" :  3 tiempos
"ironman" :  2 tiempos
"i love leetcode" :  2 tiempos de
ahora, el usuario inicia otra búsqueda:

Operación:  entrada ( 'i')
de salida:  [ "te amo", "isla", "i love leetcode"]
Explicación:
Hay cuatro Oraciones que tienen prefijo  "i". Entre ellos, "ironman" y "i love leetcode" tienen el mismo título. Como  ' ' tiene el código ASCII 32 y 'r' tiene el código ASCII 114, "i love leetcode" debe estar delante de "ironman". Además, solo necesitamos generar las 3 frases más populares, por lo que "ironman" será ignorado.

Idea: Esta pregunta es exactamente la misma que el Sistema de sugerencia de búsqueda . La sutil diferencia es que después de que el tipo de entrada haya finalizado, la entrada de palabra también debe ingresar las estadísticas de frecuencia de palabra. Luego, la frecuencia de la oración debe almacenarse en el trienodo. Es nulo, entonces el futuro cur también es nulo,

class AutocompleteSystem {
    private class TrieNode {
        public HashMap<Character, TrieNode> children;
        public HashMap<String, Integer> counts;
        public boolean isword;
        public TrieNode() {
            this.children = new HashMap<Character, TrieNode>();
            this.counts = new HashMap<String, Integer>();
            this.isword = false;
        }
    }
    
    private class Trie {
        private TrieNode root;
        
        public Trie() {
            this.root = new TrieNode();
        }
        
        public void insert(String sentence, int time) {
            TrieNode cur = root;
            for(char c : sentence.toCharArray()) {
                TrieNode next = cur.children.get(c);
                if(next == null) {
                    next = new TrieNode();
                    cur.children.put(c, next);
                }
                cur = next;
                cur.counts.put(sentence, cur.counts.getOrDefault(sentence, 0) + time);
            }
            cur.isword = true;
        }
    }
    
    private class Node {
        private String sentence;
        private int fre;
        public Node(String sentence, int fre) {
            this.sentence = sentence;
            this.fre = fre;
        }
    }
    
    private class NodeComparator implements Comparator<Node> {
        @Override
        public int compare(Node a, Node b) {
            if(a.fre != b.fre) {
                return b.fre - a.fre;
            } else {
                return a.sentence.compareTo(b.sentence);
            }
        }
    }

    private Trie trie;
    private StringBuilder sb;
    private TrieNode cur;
    private String prefix;
    public AutocompleteSystem(String[] sentences, int[] times) {
        trie  = new Trie();
        for(int i = 0; i < sentences.length; i++) {
            trie.insert(sentences[i], times[i]);
        }
        prefix = "";
        sb = new StringBuilder();
        cur = trie.root;
    }
    
    public List<String> input(char c) {
        if(c == '#') {
            trie.insert(sb.toString(), 1);
            sb = new StringBuilder();
            cur = trie.root;
            return new ArrayList<String>();
        }
        sb.append(c);
        // 注意这里，如果下面没有了，那么以后也没有了，cur 赋值为null；
        if(cur == null || !cur.children.containsKey(c)) {
            cur = null;
            return new ArrayList<String>();
        } else {
            cur = cur.children.get(c);
            PriorityQueue<Node> pq = new PriorityQueue<Node>(new NodeComparator());
            for(String sentence: cur.counts.keySet()) {
                pq.add(new Node(sentence, cur.counts.get(sentence)));
            }
            List<String> list = new ArrayList<String>();
            int count = 0;
            while(!pq.isEmpty() && count < 3) {
                Node node = pq.poll();
                list.add(node.sentence);
                count++;
            }
            return list;
        }
    }
}

/**
 * Your AutocompleteSystem object will be instantiated and called as such:
 * AutocompleteSystem obj = new AutocompleteSystem(sentences, times);
 * List<String> param_1 = obj.input(c);
 */