Ogni algoritmo a tempo lineare è un algoritmo di streaming?

14

A questa domanda sul conteggio delle inversioni , ho trovato un documento che dimostra un limite inferiore alla complessità dello spazio per tutti gli algoritmi di streaming (esatti) . Ho affermato che questo limite si estende a tutti gli algoritmi del tempo lineare. Questo è un po 'audace come in generale, un algoritmo di tempo lineare può saltare a piacimento (accesso casuale) che un algoritmo di streaming non può; deve investigare gli elementi in ordine. Posso eseguire più passaggi, ma solo costantemente molti (per runtime lineare).

Pertanto la mia domanda:

Ogni algoritmo a tempo lineare può essere espresso come algoritmo di streaming con costantemente molti passaggi?

L'accesso casuale sembra impedire a una (semplice) costruzione di dare una risposta positiva, ma non sono stato nemmeno in grado di trovare un contro esempio.

A seconda del modello di macchina, l'accesso casuale potrebbe non essere nemmeno un problema, in termini di runtime. Sarei interessato alle risposte per questi modelli:

Macchina di Turing, ingresso piatto
RAM, input come array
RAM, input come elenco collegato

— Raffaello
fonte

come vedete nelle risposte, gli "algoritmi di streaming" spesso implicano piccoli (spazio polifunzionale). ma data la vostra motivazione, la questione penso che dovrebbe essere: può ogni algoritmo di tempo lineare che utilizza

termini di spazio di lavoro essere convertiti in un algoritmo in streaming che utilizza

parole spazio. quindi un controesempio sarebbe un problema che può essere risolto con

spazio con accesso casuale mentre qualsiasi algoritmo di streaming a passaggio costante richiede

spazio. nessuna risposta ha ancora dato un esempio del genere

s

$s$

O (s)

$O(s)$

o (n)

$o(n)$

Ω (n)

$\Omega(n)$

— Sasho Nikolov,

@SashoNikolov: In realtà, l'intero problema dello spazio è tangenziale. La mia domanda riguarda principalmente il runtime. Se la risposta fosse "sì", i limiti inferiori (sulla complessità dello spazio) dimostrati nel documento si applicherebbero a tutti gli algoritmi a tempo lineare. Che il limite inferiore sia sullo spazio è casuale, ma non è al centro della questione in sé.

— Raffaello

Non capisco. È banale rendere un algoritmo di tempo lineare "streaming one-pass" con spazio illimitato. La tua domanda ha senso solo se nella forma "un algoritmo ad accesso casuale a tempo lineare può essere trasmesso in streaming costante pur mantenendo approssimativamente la misura della complessità

". Quindi dovresti scegliere una misura di complessità, o questo non ha senso.

μ

$\mu$

— Sasho Nikolov,

@SashoNikolov: non ero a conoscenza del fatto che "l'algoritmo di streaming" aveva problemi di definizione. Dato che mostrano uno spazio lineare inferiore per gli algoritmi di streaming, ho assunto che lo spazio non fosse il nucleo di una definizione. Ma immagino che potresti tradurre quello legato a "Non esiste un algoritmo di streaming ...". Tuttavia, che dire di questa definizione: "Un algoritmo di streaming è un algoritmo a cui viene fornito l'input (elenco) un elemento alla volta. Per ogni nuovo elemento, può eseguire un calcolo in

. Dopo aver costantemente molti di questi passaggi , deve emettere una risposta dopo un ulteriore

tempo. "

o (n)

$o(n)$

o (n)

$o(n)$

— Raffaello

@SashoNikolov: Ciò escluderebbe gli algoritmi "copia l'input e fai qualsiasi cosa" dall'idea, ma lo limiterebbe a

tempo. Si adatta alla classe solitamente indicata? In caso contrario, non penso che "streaming" possa essere definito nel tempo o complessità spaziale in modo utile. È piuttosto una strategia, molto simile a Greedy o divide & conquistare.

o (n^{2})

$o(n^2)$

— Raffaello

15

Affinché gli algoritmi di streaming siano significativi, devono lavorare con una quantità di spazio di lavoro significativamente inferiore rispetto all'input stesso. Ad esempio, se si consente la stessa quantità di spazio di lavoro dell'input, è possibile indicare in modo banale qualsiasi algoritmo come un "algoritmo di streaming a passaggio singolo" che prima copia l'input nello spazio di lavoro in un unico passaggio e quindi utilizza solo il lavoro spazio.

Penso che sia tipico limitare lo spazio di lavoro al massimo al pollogaritmico nella dimensione di input quando si parla di algoritmi di streaming. In base a questo presupposto, la selezione mediana non ha un algoritmo di streaming con passaggio O (1) per effetto di Munro e Paterson [MP80]: qualsiasi algoritmo di streaming con passaggio P per la selezione mediana su N elementi deve memorizzare Ω ( N ^{1 / P} ) elementi. D'altra parte, la selezione mediana ha un noto algoritmo deterministico a tempo lineare [BFPRT73].

[BFPRT73] Manuel Blum, Robert W. Floyd, Vaughan Pratt, Ronald L. Rivest e Robert E. Tarjan. Termini per la selezione. Journal of Computer and System Sciences , 7 (4): 448–461, agosto 1973. DOI: 10.1016 / S0022-0000 (73) 80033-9

[MP80] J. Ian Munro e Mike S. Paterson. Selezione e ordinamento con memoria limitata. Theoretical Computer Science , 12 (3): 315–323, novembre 1980. DOI: 10.1016 / 0304-3975 (80) 90061-4

— Tsuyoshi Ito
fonte

6

Nel modello di streaming è consentito memorizzare dati extra costanti o poliarcaritmici durante la scansione dell'ingresso. Se si considera un algoritmo di tempo lineare
che segue il paradigma di divisione e conquista , è necessario memorizzare più informazioni e / o eseguire la scansione dei dati tante volte quanto la profondità della ricorsione.

Un esempio è l' algoritmo DC3 per costruire l' array di suffissi di un testo (dato come array nel modello RAM). Per costruire un array di suffissi, raggruppate i caratteri in terzine, in modo da ottenere un testo con nuovi super caratteri . Puoi farlo con un offset di , che risulta in tre nuovi testi . È interessante notare che è possibile calcolare l'array di suffissi se si dispone dell'array di suffissi di in tempo lineare. Quindi l'algoritmo ha bisogno $T$ $0,1,2$ $T_1,T_2,T_3$ $T_1\cdot T_2$

t (n) = t (2 / 3 n) + O (n)

$t(n)= t(2/3 \;n) + O(n)$

tempo. Questa ricorsione si risolve chiaramente in . Non vedo come questo possa essere trasformato in un algoritmo di streaming. $t(n)=O(n)$

Un altro esempio ben noto è il classico algoritmo di selezione a tempo lineare .

— A.Schulz
fonte

Ecco un altro possibile esempio. La creazione di un heap richiede O (n) e utilizza internamente la subroutine heapify () basata sulla divisione e sulla conquista.

— Massimo Cafaro,

ma questa non è una prova, vero? stai solo dicendo che una simulazione ingenua non funzionerà. ma a volte ci sono algoritmi sorprendenti

— Sasho Nikolov,

@SashoNikolov: Quello che sto dicendo è che non considero l'algoritmo DC3 come algoritmo di streaming, poiché richiede molta memoria di lavoro. Forse puoi modificare l'algoritmo in un algoritmo di streaming, ma il risultato non sarebbe il DC3. Non ho discusso se esiste un algoritmo di streaming

per la costruzione di array di suffissi. Questa sarebbe una domanda completamente diversa.

O (n)

$O(n)$

— A.Schulz,

"Non vedo come questo possa essere trasformato in un algoritmo di streaming" mi ha fatto credere che stai dicendo qualcosa oltre a "questo algoritmo non è in streaming senza modifiche"

— Sasho Nikolov,

4

$P$

$R(P)$ $P$
$S(P)$ $P$

$R(P)$ $S(P)$

$n$ $[1, n-1]$ $O(\log n)$ $O(1)$ $\omega(\log n)$

$O(1/\log^2 n)$ $ps = \Omega(\sqrt{n})$ $p$ $s$ $O(\log^2 n)$

— Sasho Nikolov
fonte

1

Anche nella definizione più semplice di "algoritmo di streaming" (un algoritmo che, dopo ogni iterazione incrementale sulla sorgente, porta alla conoscenza immediata del prossimo pezzo incrementale del risultato), posso pensare ad alcuni algoritmi lineari che non lo fanno comportarsi in questo modo. Gli algoritmi di hash sono grandi; FNV-1a è lineare rispetto al numero di byte nella sorgente, ma non conosciamo alcuna parte dell'hash finale fino a quando l'intera fonte non è stata elaborata.

RadixSort aka BucketSort è O (N) (tecnicamente O (NlogM) dove M è il valore massimo negli articoli N, che è considerato piccolo) e deve essere eseguito nella sua interezza per garantire che ogni singolo articolo si trovi al suo posto finale.

Per essere un algoritmo di "streaming", nella sua forma più semplice, un algoritmo deve avere le seguenti due proprietà, nessuna delle quali è espressamente legata al tempo:

Migliore della complessità spaziale O (N) (dichiarata in modo equivalente, non è necessario conoscere l'intera sorgente e non è necessario memorizzare l'intero risultato)
O (N) relazione I / O (l'algoritmo produce un numero di uscite linearmente proporzionale ai suoi ingressi)

Pertanto, la classe principale di algoritmi che trasmettono è quella di algoritmi che eseguono "proiezioni" (trasformazioni incrementali di un input in output X> 0).

— Keiths
fonte

O (\log n)

$O(\log n)$

ω (1)

$\omega(1)$

anche logN va bene; il punto era che l'algoritmo non dovrebbe aver bisogno della conoscenza dell'intero input o output contemporaneamente.

— KeithS

Ω (n)

$\Omega(n)$