Trova la mediana di un elenco di array ordinati

8

Input: una serie di matrici (di numeri). Gli elementi all'interno di ciascun array sono ordinati, ma l'insieme di array non è necessariamente ordinato. Le matrici non hanno necessariamente le stesse dimensioni. Il numero totale di elementi è . $\ell$ $A_i$
$n$

Output: il esimo elemento più piccolo tra tutti gli elementi nell'input. $k$

Qual è l'algoritmo più efficiente per questo problema?

È possibile, ad esempio, ottenere un tempo di esecuzione di ? $O(\ell + \log n)$

algorithms algorithm-analysis

— Joe
fonte

C'è una domanda strettamente correlata su SO , con risposte insoddisfacenti.

— Joe,

Tutti gli array sono della stessa lunghezza?

— vonbrand,

Le matrici non hanno necessariamente le stesse dimensioni. Tuttavia, sono anche interessato a un caso speciale in cui le dimensioni sono geometriche, ovvero array

A_{i}

$A_i$ ha dimensioni

n / 2^{i}

$n / 2^i$ , ma dubito che aiuterà nel tempo di esecuzione.

— Joe,

4

Come si ottiene

O (ℓ \log n)

$O(\ell\log n)$ ? Puoi prendere

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

$O(\ell(\log n)^2)$ emulando l'algoritmo "quickselect". In ogni fase, scegli un perno e calcola quanti elementi ci sono sotto, in

O (ℓ \log n)

$O(\ell\log n)$ . Quindi rimuovi gli elementi dalla parte sbagliata e ripeti. Il processo termina dopo

\log n

$\log n$ iterazioni (nell'aspettativa, o nel peggiore dei casi se si sceglie il perno in modo intelligente).

— Yuval Filmus,

2

@Joe Penso che dovresti descrivere anche il tuo algoritmo. Sarebbe molto interessante e potrebbe fornire un punto di partenza per algoritmi migliori se corretti. Se errato, le persone potrebbero essere in grado di trovare eventuali errori.

— Paresh,

5

Puoi farlo dentro $O(l + k \text{ log } l)$ tempo e $O(l)$ spazio extra come segue:

Costruisci un heap binario con una voce per ciascuno degli array. La chiave per l'ingresso $i$ è l'elemento più piccolo nell'array $A_i$ . Questo richiede $O(l)$ tempo.
Seleziona la voce più piccola dall'heap e rimuovila (prendendo $O(\text{log } l$ ) tempo). Aggiungi quella voce all'heap usando come chiave la chiave successiva più piccola nell'array pertinente $O(\text{log } l)$ tempo).
Fai il passaggio precedente $k$ volte. L'ultimo elemento che rimuovi dall'heap è la tua risposta.

Se sostituisci l'heap binario con un heap di Fibonacci, penso che questo ti riduca all'ammortamento $O(l + k)$ tempo, ma in pratica sarà più lento dell'heap binario a meno che $l$ è enorme.

Ho il sospetto che il limite di heap di Fibonacci sia ottimale, perché intuitivamente dovrai ispezionare almeno $k$ elementi per trovare il file $k$ il più piccolo, e dovrai ispezionare almeno un elemento da ciascuno dei $l$ array poiché non sai come sono ordinati, il che dà immediatamente un limite inferiore di $\Omega(\text{max}(k, l)) = \Omega(k + l)$ .

— Matt Lewis
fonte

3

Non devi ispezionare almeno

k

$k$ elementi poiché le matrici sono ordinate. Vedi la soluzione nel mio commento, che dà

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

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

— Yuval Filmus,

1

È possibile migliorare il tempo di esecuzione del caso peggiore nel modello RAM, poiché è possibile implementare la coda di priorità per

n

$n$ elementi in

o (\log n)

$o(\log n)$ . In questo modello, è possibile ottenere entrambe le operazioni di inserimento ed eliminazione

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

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

O (1)

$\mathcal{O}(1)$ tempo per l'operazione findMin.

— Massimo Cafaro,

1

Sei sicuro che l'heap di Fibonnaci supporti l'operazione corretta? Penso che stai pensando di diminuire la chiave in un min-heap.

— Joe,

Questo è fondamentalmente lo stesso della risposta di vonbrand, con l'aggiunta dell'osservazione che non devi unire alcun elemento dopo il kth.

— Joe

Credo che l'heap di Fibonacci ti permetta di diminuire o aumentare una chiave

O (1)

$O(1)$ tempo. Sì, questa è sostanzialmente la stessa risposta, ma osservando che devi solo unire

k

$k$ elements riduce il tempo di esecuzione in modo corretto.

— Matt Lewis,

5

Ecco un randomizzato $O(\ell\log^2 n)$ algoritmo. Probabilmente può essere derandomizzato usando lo stesso trucco usato per derandomizzare la solita selezione rapida.

Emuliamo il classico algoritmo di selezione rapida. In ogni fase, scegli un perno e calcola quanti elementi ci sono sotto, in $O(\ell\log n)$ , utilizzando la ricerca binaria in ciascun elenco. Quindi rimuovi gli elementi dalla parte sbagliata e ripeti. Il processo termina dopo $\log n$ iterazioni in attesa.

— Yuval Filmus
fonte

1

Ciò sembra essere risolto dal documento Selezione e classificazione generalizzate (versione preliminare) di Frederickson e Johnson in STOC '80.

Danno limiti superiori e inferiori di: $\Theta(\ell + \sum_{i=1}^\ell \log|A_i|)$ che risulta essere $\ell \log n$ per la maggior parte delle distribuzioni di dimensioni di array.

L'attuale algoritmo per raggiungere il limite superiore è apparentemente riportato in un precedente documento: Algoritmi ottimali per la generazione di informazioni quantili in X + Y e matrici con colonne ordinate , Proc. 13ª Conferenza annuale su Scienza e sistemi dell'informazione, The Johns Hopkins University (1979) 47-52.

— Joe
fonte

0

Un $\ell$ -way merge richiede tempo $\Theta(n \log \ell)$ (utilizzare un modo efficiente per rappresentare una coda prioritaria degli elementi head in ciascun elenco), quindi selezionare $k$ -th elemento in tempo costante. Penso che questo sia discusso in "Ordinamento e ricerca" di Knuth per l'ordinamento. Ottenere il più piccolo (o il più grande) richiede chiaramente $\Theta(\ell)$ , per un array non ordinato lo è $O(n)$ IIRC.

Descrivi il tuo algoritmo.

— vonbrand
fonte

1

Questo è molto più lento di quello che mi interessa. Puoi trovare la mediana

O (n)

$O(n)$ tempo semplicemente concatenando le liste e usando l'algoritmo di selezione temporale lineare.

— Joe,