Encuentre la mediana de una lista de matrices ordenadas

8

Entrada: Un conjunto de arrays (de números). Los elementos dentro de cada matriz están ordenados, pero el conjunto de matrices no está necesariamente ordenado. Las matrices no son necesariamente del mismo tamaño. El número total de elementos es . $\ell$ $A_i$
$n$

Salida: El ésimo más pequeño elemento de todos los elementos en la entrada. $k$

¿Cuál es el algoritmo más eficiente para este problema?

¿Es posible, por ejemplo, lograr un tiempo de ejecución de ? $O(\ell + \log n)$

algorithms algorithm-analysis

— Joe
fuente

Hay una pregunta muy relacionada con SO , con respuestas insatisfactorias.

— Joe

¿Todas las matrices tienen la misma longitud?

— vonbrand

Las matrices no son necesariamente del mismo tamaño. Sin embargo, también estoy interesado en un caso especial donde los tamaños son geométricos, es decir, la matriz tiene un tamaño , pero dudo que ayude en el tiempo de ejecución.

A_{i}

$A_i$

n / 2^{i}

$n / 2^i$

— Joe

44

¿Cómo se obtiene ? Puede obtener emulando el algoritmo de "selección rápida". En cada fase, elige un pivote y calcula cuántos elementos hay debajo de él, en . Luego, elimina elementos del lado equivocado y repite. El proceso finaliza después de iteraciones (en expectativa, o en el peor de los casos si elige el pivote de forma inteligente).

O (ℓ \log n)

$O(\ell\log n)$

O (ℓ (\log n)^{2})

$O(\ell(\log n)^2)$

O (ℓ \log n)

$O(\ell\log n)$

\log n

$\log n$

— Yuval Filmus

2

@ Joe Creo que también deberías describir tu algoritmo. Sería muy interesante y puede proporcionar un punto de partida para mejores algoritmos si es correcto. Si es incorrecto, las personas pueden encontrar cualquier error.

— Paresh

5

Puedes hacerlo en $O(l + k \text{ log } l)$ tiempo y $O(l)$ espacio extra de la siguiente manera:

Cree un montón binario con una entrada para cada una de las matrices. La llave de entrada $i$ es el elemento más pequeño de la matriz $A_i$ . Esto toma $O(l)$ hora.
Seleccione la entrada más pequeña del montón y elimínela (tomando $O(\text{log } l$ ) hora). Agregue esa entrada al montón utilizando la siguiente entrada más pequeña en la matriz relevante como clave (nuevamente $O(\text{log } l)$ hora).
Haz el paso anterior $k$ veces. El último elemento que eliminas del montón es tu respuesta.

Si reemplaza el montón binario con un montón de Fibonacci, creo que esto lo lleva a amortizar $O(l + k)$ tiempo, pero en la práctica será más lento que el montón binario a menos que $l$ es enorme.

Sospecho que el límite del montón de Fibonacci es óptimo, porque intuitivamente tendrá que inspeccionar al menos $k$ elementos para encontrar el $k$ el más pequeño, y tendrá que inspeccionar al menos un elemento de cada $l$ matrices ya que no sabes cómo están ordenadas, lo que inmediatamente da un límite inferior de $\Omega(\text{max}(k, l)) = \Omega(k + l)$ .

— Matt Lewis
fuente

3

No tienes que inspeccionar al menos

k

$k$ elementos ya que las matrices están ordenadas. Vea la solución en mi comentario, que da

O (ℓ (\log n)^{2})

$O(\ell (\log n)^2)$ .

— Yuval Filmus

1

Puede mejorar el peor tiempo de ejecución en el modelo RAM, ya que puede implementar su cola prioritaria para

n

$n$ elementos en

o (\log n)

$o(\log n)$ . En este modelo, puede lograr operaciones de inserción y eliminación

O (\sqrt{\log \log n})

$\mathcal{O}(\sqrt{\log \log n})$ y

O (1)

$\mathcal{O}(1)$ tiempo para la operación findMin.

— Massimo Cafaro

1

¿Estás seguro de que el montón de Fibonnaci admite la operación correcta? Creo que estás pensando en disminuir- clave en un montón mínimo.

— Joe

Esto es básicamente lo mismo que la respuesta de vonbrand, con la observación adicional de que no tiene que fusionar ningún elemento después del k.

— Joe

Creo que el montón de Fibonacci le permite disminuir o aumentar una clave en

O (1)

$O(1)$ hora. Sí, esta es básicamente la misma respuesta, pero observando que solo necesitas fusionar

k

$k$ Elements reduce su tiempo de ejecución de una manera justa.

— Matt Lewis

5

Aquí hay un aleatorizado $O(\ell\log^2 n)$ algoritmo. Probablemente se puede desrandomizar usando el mismo truco usado para desrandomizar la selección rápida habitual.

Emulamos el algoritmo clásico de selección rápida. En cada fase, elige un pivote y calcula cuántos elementos hay debajo de él, en $O(\ell\log n)$ , utilizando la búsqueda binaria en cada lista. Luego elimina elementos del lado equivocado y repite. El proceso termina después de $\log n$ iteraciones en expectativa.

— Yuval Filmus
fuente

1

Esto parece ser resuelto por el documento Selección y clasificación generalizadas (versión preliminar) de Frederickson y Johnson en STOC '80.

Dan límites superiores e inferiores de: $\Theta(\ell + \sum_{i=1}^\ell \log|A_i|)$ que resulta ser $\ell \log n$ para la mayoría de las distribuciones de tamaño de matriz.

El algoritmo real para lograr el límite superior aparentemente se da en un artículo anterior: Algoritmos óptimos para generar información cuantil en X + Y y matrices con columnas ordenadas , Proc. Decimotercera Conferencia Anual sobre Ciencias de la Información y Sistemas, Universidad Johns Hopkins (1979) 47-52.

— Joe
fuente

0

Un $\ell$ la fusión de vías lleva tiempo $\Theta(n \log \ell)$ (use una forma eficiente de representar una cola prioritaria de los elementos principales en cada lista), luego elija el $k$ -th elemento en tiempo constante. Creo que esto se discute en "Ordenar y buscar" de Knuth para ordenar. Obtener el más pequeño (o el más grande) claramente toma $\Theta(\ell)$ , para una matriz sin clasificar es $O(n)$ IIRC.

Por favor describa su algoritmo.

— vonbrand
fuente

1

Esto es mucho más lento de lo que me interesa. Puedes encontrar la mediana en

O (n)

$O(n)$ tiempo simplemente concatenando las listas y usando el algoritmo de selección de tiempo lineal.

— Joe