Cosa significa un algoritmo più veloce in informatica teorica?

Se esiste un algoritmo in esecuzione nel tempo per qualche problema A, e qualcuno trova un algoritmo in esecuzione nel tempo, , dove , è considerato un miglioramento rispetto all'algoritmo precedente?$O(f(n))$$O(f(n)/g(n))$$g(n) = o(f(n))$

Ha senso, nel contesto dell'informatica teorica, elaborare un simile algoritmo?

No, un algoritmo in esecuzione nel tempo , dove , non è necessariamente considerato un miglioramento. Ad esempio, supponiamo che e . Quindi è un limite di tempo peggiore di .$O(f(n)/g(n))$$g(n) = o(f(n))$$f(n) = n$$g(n) = 1/n$$O(f(n)/g(n)) = O(n^2)$$O(f(n)) = O(n)$

Per migliorare un algoritmo in esecuzione nel tempo , devi trovare un algoritmo in esecuzione nel tempo , cioè nel tempo per alcune funzioni .o ( f ( n ) ) g ( n ) g ( n ) = o ( f ( n ) $f(n)$$o(f(n))$$g(n)$$g(n) = o(f(n))$

Se tutto ciò che sai è che un algoritmo viene eseguito nel tempo , non è chiaro se un algoritmo eseguito nel tempo sia un miglioramento, qualunque sia sono. Questo perché la grande O è solo un limite superiore del tempo di esecuzione. Invece, è comune considerare il tempo della complessità nel caso peggiore, e stimare come un grande e non solo come un grande .O ( g ( n ) ) f ( n ) , g ( n ) Θ $O(f(n))$$O(g(n))$$f(n),g(n)$$\Theta$$O$

Ricordare che Notazione è pensato per analizzare come l'attività cresce per diverse dimensioni di ingresso, e specificamente tralascia fattori moltiplicativi, di ordine inferiore termine e costanti.$O(...)$

Supponiamo di avere un algoritmo cui tempo di esecuzione effettivo è 1 n 2 + 2 n + 1 (supponendo che si possano effettivamente contare le istruzioni e conoscere i tempi esatti e così via, il che è certamente un presupposto enorme nei sistemi moderni). Supponiamo quindi di trovare un nuovo algoritmo che sembra essere O ( n ) , ma il tempo di esecuzione effettivo è 1000 n + 5000 . Supponiamo anche che tu sappia che il software per utilizzare questo algoritmo non vedrà mai una dimensione del problema di n > 10 .$O(n^2)$$1n^2+2n+1$$O(n)$$1000n + 5000$$n>10$

Quindi, quale sceglieresti - l' algoritmo che impiegherà 15000 unità di tempo o quello O ( n 2 ) che prenderà solo 121 unità? Ora se il tuo software evolve per gestire dimensioni problematiche di n > 100000 , quale sceglieresti? Cosa faresti se le dimensioni del tuo problema variano notevolmente?$O(n)$$O(n^2)$$n>100000$

In genere, ciò significa che, per qualsiasi dimensione di input sufficientemente grande, il tempo di esecuzione nel peggiore dei casi del vecchio algoritmo è più lento di quello nuovo. Ciò equivale al formalismo , dove g è la complessità temporale del nuovo algoritmo e f la complessità temporale del vecchio.$g(n) \in o\bigl(f\left(n\right)\bigr)$$g$$f$

A volte, tuttavia, gli informatici si preoccupano delle prestazioni nel caso medio. L'esempio classico è Quicksort: il suo runtime nel caso peggiore è mentre ne conosciamo altri che girano in Θ ( n log n ) tempo, ma è ampiamente utilizzato nella pratica a causa del suo buon tempo medio di esecuzione. Può inoltre essere ottimizzato per l'esecuzione molto rapida nei casi più frequenti in natura, ad esempio array che sono per lo più nell'ordine giusto.$\Theta(n^2)$$\Theta(n \log n)$

E a volte, anche gli informatici teorici usano "più velocemente" allo stesso modo delle persone normali. Ad esempio, la maggior parte delle implementazioni delle classi String ha l'ottimizzazione delle stringhe corte (anche chiamata ottimizzazione delle stringhe piccole), anche se accelera le cose solo per le stringhe brevi ed è un overhead puro per quelle più lunghe. Man mano che le dimensioni dell'input diventano sempre più grandi, il tempo di esecuzione di un'operazione String con SSO sarà maggiore di un piccolo termine costante, quindi per la definizione che ho dato nel primo paragrafo, la rimozione di SSO da una classe String rende “più veloce . ”In pratica, tuttavia, la maggior parte delle stringhe sono piccole, quindi SSO rende la maggior parte dei programmi che le usano più velocemente, e la maggior parte dei professori di informatica sanno meglio che andare in giro chiedendo che le persone parlino solo di ordini di complessità temporale asintotica .

Non esiste una definizione unificata di cosa sia un "algoritmo più veloce". Non esiste un organo di governo che decide se un algoritmo è più veloce di un altro.

Per sottolineare perché, vorrei offrire due diversi scenari che dimostrano questo concetto oscuro.

Il primo esempio è un algoritmo che cerca un elenco collegato di dati non ordinati. Se riesco a fare la stessa operazione con un array, non ho alcun cambiamento sulla grande misura Oh delle prestazioni. Entrambe le ricerche sono O (n). Se guardo solo i grandi valori di Oh, potrei dire che non ho fatto alcun miglioramento. Tuttavia, è noto che nella maggior parte dei casi le ricerche di array sono più rapide di un elenco collegato, quindi si potrebbe decidere che ciò ha reso un algoritmo "più veloce", anche se il grande Oh non è cambiato.

Se posso usare il tradizionale esempio di programmazione di un robot per creare un sandwich PBJ, posso mostrare cosa intendo in un altro modo. Considera solo il punto in cui si sta aprendo il barattolo di burro di arachidi.

Pick up the jar
Grab the lid
Unscrew the lid

Contro

Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Put the jar back down
Pick up the jar
Grab the lid
Unscrew the lid

Anche nell'impostazione teorica più accademica che mi viene in mente, scoprirai che le persone accettano che il primo algoritmo è più veloce del secondo, anche se i grandi risultati della notazione Oh sono gli stessi.

Al contrario, possiamo considerare un algoritmo per violare la crittografia RSA. Al momento, si percepisce che questo processo è probabilmente O (2 ^ n), dove n è il numero di bit. Considera un nuovo algoritmo che esegue n ^ 100 più velocemente Ciò significa che il mio nuovo processo viene eseguito in O (2 ^ n / n ^ 100). Tuttavia, nel mondo della crittografia, una velocizzazione polinomiale verso un algoritmo esponenziale non è tradizionalmente considerata una velocità teorica. Quando si eseguono prove di sicurezza, si presume che un utente malintenzionato possa scoprire una di queste accelerazioni e che non avrà alcun effetto.

Quindi in una circostanza, possiamo cambiare una O (n) in O (n) e chiamarla più velocemente. In una diversa circostanza, possiamo cambiare una O (2 ^ n) in O (2 ^ n / n ^ 100) e affermare che non c'è stata alcuna accelerazione significativa. Questo è il motivo per cui dico che non esiste una definizione unificata per un "algoritmo più veloce". È sempre contestualmente dipendente.

$A(n) \in O(f(n))$

$$\exists \ 0 \le c_f \lt \infty \mid \ \limsup_{n \to \infty} \frac{A(n)}{f(n)} = c_f$$

Supponiamo ora che stiamo parlando di una funzione arbitrariamente crescente dove e creiamo la funzione .lim sup n → ∞ g ( n ) = ∞ h ( n ) = f ( n $g(n)$$\limsup_{n\to\infty} g(n) = \infty$$h(n) = \frac{f(n)}{g(n)}$

$A'(n)$$O(h(n))$$A(n)$$O(h(n))$

$$\exists \ 0 \le c_h \lt \infty \mid \ \limsup_{n \to \infty} \frac{A(n)}{h(n)} = c_h$$

Utilizzando le regole dei limiti, possiamo anche scrivere:

$$c_h = \limsup_{n \to \infty} \frac{A(n)}{h(n)} = \limsup_{n \to \infty} \frac{A(n)g(n)}{f(n)} = c_f \cdot \limsup_{n \to \infty} g(n)$$

$c_h \lt \infty$$c_f = 0$

L'affermazione contrapposta è: Se , allora .A ( n ) ∉ O ( h ( n ) $c_f \neq 0$$A(n) \notin O(h(n))$

In parole, è un "miglioramento" su nelle condizioni aggiuntive che e stanno aumentando arbitrariamente.A ( n ) A ( n ) ∈ Θ ( f ( n ) ) g ( n $A'(n)$$A(n)$$A(n) \in \Theta(f(n))$$g(n)$

Inoltre, questo dovrebbe mostrare perché l'affermazione secondo cui non è abbastanza forte da trarre una conclusione sul fatto che sia un "miglioramento". In breve, potrebbe già essere in .A ′ ( n ) A ( n ) O ( h ( n ) $A(n) \in O(f(n))$$A'(n)$$A(n)$$O(h(n))$