Trovare k'th elemento più piccolo da una determinata sequenza solo con O (k) memoria O (n) tempo

Supponiamo di leggere una sequenza di numeri, uno per uno. Come trovare 'il più piccolo elemento solo usando la memoria della cella e in tempo lineare ( $n$ $k$ $O(k)$ $O(n)$ ). Penso che dovremmo salvare i primi $k$ termini della sequenza e quando ottieni il termine $k+1$ , elimina un termine che siamo sicuri che non possa essere l' elemento $k$ più piccolo e quindi salva il termine $k+1$ . Quindi dovremmo avere un indicatore che mostri questo termine inutilizzabile in ogni passaggio e questo indicatore dovrebbe essere aggiornato rapidamente in ogni passaggio. Ho iniziato con "max" ; ma non può aggiornarsi rapidamente; Significa che se consideriamo maxquindi nella prima cancellazione ci manca il massimo e dovremmo cercare il massimo in $O(k)$ e la sua causa $(n-k)\times O(k)$ che non è lineare. Forse dovremmo salvare i primi $k$ termini della sequenza in modo più intelligente.

Come posso risolvere questo problema?

data-structures search-algorithms quicksort

— Shahab_HK
fonte

Sei interessato a un algoritmo online o farebbe qualche algoritmo?

— Yuval Filmus

k = θ (n)

$k = \theta(n)$ , puoi farlo utilizzando l'algoritmo delle statistiche degli ordini. Se

k = o (n)

$k = o(n)$ allora puoi farlo

O (k)

$O(k)$ memoria e

O (n \log k)

$O(n\log k)$ tempo usando qualsiasi albero bilanciato in altezza.

— Shreesh,

Si chiama problema di selezione en.wikipedia.org/wiki/Selection_algorithm

— xavierm02

Esistono algoritmi lineari sul posto sul tempo, che puoi cercare su Google, ma sono piuttosto complicati.

— Yuval Filmus

@ xavierm02 non è identico al problema di selezione. Perché esiste un limite di memoria.

— Shahab_HK

Risposte:

Crea un buffer di dimensioni . Leggi in elementi dall'array. Utilizzare un algoritmo di selezione a tempo lineare per partizionare il buffer in modo che i elementi più piccoli siano i primi; questo richiede tempo . Ora leggi in un altro elementi dal tuo array nel buffer, sostituendo i elementi più grandi nel buffer, partiziona il buffer come prima e ripeti. $2k$ $2k$ $k$ $O(k)$ $k$ $k$

Questo richiede tempo e spazio. $O(k * n/k) = O(n)$ $O(k)$

— jbapple
fonte

+1, questo si adatta agli asintotici richiesti. Detto questo, non credo che questo sia più veloce di un singolo algoritmo di selezione a tempo lineare ... tranne quando

è una piccola costante, quindi fornisce una prospettiva interessante. Ad esempio per

questo algoritmo produce la funzione.

k

$k$

k = 1

$k = 1$ min

— orlp,

A volte, l'algoritmo di selezione del tempo lineare utilizza troppo spazio. Ad esempio, non è adatto per l'uso in un contesto di streaming o quando l'array di input è immutabile.

— jbapple

Questi sono punti validi.

— orlp

È possibile farlo in della memoria e tempo formando una dimensione fissa max-heap dai primi elementi a tempo, poi iterando sul resto della matrice e spingendo una nuova elemento e quindi saltando fuori per per ogni elemento che dà il tempo totale = . $O(k)$ $O(n \log k)$ $k$ $O(k)$ $O(\log k)$ $O(k + n\log k)$ $O(n \log k)$

Puoi farlo nella memoria ausiliaria e nel tempo usando l'algoritmo di selezione mediana delle mediane, selezionando in e restituendo i primi elementi. Senza alcuna modifica agli asintotici, è possibile utilizzare l'introselect per accelerare il caso medio. Questo è il modo canonico per risolvere il tuo problema. $O(\log n)$ $O(n)$ $k$ $k$

Ora tecnicamente e sono incomparabili. Tuttavia, sostengo che è meglio in pratica, poiché è effettivamente costante considerando che nessun sistema di computer ha più di byte di memoria, . Nel frattempo può crescere per essere grande quanto . $O(\log n)$ $O(k)$ $O(\log n)$ $2^{64}$ $\log 2^{64}= 64$ $k$ $n$

— orlp
fonte

Si noti che è possibile migliorare la complessità dell'algoritmo basato su heap su

invertendo l'ordine utilizzato dall'heap quando è interessante.

O (n \times \log min (k, n - k))

$O(n \times \log\min (k, n - k))$

— xavierm02

@ xavierm02

. Prova: il caso peggiore per

. Il caso peggiore per

O (m i n (k, n - k))

$O(min(k, n-k))$

O (k)

$O(k)$

k

$k$

n

$n$

m i n (k, n - k)

$min(k, n-k)$

. Sono gli stessi all'interno di un fattore costante, quindi

\frac{n}{2}

$n \over 2$

O (m i n (k, n - k))

$O(min(k, n-k))$

O (k)

$O(k)$

— orlp

@ xavierm02 Detto questo, è ancora un bel speedup :)

— orlp

ma non è

. Supponiamo che lo sia. Poi ci sono alcuni

e alcuni

modo che per ogni

, abbiamo

, che è chiaramente falso (perché possiamo prendere

u_{n, k} = k

$u_{n,k}=k$

O (k)

$O(k)$

O (min (k, n - k))

$O(\min (k, n-k))$

C

$C$

M

$M$

M \leq k \leq n

$M\le k\le n$

k \leq C (n - k)

$k\le C (n-k)$

n = k \to + \infty) .

$n=k \to +\infty).$ Quindi

O (min (k, n - k)) ⊊ O (k)

$O(\min(k, n-k))\subsetneq O(k)$

— xavierm02

@ xavierm02 Sono familiarità con il vostro

notazione. Ad essere sinceri, in generale non ho familiarità con la notazione big-

multidimensionale , specialmente considerando che le dimensioni

non sono indipendenti.

u_{n, k}

$u_{n, k}$

O

$O$

n, k

$n, k$

— orlp,