Ci sono problemi il cui algoritmo più noto ha tempo di esecuzione

Non ho mai visto un algoritmo con un registro nel denominatore prima e mi chiedo se ci sono algoritmi effettivamente utili con questo modulo?

Comprendo molte cose che potrebbero causare la moltiplicazione di un fattore di registro in fase di esecuzione, ad esempio ordinamento o algoritmi basati su albero, ma cosa potrebbe farti dividere per un fattore di registro?

La solita risposta a "cosa potrebbe farti dividere per un registro?" è una combinazione di due cose:

1. un modello di calcolo in cui sono consentite operazioni aritmetiche a tempo costante su numeri interi di dimensioni di parole, ma in cui si desidera essere prudenti su quanto sono lunghe le parole, quindi si assumono bit per parola (perché meno di quello e non potevi nemmeno occuparti di tutta la memoria, e anche perché gli algoritmi che usano le ricerche delle tabelle richiederebbero troppo tempo per impostare le tabelle se le parole fossero più lunghe), e$O(\log n)$
2. un algoritmo che comprime i dati comprimendo i bit in parole e quindi opera sulle parole.

Penso che ci siano molti esempi, ma l'esempio classico è l' algoritmo dei Quattro Russi per le sottosequenze comuni più lunghe ecc. In realtà finisce per essere , perché usa l'idea del bit-pack ma poi salva un secondo fattore di log usando un'altra idea: sostituire i blocchi di operazioni di bit con una singola ricerca di tabella.O ( log 2 n $O(n^2/\log^2 n)$$O(\log^2 n)$

Il cubo di Rubik è un esempio molto naturale (e per me inaspettato). Un cubo $n\times n\times n$ richiede $\Theta(n^2/\log n)$ passaggi per risolvere. (Nota che questa è una notazione theta, quindi è un limite superiore e inferiore stretto).

Questo è mostrato in questo documento [1].

Vale la pena ricordare che la complessità della risoluzione di istanze specifiche del cubo di Rubik è aperta, ma ipotizzata NP-difficile (discussa qui per esempio) NP difficile [2]. L' algoritmo $\Theta(n^2/\log n)$ garantisce una soluzione e garantisce che tutte le soluzioni siano asintoticamente ottimali, ma potrebbe non risolvere istanze specifiche in modo ottimale. La tua definizione di utile può o non può essere applicata qui, poiché i cubi di Rubik non vengono generalmente risolti con questo algoritmo ( l'algoritmo di Kociemba viene generalmente utilizzato per cubetti di piccole dimensioni in quanto offre soluzioni rapide e ottimali nella pratica).

[1] Erik D. Demaine, Martin L. Demaine, Sarah Eisenstat, Anna Lubiw e Andrew Winslow. Algoritmi per la risoluzione dei cubi di Rubik. Atti del 19 ° Simposio europeo annuale sugli algoritmi (SEC 2011), 5-9 settembre 2011, pagine 689-700

[2] Erik D. Demaine, Sarah Eisenstat e Mikhail Rudoy. Risolvere il cubo di Rubik in modo ottimale è NP-completo. Atti del 35 ° Simposio internazionale sugli aspetti teorici dell'informatica (STACS 2018), 28 febbraio-3 marzo 2018, pagine 24: 1-24: 13.

Un esempio di che appare nel denominatore senza trucchi per l'imballaggio dei bit è un recente articolo di Agarwal, Ben Avraham, Kaplan e Sharir sul calcolo della distanza discreta di Fréchet tra due catene poligonali nel tempo O ( n 2 log log n / log n ) . Anche se non ho familiarità con i dettagli dell'algoritmo, un trucco generale è quello di suddividere l'input in pezzi relativamente piccoli e quindi combinare le risposte in modo intelligente (ovviamente questo sembra dividere e conquistare, ma non si ottiene il registro n nel denominatore con alcuni trucchi intelligenti)$\log n$$O(n^2\log\log n/\log n)$

Non esattamente quello che hai chiesto, ma una situazione "allo stato brado" in cui un fattore di registro appare nel denominatore è il documento " Pebbles and Branching Programs for Tree Assessment " di Stephen Cook, Pierre McKenzie, Dustin Wehr, Mark Braverman e Rahul Santhanam.

Il problema di valutazione dell'albero (TEP) è: dato un albero -ary annotato con i valori in { 1 , ... , k } sulle foglie e le funzioni { 1 , ... , k } d → { 1 , ... , k } sui nodi interni , valuta l'albero. Qui ogni nodo interno ottiene il valore della sua funzione annotata sui valori dei suoi figli. Questo è un problema facile e il punto è mostrare che non può essere risolto nello spazio logaritmico (quando l'altezza dell'albero fa parte dell'input). A tal fine, siamo interessati alla dimensione dei programmi di diramazione che risolvono la TEP.$d$$\{1,\ldots,k\}$$\{1,\ldots,k\}^d \to \{1,\ldots,k\}$

Nella sezione 5, vengono presentati limiti stretti per alberi di altezza 3, sia per TEP che per il relativo problema BEP, in cui l'output viene compresso a in modo arbitrario. Per TEP il limite è Θ ( k 2 d - 1 ) , mentre per BEP il limite è Θ ( k 2 d - 1 / log k ) , ovvero si ottiene un salvataggio del log k .$\{0,1\}$$\Theta(k^{2d-1})$$\Theta(k^{2d-1}/\log k)$$\log k$

Anche se non si tratta di runtime, ho pensato che valesse la pena menzionare il risultato classico di Hopcroft, Paul e Valiant: [1], poiché è ancora in lo spirito di "cosa potrebbe farti salvare un fattore log."$\mathsf{TIME[t]} \subseteq \mathsf{SPACE}[t/\log t]$

Ciò fornisce molti esempi di problemi il cui limite superiore più noto alla complessità dello spazio ha un registro nel denominatore. (A seconda del tuo punto di vista, penso che o renda questo esempio molto interessante - che straordinario teorema! - o molto poco interessante - probabilmente non è "realmente utile".)

[1] Hopcroft, Paul e Valiant. In tempo contro spazio . J. ACM 24 (2): 332-337, 1977.

Esistono due problemi con la complessità della query :$\Theta(n/\log n)$

• Problema di pesatura delle monete con bilancia a molla.
• Mastermind con n posizione e 2 colori.

L'algoritmo più noto per calcolare la distanza di modifica (nota anche come Levenshtein) tra due stringhe di lunghezza richiede il tempo O ( ( n / log n ) 2 ) :$n$$O((n/\log n)^2)$

William J. Masek, Mike Paterson: un algoritmo di calcolo più veloce Modifica le distanze. J. Comput. Syst. Sci. 20 (1): 18-31 (1980).

appare come il limite corretto per un problema considerato da Greg e Paul Valiant (nessuna connessione ai trucchi dei bit):$\Theta(n/\log n)$

Gregory Valiant e Paul Valiant, Il potere degli stimatori lineari, 2011. Nel 52 ° Simposio annuale IEEE sulle basi dell'informatica, FOCS 2011.

Ecco un altro esempio di limite stretto con un fattore di registro. (Questo è il Teorema 6.17 di Boolean Function Complexity: Advances and Frontiers di Stasys Jukna.)

$\Theta(n^2/\log n)$$n$

$m$$\text{poly}(m)$$n := O(m \log m)$$O(\log m)$$m$$\Theta(m^2 \log m)$$\Theta(n^2/\log n)$$n$$n$

$\theta(\frac{n}{\log(n)})$$\theta(\frac{n}{\log(n)})$

$O(f(n))$$O\left({f(n)\over{\log f(n)}}\right)$$f(n)=n$$O\left(n \over {\log n} \right)$