Algoritmo di tempo lineare deterministico per verificare se un array è una versione ordinata dell'altro

Considera il seguente problema:

Input: due matrici e di lunghezza , dove è in ordine.$A$$B$$n$$B$

Domanda: do e contengono gli stessi elementi (con la loro molteplicità)?$A$$B$

Qual è l' algoritmo deterministico più veloce per questo problema?
Può essere risolto più velocemente di ordinarli? Questo problema può essere risolto in un tempo lineare deterministico?

Non hai specificato il tuo modello di calcolo, quindi assumerò il modello di confronto.

Si consideri il caso speciale in cui l'array è tratto dall'elenco { 1 , 2 } × { 3 , 4 } × ⋯ × { 2 n - 1 , 2 n } . In parole, l' i elemento è 2 i - 1 o 2 i .$B$

$$\{1,2\} \times \{3,4\} \times \cdots \times \{2n-1,2n\}.$$ $i$$2i-1$$2i$

Sostengo che se l'algoritmo conclude che e B contengono gli stessi elementi, che l'algoritmo è confrontato ogni elemento B alla sua controparte A . Infatti, supponiamo che l'algoritmo conclude che A e B contengono gli stessi elementi, ma mai a confronto il primo elemento di B alla sua controparte in A . Se cambiamo il primo elemento, l'algoritmo procederà esattamente allo stesso modo, anche se la risposta è diversa. Ciò dimostra che l'algoritmo deve confrontare il primo elemento (e qualsiasi altro elemento) alla sua controparte A .$A$$B$$B$$A$$A$$B$$B$$A$$A$

Ciò significa che se e B contengono gli stessi elementi, quindi dopo aver verificato questo algoritmo conosce l'ordinamento dei A . Quindi deve avere almeno n ! foglie diverse, e quindi ci vuole tempo Ω ( n log n ) .$A$$B$$A$$n!$$\Omega(n\log n)$

Questa risposta considera un diverso modello di calcolo: il modello di RAM a costo unitario. In questo modello, le parole macchine hanno dimensione e le operazioni su di esse richiedono O ( 1 ) . Supponiamo anche per semplicità che ogni elemento dell'array si adatti a una parola macchina (e così sia al massimo n O ( 1 ) in grandezza).$O(\log n)$$O(1)$$n^{O(1)}$

Costruiremo un algoritmo randomizzato a tempo lineare con errore unilaterale (l'algoritmo potrebbe dichiarare che i due array contengono gli stessi elementi anche se non è così) per il problema più difficile di determinare se due array e b 1 , … , b n contengono gli stessi elementi. (Non richiediamo che nessuno di questi sia ordinato.) Il nostro algoritmo commetterà un errore con probabilità al massimo 1 / n .$a_1,\ldots,a_n$$b_1,\ldots,b_n$$1/n$

L'idea è che la seguente identità valga se gli array contengono gli stessi elementi: Il calcolo esatto di questi polinomi richiederà troppo tempo. Invece, scegliamo un primo casuale p e un casuale x 0 e testiamo se n ∏ i = 1 ( x 0 - a i ) ≡ n

$$\prod_{i=1}^n (x-a_i) = \prod_{i=1}^n (x-b_i).$$ $p$$x_0$ Se gli array sono uguali, il test passerà sempre, quindi concentriamoci sui casi in cui gli array sono diversi. In particolare, un coefficiente di ∏ n i = 1 ( x - a i ) - ∏ n i = 1 ( x - b i ) è diverso da zero. Poiché a i , b ho magnitudine n O ( 1 ) , questo coefficiente ha magnitudine 2 n n O $$\prod_{i=1}^n (x_0-a_i) \equiv \prod_{i=1}^n (x_0-b_i) \pmod{p}.$$ $\prod_{i=1}^n (x-a_i) - \prod_{i=1}^n (x-b_i)$$a_i,b_i$$n^{O(1)}$ , e quindi ha al massimoO(n)fattori primi di dimensioneΩ(n). Questo significa che se si sceglie un set di almeno n 2 numeri primipdi dimensioni di almeno n 2 (ad esempio), poi per un primo casopdi questo set sarà tenere con probabilità di almeno1-1 / nche n Π i = 1 (x- a i$2^n n^{O(n)} = n^{O(n)}$$O(n)$$\Omega(n)$$n^2$$p$$n^2$$p$$1-1/n$ Unmodulo p casuale x 0 lo vedrà con probabilità 1 - n / p ≥ 1 - 1 / n (poiché un polinomio di grado al massimo n ha al massimo n radici). $$\prod_{i=1}^n (x-a_i) - \prod_{i=1}^n (x-b_i) \not\equiv 0 \pmod{p}.$$ $x_0$$p$$1-n/p \geq 1-1/n$$n$$n$

$p$$n^2$$n^2$$x_0$$p$$1-O(1/n)$$O(n)$$p$

$n^2$$\Omega(1/\log n)$$p$$(\log n)^{O(1)}$$x_0$$p$$x_0$

$O(n)$$1-O(1/n)$$1-O(1/n^C)$$C$

proporrò un altro algoritmo (o almeno uno schema di tale algoritmo)

Lo schema presuppone che i valori (presupposti " numeri interi ") siano compresi in un intervallo (stretto?) Tra$[min,max]$

1. Nel $O(n)$scansionando i due array, possiamo trovare i valori mine maxper entrambi e la loro molteplicità, se questi differiscono, gli array non sono permutazioni l'uno dell'altro

2. Sottrai mintutti i valori da entrambi gli array (qui il fatto che un array sia già in ordine non viene preso in considerazione, presumibilmente questo può essere migliorato)

3. Supponiamo che i valori nelle matrici rappresentino le masse e applichiamo un'accelerazione / velocità a ciascuna grandezza$1$ (questo può essere migliorato fino a un massimo di $c > 1$ in alcuni casi)

4. spostare le masse fino a raggiungere il valore massimo max-min, questo ha una complessità di$O((max-min)n)$. Ciò consente di trovare sia gli stessi valori sia la loro molteplicità, se questi differiscono, gli array non sono permutazioni l'uno dell'altro. Altrimenti decidi che le matrici sono permutazioni l'una dell'altra.

notare che lo schema dell'algoritmo sopra può essere (deterministico) abbastanza veloce in molte situazioni pratiche.

Lo schema dell'algoritmo sopra riportato è una variazione di un algoritmo di ordinamento a tempo lineare che impiega " masse mobili ". L'intuizione fisica dietro l' algoritmo di ordinamento delle " masse in movimento " è questa:

Supponiamo che il valore di ogni oggetto rappresenti effettivamente la sua grandezza di massa e immagina di disporre tutti gli oggetti in una linea e applicare la stessa forza di accelerazione.

Quindi ogni oggetto si sposterà fino a una distanza relativa alla sua massa, più enorme meno distanza e viceversa. Quindi, per recuperare gli oggetti ordinati, è sufficiente raccogliere gli articoli in ordine inverso per distanza percorsa.

Questo algoritmo è lineare e deterministico , ma c'è un avvertimento in quanto la quantità di forza di accelerazione iniziale e la distanza da percorrere (o il tempo di attesa) è correlata alla distribuzione dei valori (cioè le " masse ", il$max-min$fattore sopra). Si può anche provare a discretizzare lo spazio per gli oggetti di viaggiare in una griglia e ottenere un fattore costante nella velocità dell'algoritmo (e utilizzare una routine di ordinamento rapido per ordinare elementi diversi nella stessa cella ).

A questo proposito, l'algoritmo sopra riportato è simile agli algoritmi di ordinamento basati su valori numerici (ad es. Radix-sort , counting-sort )

Si potrebbe pensare che questo algoritmo non significhi molto, ma mostra almeno una cosa. Ciò, " fondamentalmente ", a livello fisico, l'ordinamento di numeri arbitrari è un'operazione a tempo lineare nel numero di elementi.