La forma más eficiente de encontrar las K palabras más frecuentes en una secuencia de palabras grande

Entrada: un entero positivo K y un texto grande. En realidad, el texto puede verse como una secuencia de palabras. Así que no tenemos que preocuparnos por cómo dividirlo en una secuencia de palabras.
Resultado: Las palabras K más frecuentes en el texto.

Mi pensamiento es así.

1. use una tabla hash para registrar la frecuencia de todas las palabras mientras recorre toda la secuencia de palabras. En esta fase, la clave es "palabra" y el valor es "frecuencia de palabra". Esto lleva O (n) tiempo.

2. ordenar el par (palabra, palabra-frecuencia); y la clave es "frecuencia de palabras". Esto lleva O (n * lg (n)) tiempo con el algoritmo de clasificación normal.

3. Después de clasificar, solo tomamos las primeras K palabras. Esto lleva tiempo O (K).

Para resumir, el tiempo total es O (n + n lg (n) + K) ， Dado que K es seguramente más pequeño que N, en realidad es O (n lg (n)).

Podemos mejorar esto. En realidad, solo queremos las K palabras más importantes. La frecuencia de otras palabras no nos preocupa. Por lo tanto, podemos usar "clasificación de montón parcial". Para los pasos 2) y 3), no solo clasificamos. En cambio, lo cambiamos para que sea

2 ') construye un montón de pares (palabra, frecuencia de palabra) con "frecuencia de palabra" como clave. Se necesita O (n) tiempo para construir un montón;

3 ') extrae las primeras K palabras del montón. Cada extracción es O (lg (n)). Entonces, el tiempo total es O (k * lg (n)).

En resumen, esta solución costó tiempo O (n + k * lg (n)).

Este es solo mi pensamiento. No he encontrado la forma de mejorar el paso 1).
Espero que algunos expertos en recuperación de información puedan arrojar más luz sobre esta pregunta.

Esto se puede hacer en O (n) tiempo

Solución 1:

Pasos:

1. Cuente palabras y hash, que terminará en la estructura como esta

   var hash = {
     "I" : 13,
     "like" : 3,
     "meow" : 3,
     "geek" : 3,
     "burger" : 2,
     "cat" : 1,
     "foo" : 100,
     ...
     ...
   

2. Recorra el hash y busque la palabra más utilizada (en este caso "foo" 100), luego cree la matriz de ese tamaño

3. Luego, podemos volver a recorrer el hash y usar el número de apariciones de palabras como índice de la matriz, si no hay nada en el índice, cree una matriz o añádala a la matriz. Luego terminamos con una matriz como:

     0   1      2            3                  100
   [[ ],[cat],[burger],[like, meow, geek],[]...[foo]]
   

4. Luego simplemente recorra la matriz desde el final y recopile las k palabras.

Solución 2:

Pasos:

1. Lo mismo que arriba
2. Use min heap y mantenga el tamaño de min heap en k, y para cada palabra en el hash comparamos las apariciones de palabras con min, 1) si es mayor que el valor min, elimine min (si el tamaño de min montón es igual a k) e inserte el número en el montón mínimo. 2) Descanse en condiciones simples.
3. Después de atravesar la matriz, simplemente convertimos el montón mínimo en matriz y devolvemos la matriz.

En general, no obtendrá un tiempo de ejecución mejor que la solución que ha descrito. Tienes que hacer al menos O (n) trabajo para evaluar todas las palabras, y luego O (k) trabajo extra para encontrar los k términos principales.

Si su problema es realmente grande, puede usar una solución distribuida como map / reduce. Haga que n trabajadores del mapa cuenten frecuencias en 1 / enésimo del texto cada uno, y para cada palabra, envíelo a uno de los m trabajadores del reductor calculados en función del hash de la palabra. Luego, los reductores suman los recuentos. Combinar la clasificación sobre las salidas de los reductores le dará las palabras más populares en orden de popularidad.

Una pequeña variación en su solución produce un algoritmo O (n) si no nos importa clasificar el K superior, y un O (n + k * lg (k)) solución si lo hacemos. Creo que ambos límites son óptimos dentro de un factor constante.

La optimización aquí viene nuevamente después de que revisamos la lista, insertándola en la tabla hash. Podemos usar el algoritmo de la mediana de las medianas para seleccionar el K-ésimo elemento más grande de la lista. Este algoritmo es probablemente O (n).

Después de seleccionar el K-ésimo elemento más pequeño, dividimos la lista alrededor de ese elemento como en Quicksort. Obviamente, esto también es O (n). Todo lo que esté en el lado "izquierdo" del pivote está en nuestro grupo de elementos K, así que hemos terminado (simplemente podemos desechar todo lo demás a medida que avanzamos).

Entonces esta estrategia es:

1. Revise cada palabra e insértela en una tabla hash: O (n)
2. Seleccione el K-ésimo elemento más pequeño: O (n)
3. Partición alrededor de ese elemento: O (n)

Si desea clasificar los elementos K, simplemente ordénelos con cualquier clasificación de comparación eficiente en el tiempo O (k * lg (k)), lo que arroja un tiempo de ejecución total de O (n + k * lg (k)).

El límite de tiempo O (n) es óptimo dentro de un factor constante porque debemos examinar cada palabra al menos una vez.

El límite de tiempo O (n + k * lg (k)) también es óptimo porque no hay una forma basada en la comparación de ordenar k elementos en menos de k * lg (k) tiempo.

Si su "lista grande de palabras" es lo suficientemente grande, simplemente puede hacer una muestra y obtener estimaciones. De lo contrario, me gusta la agregación de hash.

Editar :

Por ejemplo me refiero a elegir un subconjunto de páginas y calcular la palabra más frecuente en esas páginas. Siempre que seleccione las páginas de forma razonable y seleccione una muestra estadísticamente significativa, sus estimaciones de las palabras más frecuentes deberían ser razonables.

Este enfoque solo es razonable si tiene tantos datos que procesarlos todos es un poco tonto. Si solo tiene unos pocos megas, debería poder analizar los datos y calcular una respuesta exacta sin sudar en lugar de molestarse en calcular una estimación.

Puede reducir aún más el tiempo dividiendo usando la primera letra de palabras, luego dividiendo el conjunto de palabras múltiples más grande usando el siguiente carácter hasta que tenga k conjuntos de palabras simples. Utilizaría una especie de árbol de 256 vías con listas de palabras parciales / completas en las hojas. Debería tener mucho cuidado de no generar copias de cadenas en todas partes.

Este algoritmo es O (m), donde m es el número de caracteres. Evita esa dependencia de k, lo cual es muy bueno para k grandes [por cierto, el tiempo de ejecución publicado es incorrecto, debería ser O (n * lg (k)), y no estoy seguro de qué es eso en términos de metro].

Si ejecuta ambos algoritmos uno al lado del otro, obtendrá lo que estoy bastante seguro de que es un algoritmo O (min (m, n * lg (k))) asintóticamente óptimo, pero el mío debería ser más rápido en promedio porque no implica hash o clasificación.

Tiene un error en su descripción: Contar toma O (n) tiempo, pero ordenar toma O (m * lg (m)), donde m es el número de palabras únicas . Esto suele ser mucho más pequeño que el número total de palabras, por lo que probablemente debería optimizar la forma en que se construye el hash.

Su problema es el mismo que este: http://www.geeksforgeeks.org/find-the-k-most-frequent-words-from-a-file/

Utilice Trie y min heap para resolverlo de manera eficiente.

Si lo que busca es la lista de k palabras más frecuentes en su texto para cualquier k práctica y para cualquier lenguaje natural, entonces la complejidad de su algoritmo no es relevante.

Solo muestre , digamos, algunos millones de palabras de su texto, procese eso con cualquier algoritmo en cuestión de segundos y los recuentos más frecuentes serán muy precisos.

Como nota al margen, la complejidad del algoritmo ficticio (1. contar todos 2. ordenar los conteos 3. tomar el mejor) es O (n + m * log (m)), donde m es el número de palabras diferentes en su texto. log (m) es mucho más pequeño que (n / m), por lo que sigue siendo O (n).

Prácticamente, el paso largo está contando.

1. Utilice una estructura de datos eficiente en la memoria para almacenar las palabras
2. Utilice MaxHeap para encontrar las K palabras más frecuentes.

Aqui esta el codigo

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;

import com.nadeem.app.dsa.adt.Trie;
import com.nadeem.app.dsa.adt.Trie.TrieEntry;
import com.nadeem.app.dsa.adt.impl.TrieImpl;

public class TopKFrequentItems {

private int maxSize;

private Trie trie = new TrieImpl();
private PriorityQueue<TrieEntry> maxHeap;

public TopKFrequentItems(int k) {
    this.maxSize = k;
    this.maxHeap = new PriorityQueue<TrieEntry>(k, maxHeapComparator());
}

private Comparator<TrieEntry> maxHeapComparator() {
    return new Comparator<TrieEntry>() {
        @Override
        public int compare(TrieEntry o1, TrieEntry o2) {
            return o1.frequency - o2.frequency;
        }           
    };
}

public void add(String word) {
    this.trie.insert(word);
}

public List<TopK> getItems() {

    for (TrieEntry trieEntry : this.trie.getAll()) {
        if (this.maxHeap.size() < this.maxSize) {
            this.maxHeap.add(trieEntry);
        } else if (this.maxHeap.peek().frequency < trieEntry.frequency) {
            this.maxHeap.remove();
            this.maxHeap.add(trieEntry);
        }
    }
    List<TopK> result = new ArrayList<TopK>();
    for (TrieEntry entry : this.maxHeap) {
        result.add(new TopK(entry));
    }       
    return result;
}

public static class TopK {
    public String item;
    public int frequency;

    public TopK(String item, int frequency) {
        this.item = item;
        this.frequency = frequency;
    }
    public TopK(TrieEntry entry) {
        this(entry.word, entry.frequency);
    }
    @Override
    public String toString() {
        return String.format("TopK [item=%s, frequency=%s]", item, frequency);
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + frequency;
        result = prime * result + ((item == null) ? 0 : item.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        TopK other = (TopK) obj;
        if (frequency != other.frequency)
            return false;
        if (item == null) {
            if (other.item != null)
                return false;
        } else if (!item.equals(other.item))
            return false;
        return true;
    }

}   

}

Aquí están las pruebas unitarias

@Test
public void test() {
    TopKFrequentItems stream = new TopKFrequentItems(2);

    stream.add("hell");
    stream.add("hello");
    stream.add("hello");
    stream.add("hello");
    stream.add("hello");
    stream.add("hello");
    stream.add("hero");
    stream.add("hero");
    stream.add("hero");
    stream.add("hello");
    stream.add("hello");
    stream.add("hello");
    stream.add("home");
    stream.add("go");
    stream.add("go");
    assertThat(stream.getItems()).hasSize(2).contains(new TopK("hero", 3), new TopK("hello", 8));
}

Para obtener más detalles, consulte este caso de prueba

1. use una tabla hash para registrar la frecuencia de todas las palabras mientras recorre toda la secuencia de palabras. En esta fase, la clave es "palabra" y el valor es "frecuencia de palabra". Esto lleva O (n) tiempo. Esto es lo mismo que todos los explicados anteriormente.

2. Mientras se inserta en hashmap, mantenga el Treeset (específico de Java, hay implementaciones en todos los idiomas) de tamaño 10 (k = 10) para mantener las 10 palabras más frecuentes. Hasta que el tamaño sea inferior a 10, sigue agregándolo. Si el tamaño es igual a 10, si el elemento insertado es mayor que el elemento mínimo, es decir, el primer elemento. Si es así, elimínelo e inserte un nuevo elemento

Para restringir el tamaño del conjunto de árboles, consulte este enlace.

Supongamos que tenemos una secuencia de palabras "ad" "ad" "chico" "grande" "malo" "com" "ven" "frío". Y K = 2. como mencionaste "particionar usando la primera letra de las palabras", obtuvimos ("ad", "ad") ("boy", "big", "bad") ("com" "come" "cold") "luego particionando el conjunto de varias palabras más grande usando el siguiente carácter hasta que tenga k conjuntos de una sola palabra ". particionará ("chico", "grande", "malo") ("com" "ven" "frío"), la primera partición ("anuncio", "anuncio") se pierde, mientras que "anuncio" es en realidad el palabra más frecuente.

Quizás entiendo mal tu punto. ¿Puede detallar su proceso sobre la partición?

Creo que este problema se puede resolver con un algoritmo O (n). Podríamos hacer la clasificación sobre la marcha. En otras palabras, la clasificación en ese caso es un subproblema del problema de clasificación tradicional, ya que solo un contador se incrementa en uno cada vez que accedemos a la tabla hash. Inicialmente, la lista está ordenada ya que todos los contadores son cero. A medida que seguimos incrementando los contadores en la tabla hash, mantenemos otra matriz de valores hash ordenados por frecuencia de la siguiente manera. Cada vez que incrementamos un contador, verificamos su índice en la matriz clasificada y verificamos si su recuento excede a su predecesor en la lista. Si es así, intercambiamos estos dos elementos. Como tal, obtenemos una solución que es como máximo O (n) donde n es el número de palabras en el texto original.

Yo también estaba luchando con esto y me inspiré en @aly. En lugar de ordenar después, podemos simplemente mantener una lista de palabras clasificadas previamente ( List<Set<String>>) y la palabra estará en el conjunto en la posición X donde X es el recuento actual de la palabra. En general, así es como funciona:

1. para cada palabra, almacenarla como parte del mapa de ocurrencia de que: Map<String, Integer>.
2. luego, según el recuento, elimínelo del conjunto de recuento anterior y agréguelo al nuevo conjunto de recuento.

El inconveniente de esto es que la lista puede ser grande, se puede optimizar usando a TreeMap<Integer, Set<String>>, pero esto agregará algo de sobrecarga. En última instancia, podemos utilizar una combinación de HashMap o nuestra propia estructura de datos.

El código

public class WordFrequencyCounter {
    private static final int WORD_SEPARATOR_MAX = 32; // UNICODE 0000-001F: control chars
    Map<String, MutableCounter> counters = new HashMap<String, MutableCounter>();
    List<Set<String>> reverseCounters = new ArrayList<Set<String>>();

    private static class MutableCounter {
        int i = 1;
    }

    public List<String> countMostFrequentWords(String text, int max) {
        int lastPosition = 0;
        int length = text.length();
        for (int i = 0; i < length; i++) {
            char c = text.charAt(i);
            if (c <= WORD_SEPARATOR_MAX) {
                if (i != lastPosition) {
                    String word = text.substring(lastPosition, i);
                    MutableCounter counter = counters.get(word);
                    if (counter == null) {
                        counter = new MutableCounter();
                        counters.put(word, counter);
                    } else {
                        Set<String> strings = reverseCounters.get(counter.i);
                        strings.remove(word);
                        counter.i ++;
                    }
                    addToReverseLookup(counter.i, word);
                }
                lastPosition = i + 1;
            }
        }

        List<String> ret = new ArrayList<String>();
        int count = 0;
        for (int i = reverseCounters.size() - 1; i >= 0; i--) {
            Set<String> strings = reverseCounters.get(i);
            for (String s : strings) {
                ret.add(s);
                System.out.print(s + ":" + i);
                count++;
                if (count == max) break;
            }
            if (count == max) break;
        }
        return ret;
    }

    private void addToReverseLookup(int count, String word) {
        while (count >= reverseCounters.size()) {
            reverseCounters.add(new HashSet<String>());
        }
        Set<String> strings = reverseCounters.get(count);
        strings.add(word);
    }

}

Acabo de descubrir la otra solución para este problema. Pero no estoy seguro de que sea correcto. Solución:

1. Use una tabla hash para registrar la frecuencia de todas las palabras T (n) = O (n)
2. Elija los primeros k elementos de la tabla hash y restáurelos en un búfer (cuyo espacio = k). T (n) = O (k)
3. Cada vez, primero necesitamos encontrar el elemento mínimo actual del búfer, y simplemente comparar el elemento mínimo del búfer con los (n - k) elementos de la tabla hash uno por uno. Si el elemento de la tabla hash es mayor que este elemento mínimo del búfer, elimine el mínimo del búfer actual y agregue el elemento de la tabla hash. Entonces, cada vez que encontramos el mínimo en el búfer necesitamos T (n) = O (k), y recorremos toda la tabla hash necesitamos T (n) = O (n - k). Entonces, la complejidad de tiempo total para este proceso es T (n) = O ((nk) * k).
4. Después de recorrer toda la tabla hash, el resultado está en este búfer.
5. Toda la complejidad del tiempo: T (n) = O (n) + O (k) + O (kn - k ^ 2) = O (kn + n - k ^ 2 + k). Dado que, k es realmente menor que n en general. Entonces, para esta solución, la complejidad del tiempo es T (n) = O (kn) . Ese es el tiempo lineal, cuando k es realmente pequeño. ¿Es correcto? Realmente no estoy seguro.

Intente pensar en una estructura de datos especial para abordar este tipo de problemas. En este caso un tipo especial de árbol como el intento de almacenar cadenas de forma específica, muy eficiente. O una segunda forma de construir su propia solución como contar palabras. Supongo que este TB de datos estaría en inglés, entonces tenemos alrededor de 600,000 palabras en general, por lo que será posible almacenar solo esas palabras y contar qué cadenas se repetirían + esta solución necesitará expresiones regulares para eliminar algunos caracteres especiales. La primera solución será más rápida, estoy bastante seguro.

http://en.wikipedia.org/wiki/Trie

Esta es una idea interesante para buscar y pude encontrar este documento relacionado con Top-K https://icmi.cs.ucsb.edu/research/tech_reports/reports/2005-23.pd f

También hay una implementación aquí .

El código más simple para obtener la aparición de la palabra más utilizada.

 function strOccurence(str){
    var arr = str.split(" ");
    var length = arr.length,temp = {},max; 
    while(length--){
    if(temp[arr[length]] == undefined && arr[length].trim().length > 0)
    {
        temp[arr[length]] = 1;
    }
    else if(arr[length].trim().length > 0)
    {
        temp[arr[length]] = temp[arr[length]] + 1;

    }
}
    console.log(temp);
    var max = [];
    for(i in temp)
    {
        max[temp[i]] = i;
    }
    console.log(max[max.length])
   //if you want second highest
   console.log(max[max.length - 2])
}

En estas situaciones, recomiendo utilizar las funciones integradas de Java. Dado que, ya están bien probados y son estables. En este problema, encuentro las repeticiones de las palabras usando la estructura de datos HashMap. Luego, envío los resultados a una serie de objetos. Ordeno el objeto por Arrays.sort () e imprimo las primeras k palabras y sus repeticiones.

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

public class TopKWordsTextFile {

    static class SortObject implements Comparable<SortObject>{

        private String key;
        private int value;

        public SortObject(String key, int value) {
            super();
            this.key = key;
            this.value = value;
        }

        @Override
        public int compareTo(SortObject o) {
            //descending order
            return o.value - this.value;
        }
    }


    public static void main(String[] args) {
        HashMap<String,Integer> hm = new HashMap<>();
        int k = 1;
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("words.in")));

            String line;
            while ((line = br.readLine()) != null) {
                // process the line.
                //System.out.println(line);
                String[] tokens = line.split(" ");
                for(int i=0; i<tokens.length; i++){
                    if(hm.containsKey(tokens[i])){
                        //If the key already exists
                        Integer prev = hm.get(tokens[i]);
                        hm.put(tokens[i],prev+1);
                    }else{
                        //If the key doesn't exist
                        hm.put(tokens[i],1);
                    }
                }
            }
            //Close the input
            br.close();
            //Print all words with their repetitions. You can use 3 for printing top 3 words.
            k = hm.size();
            // Get a set of the entries
            Set set = hm.entrySet();
            // Get an iterator
            Iterator i = set.iterator();
            int index = 0;
            // Display elements
            SortObject[] objects = new SortObject[hm.size()];
            while(i.hasNext()) {
                Map.Entry e = (Map.Entry)i.next();
                //System.out.print("Key: "+e.getKey() + ": ");
                //System.out.println(" Value: "+e.getValue());
                String tempS = (String) e.getKey();
                int tempI = (int) e.getValue();
                objects[index] = new SortObject(tempS,tempI);
                index++;
            }
            System.out.println();
            //Sort the array
            Arrays.sort(objects);
            //Print top k
            for(int j=0; j<k; j++){
                System.out.println(objects[j].key+":"+objects[j].value);
            }


        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

Para obtener más información, visite https://github.com/m-vahidalizadeh/foundations/blob/master/src/algorithms/TopKWordsTextFile.java . Espero que ayude.

**

C ++ 11 Implementación del pensamiento anterior

**

class Solution {
public:
vector<int> topKFrequent(vector<int>& nums, int k) {

    unordered_map<int,int> map;
    for(int num : nums){
        map[num]++;
    }

    vector<int> res;
    // we use the priority queue, like the max-heap , we will keep (size-k) smallest elements in the queue
    // pair<first, second>: first is frequency,  second is number 
    priority_queue<pair<int,int>> pq; 
    for(auto it = map.begin(); it != map.end(); it++){
        pq.push(make_pair(it->second, it->first));

        // onece the size bigger than size-k, we will pop the value, which is the top k frequent element value 

        if(pq.size() > (int)map.size() - k){
            res.push_back(pq.top().second);
            pq.pop();
        }
    }
    return res;

}

};