Read without ads and support Scribd by becoming a Scribd Premium Reader.
See Premium Plans
 
Algoritmi per la generazione di permutazioni
Vincenzo La Spesa4 marzo 2010
v1.2
Indice
1 Algoritmo iterativo per generare permutazioni in ordine lessicografico22 Algoritmo ricorsivo per generare permutazioni33 Algoritmo degli scambi semplici (Plain changes - Johnson-Trotter)44 Determinare una specifica permutazione dall’insieme delle permutazioni64.1 I Factoradic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64.2 Interpretazione dei codici di Lehmer. . . . . . . . . . . . . . . . . . . . . 64.2.1 Algoritmi per la generazione di un Factoradic. . . . . . . . . . . . 84.3 Generazione di permutazioni casuali con i factoradic. . . . . . . . . . . . 95 Ricavare il numero di una permutazione (ranking)96 Generare permutazioni casuali (algoritmo di Fisher-Yates o Knuth shuffle)106.1 Problemi di bias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Riferimenti bibliografici11
http://thedarshan.wordpress.com/
Quest’opera `e stata rilasciata sotto la licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia. Per leggere una copia della li-cenza visita il sito web http://creativecommons.org/licenses/by-nc-sa/2.5/it/ o spe-disci una lettera a Creative Commons, 171 Second Street, Suite 300, San Francisco,California, 94105, USA.
1
 
1 Algoritmo iterativo per generare permutazioni in ordine lessicografico
L’algoritmo seguente `e probabilmente il pi`u semplice algoritmo iterativo per listare lepermutazioni di un insieme di elementi, analizza semplicemente la permutazione attualeper ricavarne la prossima basandosi sul fatto che le permutazioni devono seguire unordinamento lessicografico (nel caso numerico qui analizzato ogni permutazione deveessere la minima permutazione maggiore di quella corrente)considerando la permutazione come un vettore di n elementi numerici l’algoritmodetermina la permutazione successiva nel seguente modo:1. a partire dall’ultimo elemento scorre l’array cercando il primo elemento precedutoda un elemento minore2. se non esiste si `e giunti all’ultima permutazione possibile e l’algoritmo deve termi-nare3. se esiste ricomincia a scorrere il vettore dalla fine cercando il primo elementomaggiore all’elemento trovato al punto14. si invertono gli elementi trovati al punto1 e al punto35. se lo scambio non `e avvenuto tra elementi di livello minimo (l’ultimo e il penultimo)si ripristina l’ordinamento interno invertendo le posizioni degli elementi che sitrovano tra l’elemento trovato al punto1 e quello trovato al punto3l’algoritmo `e molto semplice e molto generico ma non `e efficiente, infatti il fatto di doveranalizzare a ogni iterazione la struttura attuale del vettore ne incrementa di molto lacomplessit`a.Listing 1: Algoritmo semplice
public boolean
prossima ()
{
int
i = len
−
1;
while
( i
>
0 && ( elementi [ i
−
1]
>
= elementi [ i ])) i
−−
;
if 
( i==0)
return false
;
int
j = len ;
// (i 
−
1) `e l ’ elemento trovato con i l ciclo precedente
while
( elementi [ j
−
1]
<
= elementi [ i
−
1]) j
−−
;swap( i
−
1, j
−
1);i++; j = len ;
// inverto gli elementi tra i due elementi scambiati 
while
( i
<
j )
{
swap( i
−
1, j
−
1);i++; j
−−
;
}
return true
;
}
2
 
2 Algoritmo ricorsivo per generare permutazioni
L’uso di un algoritmo ricorsivo per la generazione di permutazioni non `e particolarmen-te conveniente perche non permette di generare una permutazione per volta, e inoltrel’approccio iterativo `e di pers`e pi`u veloce perche non usa memoria di stack, detto questoho deciso di includere comunque questo algoritmo come esempio “didattico”.L’implementazione ricorsiva `e una tipica applicazione dell’approccio
divide et impera Le permutazioni di un vettore di n elementi si ottengono calcolando le permutazioni del sottovettore di n-1 elementi e poi scambiando l’n-esimo elemento con ogni elemen-to del sottovettore. Il caso base `e la permutazione di un vettore di due elementi che `esemplicemente uno scambio
Listing 2: Algoritmo ricorsivo
static void
permuta ricorsivo (
int
[ ] elementi ,
int
da ,
int
a)
{
int
k;
if 
(a
>
da)
{
for
(k = a; k
>
= da; k
−−
)
{
Array util .swap( elementi , k, a );permuta ricorsivo ( elementi , da , a
−
1);Array util .swap( elementi , k, a );
}}
else
{
System . out . println ( Array util .dump( elementi ));
}}
2,1,3,4 2,1,4,3 4,1,3,2 2,4,3,11,3,2,4 1,4,2,3 1,3,4,2 4,3,2,13,1,2,4 4,1,2,3 3,1,4,2 3,4,2,13,2,1,4 4,2,1,3 3,4,1,2 3,2,4,12,3,1,4 2,4,1,3 4,3,1,2 2,3,4,1Tabella 1: Esecuzione dell’algoritmo su un vettore di 4 elementi3
Search
Search History:
Searching...
Result 00 of 00
00 results for result for
  • p.
    • Notes
    Load more