Algoritmo shuffle riffle sul posto a tempo lineare

Esiste un algoritmo di riffle shuffle sul posto lineare nel tempo? Questo è l'algoritmo che alcune mani particolarmente abili sono in grado di eseguire: dividere uniformemente un array di input di dimensioni pari e quindi intercalare gli elementi delle due metà.

Mathworld ha una breve pagina sulla riproduzione casuale dei riffle . In particolare, sono interessato alla varietà out-shuffle che trasforma l'array di input 1 2 3 4 5 6 in 1 4 2 5 3 6. Si noti che nella loro definizione, la lunghezza di input è . $2n$

È semplice eseguirlo in tempo lineare se abbiamo un secondo array di dimensioni o più utili. Prima copia gli ultimi elementi nell'array. Quindi, assumendo l'indicizzazione basata su 0, copiare i primi elementi dagli indici su . Quindi copiare gli elementi dal secondo array di nuovo nell'array di input, mappando gli indici su . (Possiamo fare un po 'meno lavoro di quello, perché il primo e l'ultimo elemento nell'input non si muovono.) $n$ $n$ $n$ $[0,1,2,...,n-1]$ $[0, 2, 4,...,2n-2]$ $n$ $[0,1,2,...,n-1]$ $[1,3,5,...,2n-1]$

Un modo per tentare di eseguire questa operazione sul posto consiste nella decomposizione della permutazione in cicli disgiunti e quindi nel riordinare gli elementi in base a ciascun ciclo. Ancora una volta, supponendo l'indicizzazione basata su 0, la permutazione implicata nel caso dei 6 elementi è

σ = (\begin{matrix} 0 & 1 & 2 & 3 & 4 & 5 \\ 0 & 2 & 4 & 1 & 3 & 5 \end{matrix}) = (\begin{matrix} 0 \end{matrix}) (\begin{matrix} 5 \end{matrix}) (\begin{matrix} 1 & 2 & 4 & 3 \end{matrix}) .

$\sigma=\begin{pmatrix} 0 & 1 & 2 & 3 & 4 & 5 \\ 0 & 2 & 4 & 1 & 3 & 5\end{pmatrix}=\begin{pmatrix}0 \end{pmatrix} \begin{pmatrix}5 \end{pmatrix} \begin{pmatrix}1 & 2 & 4 &3 \end{pmatrix}.$

Come previsto, il primo e l'ultimo elemento sono punti fissi e se permutiamo i 4 elementi centrali otteniamo il risultato atteso.

Sfortunatamente, la mia comprensione della matematica delle permutazioni (e del loro ) si basa principalmente su Wikipedia, e non so se questo possa essere fatto in tempo lineare. Forse le permutazioni coinvolte in questo mescolamento possono essere rapidamente decomposte? Inoltre, non abbiamo nemmeno bisogno della decomposizione completa. È sufficiente determinare un singolo elemento di ciascuno dei cicli disgiunti, dal momento che possiamo ricostruire il ciclo da uno dei suoi elementi. Forse è necessario un approccio completamente diverso. $\LaTeX$

Buone risorse sulla matematica correlata sono preziose quanto un algoritmo. Grazie!

ds.algorithms time-complexity

— Johny
fonte

Esiste una soluzione temporale (con spazio extra). Non conosco alcuna soluzione lineare.

O (n \lg n)

$O(n\lg n)$

O (1)

$O(1)$

— Radu GRIGore,

È più appropriato per cs.stackexchange. Nel modello non uniforme, volte è sempre possibile. In questo caso dovrebbe essere possibile anche in modo uniforme.

O (n)

$O(n)$

— Yuval Filmus,

@Radu Simile a questa domanda , questo problema probabilmente non ha una soluzione che utilizza solo spazio extra, ma spazio extra.

O (1)

$O(1)$

O (\log n)

$O(\log n)$

— Tyson Williams,

Prendo il mio commento (e voto per chiudere) indietro! (Sebbene la domanda abbia una risposta in letteratura.)

— Yuval Filmus,

Ho sentito questa domanda da uno studente CS la scorsa settimana, che l'ha ascoltata durante un colloquio di lavoro.

— Jeffε

Risposte:

Il problema è sorprendentemente non banale. Ecco una bella soluzione di Ellis e Markov, In-Situ, Stable Merging tramite Perfect Shuffle (sezione 7). Ellis, Krahn e Fan, Computing the Cycles in the Perfect Shuffle Permutazione riescono a selezionare "leader del ciclo", a scapito di più memoria. Inoltre è correlato il bel documento di Fich, Munro e Poblete, Permuting In Place , che fornisce un algoritmo di tempo per il modello dell'oracolo. Se è disponibile solo un oracolo per la permutazione, l'algoritmo richiede spazio logaritmico; se abbiamo anche un oracolo per l'inverso, richiede spazio costante. $O(n\log n)$

Ora per la soluzione di Ellis e Markov. Innanzitutto, supponiamo che . Quindi calcolare il perfetto riordino dell'ordine riduce al calcolo della perfetta riordino degli ordini ed , con una rotazione li precede. Ecco una dimostrazione di esempio ( , , ): $n = x+y$ $n$ $x$ $y$ $n=5$ $x=3$ $y=2$

\begin{array}{cc} 012345 & 6789 \\ 012567 & 3489 \\ 051627 & 3849 \end{array}

$\begin{array}{cc} 012\mathbf{345} & \mathbf{67}89 \\ 012\mathbf{567} & \mathbf{34}89 \\ 051627 & 3849 \end{array}$

Ellis e Markov hanno trovato un modo semplice per calcolare lo shuffle perfetto quando , usando spazio costante e tempo lineare. Usando questo, otteniamo un algoritmo per calcolare lo shuffle perfetto per arbitrario . Per prima cosa, scrivi usando la codifica binaria di , e lascia che . Ruota i bit , mescola i bit di destra . Ignorando la mano destra $n=2^k$ $n$ $n = 2^{k_0} + \cdots + 2^{k_w}$ $n$ $n_i = 2^{k_i} + \cdots + 2^{k_w}$ $n_0$ $2^{k_0}$ $2^{k_0}$ bit, ruotare il mezzo bit, e mescolare la destra $n_1$ $2^{k_1}$ bit. E così via. Si noti che la rotazione è semplice poiché i primi elementi ruotati funzionano come leader del ciclo. La complessità totale della rotazione è , poiché . La complessità totale dei riordini interni è . $O(n_0 + \cdots + n_w) = O(n)$ $n_{t+1} < n_t/2$ $O(2^{k_0} + \cdots + 2^{k_w}) = O(n)$

Resta da mostrare come calcolare lo shuffle perfetto quando . In effetti, saremo in grado di identificare i leader del ciclo, seguendo il lavoro classico sulle collane (Fredricksen e Maiorana, Collane di perline in colori e sequenze di -ary de Bruijn ; Fredricksen e Kessler, Un algoritmo per generare collane di perline in due colori ). $n=2^k$ $k$ $k$

Qual è la connessione? Dichiaro che la permutazione shuffle corrisponde al giusto spostamento della rappresentazione binaria. Ecco una dimostrazione per esempio, per : Pertanto, per trovare i leader del ciclo, dobbiamo trovare un rappresentante per ciascuna classe di equivalenza della rotazione di stringhe binarie di lunghezza . I documenti sopra menzionati forniscono il seguente algoritmo per generare tutti i leader del ciclo. Inizia con $n=8$

\begin{array}{cccccccc} 000 & 001 & 010 & 011 & 100 & 101 & 110 & 111 \\ 000 & 100 & 001 & 101 & 010 & 110 & 011 & 111 \end{array}

$\begin{array}{cccccccc} 000 & 001 & 010 & 011 & 100 & 101 & 110 & 111 \\ 000 & 100 & 001 & 101 & 010 & 110 & 011 & 111 \end{array}$

k

$k$

0^{k}

$0^k$ . Ad ogni passo, siamo ad un certo punto

. Trova l'indice massimo

di un bit zero, dividi

per

per ottenere

e lascia che il punto seguente sia

. Ogni volta che

, la nuova stringa è un leader del ciclo.

a_{1} \dots a_{k}

$a_1 \ldots a_k$

i

$i$

k

$k$

i

$i$

k = d \cdot i + r

$k = d\cdot i + r$

(a_{1} \dots a_{i - 1} 1)^{d} a_{1} \dots a_{r}

$(a_1\ldots a_{i-1}1)^d a_1\ldots a_r$

r = 0

$r = 0$

Ad esempio, quando questo genera la sequenza $n=16$

0000, 0001, 0010, 0011, 0101, 0110, 0111, 1111 .

$\mathbf{0000}, \mathbf{0001}, 0010, \mathbf{0011}, \mathbf{0101}, 0110, \mathbf{0111}, \mathbf{1111}.$

I leader del ciclo sono evidenziati.

— Yuval Filmus
fonte

Vedi anche la risposta di Aryabhata, che utilizza arxiv.org/abs/0805.1598 . Quel documento, "Un semplice algoritmo sul posto per In-Shuffle" di Jain, usa la stessa idea, ma invece di poteri di

, usa poteri di

. Il punto è che poiché

è una radice primitiva modulo

, si vede facilmente che

sono leader del ciclo. Ancora più semplice di Ellis e Markov!

2

$2$

3

$3$

2

$2$

3^{k}

$3^k$

3^{0}, \dots, 3^{k}

$3^0,\ldots,3^k$

— Yuval Filmus,

Anche se penso che il documento di Jain sia un po 'più semplice, preferisco quello precedente, così come quello precedente con il maggior numero di voti.

— Johny,

Questa è stata una domanda di seeding su cs.stackexchange.com e una risposta è qui: /cs/332/in-place-algorithm-for-interleaving-an-array/400#400

È una spiegazione del documento: http://arxiv.org/abs/0805.1598 .

$k$ $2$ $k$ $3^2$ $k=2$

$j \to 2j \mod 2n+1$

— Aryabhata
fonte

Ha! Mi ero completamente dimenticato di quella domanda, anche se ho partecipato alla discussione. Questo significa che non ho davvero capito come funziona quella volta.

— Radu GRIGore,

$m$ $n = m-2$ $i$ $f(i) = 2\cdot i$ $i \leq n/2$ $f(i) = 2 \cdot (i \mod n/2) - 1$ $i > n/2$

$O(1)$ $O(\log n)$

— Robert Robere
fonte

Ah aspetta. Ciò presuppone che tutti i valori nella permutazione del riffle si trovino sullo stesso ciclo. Questa strategia dovrebbe essere modificata un po ', a seconda di quanti cicli disgiunti ci sono.

— Robert Robere,