Algoritmo non banale per il calcolo di una mediana a finestra scorrevole

Devo calcolare la mediana corrente:

Input: $n$ , , vettore . $k$ $(x_1, x_2, \dotsc, x_n)$
Output: vettore , dove è la mediana di . $(y_1, y_2, \dotsc, y_{n-k+1})$ $y_i$ $(x_i, x_{i+1}, \dotsc, x_{i+k-1})$

(Nessun imbroglio con approssimazioni; vorrei avere soluzioni esatte. Gli elementi sono numeri interi grandi). $x_i$

Esiste un banale algoritmo che mantiene un albero di ricerca di dimensioni ; il tempo di esecuzione totale è . (Qui un "albero di ricerca" si riferisce ad una struttura dati efficiente che supporta inserimenti, eliminazioni e query mediane nel tempo logaritmico.) $k$ $O(n \log k)$

Tuttavia, questo mi sembra un po 'stupido. Impareremo efficacemente tutte le statistiche degli ordini in tutte le finestre di dimensione , non solo le mediane. Inoltre, ciò non è troppo attraente in pratica, specialmente se è grande (i grandi alberi di ricerca tendono ad essere lenti, i costi di gestione della memoria non sono banali, l'efficienza della cache è spesso scarsa, ecc.). $k$ $k$

Possiamo fare qualcosa di sostanzialmente migliore?

Esistono limiti inferiori (ad esempio, l'algoritmo banale è asintoticamente ottimale per il modello di confronto)?

Modifica: David Eppstein ha dato un bel limite inferiore per il modello di confronto! Mi chiedo se sia comunque possibile fare qualcosa di leggermente più intelligente dell'algoritmo banale?

Ad esempio, possiamo fare qualcosa in tal senso: dividere il vettore di input in parti di dimensione ; ordina ogni parte (tenendo traccia delle posizioni originali di ciascun elemento); e quindi utilizzare il vettore ordinato a tratti per trovare in modo efficiente le mediane in esecuzione senza alcuna struttura di dati ausiliaria? Ovviamente questo sarebbe ancora , ma in pratica gli array di ordinamento tendono ad essere molto più veloci rispetto al mantenimento degli alberi di ricerca. $k$ $O(n \log k)$

Modifica 2: Saeed voleva vedere alcuni motivi per cui penso che l'ordinamento sia più veloce delle operazioni dell'albero di ricerca. Ecco alcuni benchmark molto rapidi, per , : $k = 10^7$ $n = 10^8$

≈ 8s: ordinamento di vettori con elementi ciascuno $n/k$ $k$
≈ 10s: ordinamento di un vettore con elementi $n$
≈ 80: inserimenti ed eliminazioni in una tabella hash di dimensioni $n$ $k$
≈ 390s: inserimenti ed eliminazioni in un albero di ricerca bilanciato di dimensioni $n$ $k$

La tabella hash è lì solo per il confronto; non ha alcuna utilità diretta in questa applicazione.

In sintesi, abbiamo quasi una differenza di fattore 50 nelle prestazioni dell'ordinamento rispetto alle operazioni dell'albero di ricerca bilanciata. E le cose peggiorano molto se aumentiamo . $k$

(Dettagli tecnici: Dati = numeri interi casuali a 32 bit. Computer = un tipico laptop moderno. Il codice di test è stato scritto in C ++, usando le routine di libreria standard (std :: sort) e le strutture di dati (std :: multiset, std :: unsorted_multiset). Ho usato due diversi compilatori C ++ (GCC e Clang) e due diverse implementazioni della libreria standard (libstdc ++ e libc ++). Tradizionalmente, std :: multiset è stato implementato come un albero rosso-nero altamente ottimizzato.)

ds.algorithms ds.data-structures lower-bounds

— Jukka Suomela
fonte

Non credo che sarete in grado di migliorare la

. La ragione è che, se si guarda a una finestra

, non puoi mai escludere nessuno dei numeri

n l o g k

$nlogk$

x_{t}, . . ., x_{t + k - 1}

$x_t,...,x_{t+k-1}$

dall'essere mediani della finestra futura. Ciò significa che in qualsiasi momento devi mantenere almeno

x_{t + \frac{k}{2}}, . . ., x_{t + k - 1}

$x_{t+\frac{k}{2}},...,x_{t+k-1}$

numeri interi in una struttura di dati e non sembra aggiornarsi in meno del tempo di log.

\frac{k}{2}

$\frac{k}{2}$

— RB

Il tuo banale algoritmo per me sembra essere

non

, ho capito male qualcosa? E penso per questo che tu abbia problemi con big

, altrimenti il fattore logaritmico non è nulla nelle applicazioni pratiche, inoltre non c'è una grande costante nascosta in questo algoritmo.

O ((n - k) \cdot k \cdot \log k)

$O((n-k)\cdot k \cdot \log k)$

O (n \log k)

$O(n \log k)$

k

$k$

— Saeed,

@Saeed: Nell'algoritmo banale, elabori gli elementi uno per uno; nel passaggio

aggiungi

all'albero di ricerca e (se

) rimuovi anche

dall'albero di ricerca. Si tratta di

passaggi, ognuno dei quali richiede tempo

i

$i$

x_{i}

$x_i$

i > k

$i > k$

x_{i - k}

$x_{i-k}$

n

$n$

O (\log k)

$O(\log k)$

— Jukka Suomela,

Quindi vuoi dire che hai un albero di ricerca bilanciato e non un albero di ricerca casuale?

— Saeed,

@Saeed: tieni presente che nei miei benchmark non ho nemmeno provato a trovare le mediane. Ho appena fatto

inserimenti e

eliminazioni in un albero di ricerca di dimensioni

e queste operazioni sono garantite per prendere

. Devi solo accettare che le operazioni dell'albero di ricerca sono molto lente nella pratica, rispetto all'ordinamento. Lo vedrai facilmente se provi a scrivere un algoritmo di ordinamento che funziona aggiungendo elementi a un albero di ricerca bilanciato - sicuramente funzionerà in tempo

, ma sarà ridicolmente lento nella pratica e sprecherà anche molto di memoria.

n

$n$

n

$n$

k

$k$

O (\log k)

$O(\log k)$

O (n \log n)

$O(n \log n)$

— Jukka Suomela,

Risposte:

Ecco un limite inferiore dall'ordinamento. Dato un set di input di lunghezza da ordinare, crea un input per il tuo problema mediano in esecuzione costituito da copie di un numero inferiore al minimo di , quindi stesso, quindi copie di un numero maggiore di il massimo di e impostare . Le mediane esecuzione di questo ingresso sono le stesse della sequenza ordinata di . $S$ $n$ $n-1$ $S$ $S$ $n-1$ $S$ $k=2n-1$ $S$

Quindi in un modello di confronto di calcolo, è richiesto il tempo . Forse se i tuoi input sono numeri interi e usi algoritmi di ordinamento dei numeri interi, puoi fare di meglio. $\Omega(n\log n)$

— David Eppstein
fonte

Questa risposta mi fa davvero domandare se vale anche il contrario: dato un algoritmo di ordinamento efficiente, otteniamo un algoritmo mediano funzionante efficiente? (Ad esempio, su un algoritmo di ordinamento intero efficiente implica un algoritmo mediano funzionante efficiente per numeri interi? O un algoritmo di ordinamento efficiente IO fornisce un algoritmo mediano funzionante IO efficiente?)

— Jukka Suomela

Ancora una volta, molte grazie per la tua risposta, mi ha davvero messo sulla buona strada e ha dato l'ispirazione per l'algoritmo di filtro mediano basato sull'ordinamento! Alla fine sono stato in grado di trovare un documento del 1991 che presentava sostanzialmente lo stesso argomento di quello che dai qui, e Pat Morin ha dato un puntatore a un altro documento pertinente del 2005; vedi rif. [6] e [9] qui .

— Jukka Suomela,

Modifica: questo algoritmo è ora presentato qui: http://arxiv.org/abs/1406.1717

Sì, per risolvere questo problema è sufficiente eseguire le seguenti operazioni:

Ordina i vettori , ciascuno con elementi. $n/k$ $k$
Esegui post-elaborazione lineare.

Molto approssimativamente, l'idea è questa:

Considera due blocchi adiacenti di input, e , entrambi con elementi ; lasciare che gli elementi siano e nell'ordine di apparizione nel vettore di input . $a$ $b$ $k$ $a_1, a_2, ..., a_k$ $b_1, b_2, ..., b_k$ $x$
Ordina questi blocchi e impara il rango di ciascun elemento all'interno del blocco.
Aumentare i vettori e con puntatori predecessore / successore affinché seguendo le catene puntatore poter attraversare gli elementi in ordine crescente. In questo modo abbiamo costruito elenchi doppiamente collegati e . $a$ $b$ $a'$ $b'$
Uno per uno, eliminare tutti gli elementi dalla lista collegata , in ordine inverso di apparizione . Ogni volta che eliminiamo un elemento, ricorda qual era il suo successore e predecessore al momento della cancellazione . $b'$ $b_k, b_{k-1}, ..., b_1$
Ora mantenere "puntatori mediana" e quel punto alle liste e , rispettivamente. Inizializza sul punto medio di e inizializza sulla coda dell'elenco vuoto . $p$ $q$ $a'$ $b'$ $p$ $a'$ $q$ $b'$
Per ogni : $i$
- Elimina dalla lista (questa è volta, basta cancellare dalla lista collegata). Confronta con l'elemento puntato da per vedere se abbiamo eliminato prima o dopo . $a_i$ $a'$ $O(1)$ $a_i$ $p$ $p$
- Riporta alla lista nella sua posizione originale (questa è volta, abbiamo memorizzato il predecessore e successore di ). Confronta con l'elemento puntato da per vedere se abbiamo aggiunto l'elemento prima o dopo . $b_i$ $b'$ $O(1)$ $b_i$ $b_i$ $q$ $q$
- Aggiorna i puntatori e modo che la mediana dell'elenco unito sia a che a . (Questo è il tempo , basta seguire gli elenchi collegati uno o due passaggi per correggere tutto. Terremo traccia di quanti elementi sono presenti prima / dopo e in ciascun elenco e manterremo invariante che entrambi e indicano elementi il più vicino possibile alla mediana.) $p$ $q$ $a' \cup b'$ $p$ $q$ $O(1)$ $p$ $q$ $p$ $q$

Gli elenchi collegati sono solo matrici di indici -element, quindi sono leggere (tranne per il fatto che la località di accesso alla memoria è scarsa). $k$

Ecco un'implementazione di esempio e parametri di riferimento:

https://github.com/suomela/median-filter

$n \approx 2\cdot 10^6$

$O(n \log k)$
$O(n \log k)$
$O(n \log k)$
$O(n k)$
$\approx k/2$
Asse Y = tempo di funzionamento in secondi.
Dati = numeri interi a 32 bit e numeri interi casuali a 64 bit, provenienti da varie distribuzioni.

tempi di esecuzione

— Jukka Suomela
fonte

$m$ $O(n \log m + m \log n)$

$O(\log m)$ $O(\log n)$ $O(\log n)$ la carica si verifica una sola volta per mediana.

$O(n \log m + m \log k)$

— Geoffrey Irving
fonte

Oops, questo non funziona come scritto, poiché se non elimini gli elementi i conteggi non rispecchieranno la nuova finestra. Non sono sicuro che possa essere risolto, ma lascerò la risposta nel caso ci fosse un modo.

— Geoffrey Irving,

O (n \log m)

$O(n \log m)$

nota a margine: la domanda non è chiara, la struttura dei dati alla base non è definita, sappiamo solo qualcosa di molto vago. come vuoi migliorare qualcosa che non sai di cosa si tratta? come vuoi confrontare il tuo approccio?

— Saeed,

Mi scuso per il lavoro incompleto. Ho posto la domanda concreta necessaria per risolvere questa risposta qui: cstheory.stackexchange.com/questions/21778/… . Se ritieni che sia appropriato, posso rimuovere questa risposta fino alla risoluzione della domanda secondaria.

— Geoffrey Irving,