¿Cómo contar en tiempo lineal el peor de los casos?

Esta pregunta y esta pregunta me hicieron pensar un poco. Para ordenar una matriz de longitud con elementos únicos en , necesitamos poder almacenar conteos de valores en la matriz. Hay algunas sugerencias, pero estoy buscando una manera de hacerlo en el peor de los casos, el tiempo lineal. Más específicamente:$n$$k$$O(n + k \log k)$

Dada una lista $A$ de $n$ elementos con $k$ elementos distintos, determinar una lista de tuplas $U = \{(x_i, c_i)\}^k$ de todos los elementos únicos $x_i \in A$ tal que $c_i$ es el recuento de elemento $x_i$ en $A$ .

Aquí hay algunas ideas (fallidas) que he tenido y que me han sugerido:

1. Árbol de búsqueda binaria equilibrado : con esto se necesitará $O(\log k)$ para insertar en el árbol y aumentar los valores. Después de las inserciones podríamos hacer un recorrido del árbol en $O(k)$ . Por lo tanto, el tiempo total sale a $O(n \log k)$ que es demasiado lento.
2. Hash Map : con esto podemos obtener $O(1)$ inserciones esperadas y, por lo tanto, $O(n)$ tiempo esperado . Sin embargo, esto todavía no es $O(n)$ peor de los casos.
3. Vaciar el mapeo espacial - Encontrar el mínimo y el máximo elemento en $A$ . Asigne (pero no inicialice) suficiente memoria para cubrir este rango. Utilice esta memoria básicamente como un mapa hash e incluya un hash aleatorio para que no intentemos acceder a la memoria corrupta. Esta estrategia presenta problemas. (1) Es probabilístico con muy, muy baja probabilidad de falla, pero aún no está garantizado. Usar memoria como esta nos limita a las restricciones de punto flotante o entero.
4. Matrices asociativas : hay muchas otras matrices asociativas que se pueden utilizar, de forma similar a los mapas hash y BST, pero no encuentro ninguna que coincida con estas restricciones.

Tal vez hay un método obvio que me falta, pero también creo que podría no ser posible. ¿Cuáles son tus pensamientos?

Esta es una buena pregunta.

En el modelo de comparación o, lo que es más general, el modelo de árbol de decisión algebraico, el problema de la distinción de elementos tiene un límite inferior de complejidad de tiempo en el peor de los casos, como se dice en este artículo de Wikipedia . Por lo tanto, no existe un algoritmo para contar elementos distintos en tiempo lineal en el peor de los casos, incluso sin contar las duplicidades.$\Theta(n\log n)$

Sin embargo, no está claro si se puede hacer en otro modelo computacional. Parece poco probable en cualquier modelo computacional determinista razonable.

Existen algoritmos aleatorios cuyo tiempo de ejecución esperado es ; o donde la probabilidad de que el tiempo de ejecución tarde más que es exponencialmente pequeña en .$O(n)$$cn$$c$

En particular, elija aleatoriamente una función hash universal 2, luego úsela para hash todos los elementos de la matriz. Esto logra los tiempos de ejecución establecidos, si elige la longitud de la salida del hash 2-universal adecuadamente.

Como otro ejemplo, puede construir un algoritmo aleatorio cuyo peor tiempo de ejecución es (siempre se ejecuta en tiempo lineal, sin importar qué) y tiene una probabilidad de error de como máximo . (¿Cómo? Ejecute el algoritmo anterior y termínelo si se ejecuta más de pasos para algunos elegidos apropiadamente .) En la práctica, eso es lo suficientemente bueno, ya que la probabilidad de que su computadora muestre la respuesta incorrecta debido a un rayo cósmico ya es mucho mayor que .$O(n)$$1/2^{100}$$cn$$c$$1/2^{100}$

Su enfoque 3 puede ser seguro utilizando una solución para el ejercicio 2.12 de Aho, Hopcroft y Ullman (1974) El diseño y análisis de algoritmos informáticos como se describe, por ejemplo, en Uso de memoria no inicializada para diversión y beneficio .

Básicamente, además de su conjunto de N elementos con los recuentos, tiene dos conjuntos de N elementos y un recuento auxiliar para crear un conjunto disperso que indica cuáles de los recuentos son válidos.

En pseudocódigo tipo C:

uint* a = malloc(n);
uint* b = malloc(n);
uint* c = malloc(n);
uint len = 0;

get_count(uint x) {
    uint idx = a[x];
    return idx >= 0 && idx < len && b[idx] == x ? c[idx] : 0;
}

increment_count(uint x) {
    uint idx = a[x];
    if (idx < 0 || idx >= len || b[idx] != x) {
        idx = len;
        len++;
        a[x] = idx;
        b[idx] = x;
        c[idx] = 0;
    }
    c[idx]++;
}

La implementación práctica del conjunto disperso se analiza en esta respuesta de StackOverflow .