Algoritmi esponenziali

Transcript

1 Algoritmi esponenziali Algoritmi esponenziali Supponiamo che f(n) sia la funzione che rappresenta il numero di operazioni eseguite da un algoritmo e supponiamo che il tempo necessario per compiere una operazione sia un microsecondo: 1µs = 10-6 sec. Vogliamo vedere che per valori di n non elevati gli algoritmi impiegano un tempo troppo elevato per poter essere utilizzati: gli algoritmi esponenziali sono impraticabili. Algoritmi esponenziali Vediamo questa tabella dove riportiamo, al variare di n, il tempo impiegato da alcune funzioni di n (cap. 5) n log 2 (n) 100*n 10*n 2 n 3 2 n µs 1ms 1ms 1ms 1024µs ~ 1ms µs 2ms 4ms 8ms 1.048sec µs 6ms 36ms 0.21sec 2 60 µs ~ 366 secoli Algoritmi esponenziali 2 60 µs ~ 366 secoli, vediamo come mai 2 60 µs ~ µs ~ µs~ sec ( ) (1µs = 10-6 sec ) Quanti secondi in un anno? 1 minuto = 60 secondi 1 ora = 3600 secondi 1 giorno = secondi 1 secolo = secondi secondi secoli = = = 366 secondi in un secolo Algoritmi esponenziali Esistono degli algoritmi che sono intrinsecamente esponenziali: calcolare le permutazioni di n elementi: n! ~ n n Ci sono problemi che sono risolti da un algoritmo deterministico esponenziale, ma il cui algoritmo non deterministico è polinomiale. L algoritmo non deterministico è un algoritmo ideale: può essere simulato pensando di poter eseguire scelte contemporanee ed è rappresentabile su un albero: la profondità dell albero può essere proporzionale alla dimensione dei dati. Tali problemi si chiamano NP (Non deterministico Polinomiale). Algoritmi esponenziali Esempio. Consideriamo la formula logica F(x 1, x 2, x 3 ) = (x 1 e x 2 ) o (non x 3 ) e ci chiediamo se esiste una scelta di valori per le variabili x 1, x 2, x 3 che renda vera F. Un algoritmo deterministico prova tutte le possibilità e poiché il valore di x i può essere vero o falso, le possibilità sono

2 Algoritmi esponenziali In generale considerando F(x 1, x 2,.., x n ) il problema può essere risolto in un tempo O(2 n ). L algoritmo non deterministico è in grado di scegliere il valore di x i che porta alla soluzione. Per simulare tale comportamento si può costruire un albero: ogni nodo rappresenta una variabile della formula; da ogni nodo partono due rami che rappresentano il vero e il falso. Algoritmi esponenziali Se potessimo esplorare l albero in modo da poter percorrere contemporaneamente i due rami V e F, in n passi arriveremmo alle foglie. Quindi l algoritmo non deterministico è O(n). x 1 x 2 x 3 V x F x 2 x 2 x 3 x 3 x 3 x 3 Complessità asintotica Le considerazioni fatte sulla complessità valgono solo se n e F(n) Se invece n si mantiene limitato anche un algoritmo esponenziale può essere utilizzato; per lo stesso motivo anche la costante moltiplicativa, che solitamente trascuriamo nella notazione O-grande, può invece essere fondamentale nella scelta. Complessità asintotica Esempio. f 1 (n) = 1000 * n f 2 (n) = 10 * n 2 f 1 è O(n) f 2 è O(n 2 ) Quindi: se n è preferibile f 1 se n 10 è preferibile f 2, infatti: 1000 * n 1000*10 = * n 2 10*100 = 10 3 Ordinamento per inserimento Ordinamento per inserimento L idea è quella di inserire una componente in ordine rispetto ad una sequenza di componenti già ordinate. Esempio. Vogliamo inserire 6 nella sequenza: La cosa più efficiente è partire dall ultima posizione e slittare verso destra le componenti che sono maggiori si 6: in tale modo quelle più piccole restano ferme : ora c è posto per inserire 6. 2

3 Ordinamento per inserimento Per effettuare l ordinamento si parte dalla seconda componente che si inserisce in ordine rispetto alla prima, poi si considera la terza, che si inserisce in ordine rispetto alle prime due, in generale: si vuole inserire la k-esima componente in ordine rispetto alle k-1 già ordinate. Poiché il numero di componenti non aumenta, per poter slittare in avanti le componenti che precedono nella sequenza, è necessaria una variabile di appoggio x per salvare il valore: x Ordinamento per inserimento Bisogna non uscire dall array se si deve inserire un valore prima della prima componente. Ci sono varie strategie per realizzare ciò, una di queste è sfruttare la valutazione pigra dei predicati : for(k=1; k<=n-1; k++) {//v[0] è già //in ordine x=v[k]; i=k; while((i!=0) && (x < v[i-1])){ v[i]=v[i-1]; i--; } //fine while v[i]=x; }//fine for Ordinamento per inserimento Complessità. Caso favorevole: array già ordinato il predicato del ciclo interno è sempre falso, ( x < v[i-1] è falso), quindi il numero di operazioni è proporzionale a n : Ω(n). Caso peggiore: array in ordine inverso il ciclo interno viene sempre eseguito per valori crescenti di i=k: (n-1) = n (n-1)/2 : O(n 2 /2) Scelte multiple: switch Scelte multiple: switch La struttura switch si usa al posto di una situazione in cui ci siano scelte del tipo else if annidate (par ). Esempio. int x, y; cin>>x; if (x == 1) y = 1; else if (x == 2) y = 4; else if (x == 4) y = 16; Scelte multiple: switch Sintassi. Viene valutata una espressione (di tipo intero o carattere: switch(espressione){ case valore1: istruzione1; case valore2: istruzione2; case valore3: istruzione3; } dove valore1, valore2, valore3 sono valori costanti e diversi tra loro. 3

4 Scelte multiple: switch Semantica. Il valore dell espressione viene cercata tra i valori presenti nella case e se viene trovata si esegue l istruzione indicata e tutte le successive. Se si vuole che le istruzioni siano in alternativa, come avviene con l annidamento delle if, si deve utilizzare la parola chiave break. Scelte multiple: switch switch(espressione){ case costante1: istruzione; break; case costante2: istruzione; break; case costante3: istruzione; } Se il valore dell espressione non è presente nelle case, non vi è alcuna segnalazione di errore. Per gestire meglio il caso valore non presente, si può introdurre un default. Scelte multiple: switch int k; cin>>k; switch(k){ case val1: istruzione; break; case val2: istruzione; break; case val3: istruzione; break; default: cout<<"il valore di k" << "non e presente \n"; } Scelte multiple: switch Se non si usa break, l ordine delle case fa variare le operazioni da eseguire. Esempio. cin>>x; switch (x){ case 1: y = 1; case 2: y = 4; case 4: y = 16; } //se x = 1 y = 16 vengono eseguite tutte le assegnazioni su y. Scelte multiple: switch Il valore 1 è dell ultima case: switch (x){ case 4: y = 16; case 2: y = 4; case 1: y = 1; } //se x = 1 y = 1 Questa struttura è utile quando si devono scegliere metodi diversi da eseguire in alternativa, come un menu che propone delle scelte: la lettura del menu è sicuramente più chiara che non l elenco delle varie else if. Ciclo do 4

5 Ciclo do Capita a volte di dover eseguire il corpo di un ciclo almeno una volta, per poi ripeterne l esecuzione se è verificata una particolare condizione. Esempio: leggiamo un valore in ingresso e vogliamo che esso sia positivo: se il valore non è positivo vogliamo poter ripetere la lettura. Ciclo do Sintassi. do { //iterazione } while(condizione); Semantica. L iterazione viene eseguita la prima volta; viene valutata la condizione: se è vera si esegue nuovamente l iterazione, se è falsa il ciclo termina. Ciclo do Ciclo do Equivale a scrivere: iterazione; while(condizione){ iterazione; } oppure boolean continua =true; while(continua){ iterazione; if(!condizione) continua=false; } Esercizio. Calcolare la somma 1 +1./2 + 1./3 + 1./ /n + fino a quando 1./n > t con t valore stabilito (ad esempio t = 10-6 ). Provare a scrivere l algoritmo usando sia il ciclo while che il ciclo do. Una scomposizione di un problema P in sottoproblemi P 1, P 2,, P n si dice ricorsiva se almeno uno dei sottoproblemi è formalmente simile a P e di dimensione inferiore. Esempio. Fattoriale di un numero naturale. Per definizione 0! = 1 (caso base) n! = n * (n-1)! Vediamo che n! viene definito tramite (n-1)! che è un numero più piccolo di n. 5

6 Per capire una definizione ricorsiva, bisogna espanderla : si ricopia la formula sostituendo al posto di n il numero n-1 e si prosegue fino al caso base : n! = n*(n-1)! = n* [(n-1) * (n-2)!] =... = = n*(n-1)*... * (n-n)! Poiché (n-n)! = 0! = 1 per definizione, si ottiene: n! = n*(n-1)*... * 1 Ci chiediamo se è una buona definizione. È una buona definizione perché esiste una dimensione del problema, una condizione, che non necessita di ulteriori scomposizioni; il problema viene risolto direttamente: 0! = 1 il problema per n=0 è risolto senza utilizzo della ricorsione. Possiamo scrivere algoritmi ricorsivi, algoritmi che richiamano se stessi. Il main non può essere ricorsivo: il main è richiamato dal Sistema Operativo. Un generico algoritmo ricorsivo avrà una struttura del tipo: se condizione allora risolvi direttamente altrimenti ricorsione oppure se condizione allora ricorsione In questo caso può esserci o meno una alternativa: se la condizione è falsa non si esegue nulla. Se la ricorsione non termina, si hanno infinite chiamate per l algoritmo e si può occupare tutta la memoria: questo è un errore grave, come quello di costruire un ciclo infinito. La scrittura di un algoritmo ricorsivo è semplice se si sta realizzando una formula matematica come quella del fattoriale: 0! =1, n! = n*(n-1)! Cosa accade veramente? Facciamo uno schema della scomposizione: n! intestazione della funzione fattoriale(n intero) definizione variabili f intero se n==0 allora f 1 altrimenti f n * fattoriale(n-1) //finese restituire f n* (n-1)* (n-1)! (n-2)! * 0! =1 6

7 I vari prodotti n*, (n-1)*, restano sospesi perché il controllo passa al sottoprogramma chiamato. Dopo l ultima chiamata che restituisce 1, si può ritornare indietro ed eseguire i prodotti sospesi. Come può una funzione rimanere sospesa e poi, quando si riattiva, eseguire i prodotti giusti? La funzione ricorsiva avrà una scrittura del tipo: int fattoriale(int n){ int f; if(n == 0) f = 1; else f = n * fattoriale(n-1); return f; }//fine fattoriale ricorsivo Nella funzione appare: n nell intestazione n-1 nella chiamata. Una parte della memoria, RunTimeStack, mantiene le descrizioni delle attivazioni dei sottoprogrammi (funzioni): funzione M main. chiama M. quando si esegue l istruzione di chiamata di una funzione, il controllo passa alla funzione e quando la funzione è terminata, il controllo ritorna al chiamante Con la ricorsione la funzione è sempre la stessa, ma la gestione nel RunTimeStack è analoga: nelle varie copie della funzione sono memorizzati i parametri e le istruzioni di quella chiamata: f f f ritorno chiama f. chiama f. main chiama f.. il PC (contatore di programma) contiene l indirizzo della prossima istruzione da eseguire Che cosa deve essere memorizzato per poter eseguire le operazioni? Si deve memorizzare: quali sono le operazioni da eseguire prima e dopo la chiamata quale è il valore delle variabili a quel livello di chiamata. Vediamo un esempio di questa memorizzazione calcolando ricorsivamente 5! 1 * 0! 2 * 1! 3 * 2! ritorno 1 2*1 = 2 3*2 = 6 Quando un sottoprogramma termina, l area allocata ritorna libera. 4 * 3! 5 * 4! 4*6 = 24 5*24 =120 7

8 Complessità di un algoritmo ricorsivo Il tempo di un algoritmo ricorsivo si ottiene sommando vari tempi: il tempo delle operazioni eseguite nell algoritmo (esclusa la ricorsione) il tempo della chiamata della funzione il tempo dell algoritmo di dimensione inferiore Il tempo delle operazioni della parte non ricorsiva si calcola contando confronti, assegnazioni, cicli: T(n). Complessità di un algoritmo ricorsivo Il tempo per effettuare una chiamata è O(1): infatti si effettua un passaggio di parametri, in chiamata, e il ritorno di un valore, quando il metodo è terminato; questo equivale ad un numero finito di assegnazioni e pertanto è costante. Il tempo dell algoritmo di dimensione inferiore è T(dimensioneinferiore) Complessità di un algoritmo ricorsivo Esempio. Complessità dell algoritmo ricorsivo per il calcolo di n! Sia T(n) il tempo per calcolare n!: possiamo contare il numero di moltiplicazioni, dal momento che questa è l operazione fondamentale: costante se n=0 T(n) = costante + T(n-1) se n>0 Se contiamo solo le moltiplicazioni la prima costante è 0 e la seconda costante è 1. Complessità di un algoritmo ricorsivo Se vogliamo con precisione contare tutte le operazioni avremo: per la prima costante t c + t a + t ritorno per la seconda costante: t c + t prodotto + t chiamata + t a + t ritorno Otteniamo così la formula: T(n) = c + T(n-1) Complessità di un algoritmo ricorsivo Analogamente a quanto fatto con la definizione, espandiamo la formula: T(n) = c + T(n-1) = c + (c + T(n-2)) = 2c + T(n-2) = = 2c + (c + T(n-3)) = 3c + T(n-3) = = 3c + (c + T(n-4)) = 4c + T(n-4) =. = n c + T(n-n) = n c + T(0) = = (n+1) c O(n) e iterazione Avremmo anche potuto calcolare il fattoriale in maniera iterativa; la scomposizione iterativa del fattoriale è diversa: n! Se avessimo contato le moltiplicazioni, avremmo avuto: T(n) = 1 + T(n-1) =. = n + T(0) = n f f*1 f f* f f*n 8

9 e iterazione Anche la scrittura dell algoritmo cambia; possiamo scrivere delle istruzioni del tipo: intestazione della funzione fattiterativo(n intero) definizione variabili f, i intero f 1 per i da 1 a n eseguire f f * i //fineper restituire f e iterazione La complessità non cambia: abbiamo infatti una struttura iterativa che viene eseguita n volte: t a + (n+1) t p + n t a + t ritorno quindi sempre c n operazioni. Il meccanismo della ricorsione Schematizziamo un algoritmo ricorsivo nel modo seguente: algricorsivo(parametri) α se P allora β altrimenti γ chiama algricorsivo(nuoviparametri) δ //finese ritorno //fine algricorsivo Il meccanismo della ricorsione dove α, β, γ, δ sono gruppi di istruzioni, P è il predicato che governa la ricorsione, ritorno indica ritorno al chiamante (ci può essere uno scalare oppure void). Vediamo il funzionamento: α (P vero) β ritorno α (P falso) γ chiama [α (P vero) β ritorno] δ ritorno Supponiamo che P sia falso 3 volte e indichiamo solo le istruzioni α, β,γ, δ Il meccanismo della ricorsione falso falso falso vero ritorno ritorno ritorno α γ α γ αγ α β δ δ δ Le istruzioniδdevono essere eseguite con i valori dei parametri al momento in cui le operazioni αγ hanno effettuato la chiamata: vengono salvati nel RunTimeStack. Dallo schema si vede che una scomposizione ricorsiva si può sempre trasformare in iterativa. Il meccanismo della ricorsione Se l'istruzione δ non c'è, la ricorsione si scioglie facilmente: α (P falso) γ α (P falso)γ α (P falso)γ α (P vero)β e si trasforma nella seguente struttura iterativa dove (non P) è il valore di predicato che effettua la chiamata: α mentre non P eseguire γ costruire nuoviparametri α //finementre β 9

10 Il meccanismo della ricorsione Esempio. Stampare i primi numeri naturali in ordine decrescente: n, n-1, n-2,, 1. algoritmo stamparic( intero n) se n>0 allora stampare n chiamare stamparic(n-1) //finese //fine algoritmo manca δ; l algoritmo è semplice, manca l istruzione α, e manca β pertanto la chiamata è per n>0. Il meccanismo della ricorsione Trasformiamo l algoritmo: la chiamata viene eseguita quando n>0, pertanto questo sarà il predicato del ciclo: mentre n>0 eseguire stampare n n n-1 //costruire nuovi parametri //finementre Esercizio. Stampare i numeri in ordine crescente. Costruire manualmente lo Stack per memorizzare δ. Leonardo da Pisa (detto Fibonacci, ) fu un illustre matematico che si interessò di vari problemi, alcuni dei quali oggi potremmo chiamarli dinamica delle popolazioni, ossia lo studio di come si evolvono le popolazioni. Problema astratto. Consideriamo: un isola deserta: sistema isolato una coppia di conigli genera un altra coppia ogni anno i conigli si riproducono solo dopo due anni dalla loro nascita i conigli sono immortali (n + ) Quante coppie ci sono dopo n anni? Indichiamo con F n il numero di conigli dopo n anni e proviamo a calcolarli a partire dal primo anno: F 1 = 1 coppia iniziale F 2 = 1 la stessa coppia F 3 = = 2 F 1 + la coppia nata da F 1 ( 2 anni) F 4 = = 3 F 3 + la coppia nata da F 2 ( 2 anni) F 5 = = 5 F 4 + le due coppie nate da F 3 ( 2 anni).. In generale si avrà F n = F n-1 + F n-2 dove F n-1 rappresenta le coppie presenti l anno precedente ed F n-2 rappresenta una nuova coppia per ogni coppia di almeno 2 anni. I numeri si calcolano facilmente sommando i valori dei due posti precedenti: n F(n) L algoritmo più immediato da scrivere è quello che ricopia la definizione e pertanto è un algoritmo ricorsivo, che avrà una scrittura del tipo: intestazione funzione fibonacci (n intero) definizione variabili fib intero se n ==1 oppure n ==2 allora fib 1 altrimenti fib fibonacci (n-1) + fibonacci (n-2) //finese restituire fib 10

11 Possiamo rappresentare le chiamate ricorsive con una struttura di albero, come abbiamo fatto con il fattoriale. Un albero è un insieme di punti, detti nodi, a cui è associata una struttura d ordine che gode delle seguenti proprietà: esiste uno ed un solo nodo che precede tutti gli altri, detto radice ogni nodo, esclusa la radice, ha un unico predecessore immediato. Ogni nodo con successore si chiama padre. Ogni nodo con predecessore si chiama figlio. I nodi senza successore si chiamano foglie. L arco che collega un nodo padre a un nodo figlio si chiama ramo. Possiamo rappresentare l albero per n = 5. F 5 F 4 F 3 F 3 F 2 F 2 F 1 F 2 F 1 F 5 è la radice, F 1 e F 2 sono foglie; le foglie non hanno ulteriori chiamate ricorsive e restituiscono il valore 1 e nel ritorno si eseguono le somme. Si può dimostrare che il numero delle foglie dell albero della ricorsione per la costruzione di F n coincide con il valore di F n. Se vogliamo contare le chiamate della funzione, dobbiamo anche aggiungere il numero dei nodi interni, che corrisponde al numero delle chiamate ricorsive. Si può dimostrare che tale numero è uguale al numero delle foglie meno uno. Possiamo concludere che: la complessità dell algoritmo ricorsivo cresce come F(n). Osservando l albero della ricorsione si nota che molti valori F n sono calcolati più volte: nel caso di F 5, F 2 viene calcolato 3 volte. Si possono pertanto memorizzare tali valori in un array e calcolarli una volta sola. Si dovrà però dare una dimensione all array, stabilendo un numero massimo di elementi da calcolare. intestazione funzione fibonacci2 (n intero) definizione variabili fib[nummax], i intero fib[1] 1 fib[2] 1 per i da 3 a n eseguire fib[i] fib[i-1] + fib[i-2] //fineper restituire fib[n] 11

12 Quale complessità ha l algoritmo che utilizza l array? tempo O(n): ciclo che viene eseguito n volte spazio O(n): si utilizza un array di nummax componenti per calcolare F n con n<=nummax Si può scrivere un algoritmo ancora più efficiente. Osserviamo nuovamente il calcolo dei valori F n, ed osserviamo che ad ogni passo si utilizzano solo i valori precedenti, che possono essere salvati in due variabili scalari: F 1 = 1 F 2 = 1 F 3 = F 2 + F 1 F 4 = F 3 + F 2 F 5 = F 4 + F 3 queste somme sono del tipo: f f + valoreprecedente Si ottiene così il seguente algoritmo: intestazione funzione fibonacci3 (n intero) definizione variabili fib, i, prec, prec1 intero prec 1 //F1 fib 1 //F2 per i da 3 a n eseguire prec1 fib //salviamo F 2, prima di fib fib + prec // F 3 = F 2 + F 1 prec prec1 // perché servirà nel //fineper //calcolo di F 4 restituire fib Quale complessità ha l algoritmo che utilizza le sole variabili scalari? tempo spazio O(n): ciclo che viene eseguito n volte O(1): si utilizza un numero costante di locazioni di memoria Per calcolare la complessità dell algoritmo ricorsivo dobbiamo capire come il valore di F(n) cresce, andando all infinito. Possiamo stimare il valore utilizzando un algoritmo numerico. Si cerca una funzione che soddisfi la relazione di ricorrenza F n = F n-1 + F n-2 e si prova con a n, a 0; l equazione diventa: a n = a n-1 + a n-2 da cui raccogliendo a n-2 si ottiene: a n-2 ( a 2 a 1) = 0 Poiché a 0 cerchiamo le soluzioni dell equazione ( a 2 a 1) = 0 e troviamo le due radici reali: φ = (1 + 5 ) / 2 ~ φ = (1-5 ) / 2 ~ φ è la sezione aurea. Si può dimostrare che F n = (φ n -φ n ) / 5 12

13 Esiste quindi un algoritmo numerico con il quale calcolare il numero F n. Però tale algoritmo non può essere preciso, dal momento che F n è un numero naturale e la radice di 5 è un numero irrazionale: quindi una qualunque applicazione di tale algoritmo fornisce solo una approssimazione. La complessità di tempo e di spazio è O(1). Utilizziamo la formula F n = (φ n -φ n ) / 5 per stimare come F(n) + L algoritmo ricorsivo ha complessità momento che: φ < 1 si ha che φ n 0 O(F n ); dal 1< φ < 2 si ha che φ n < 2 n e pertanto l algoritmo cresce in maniera esponenziale con limitazione superiore 2 n : tempo O(2 n ). F 4 F 3 F 3 F 2 F 2 F 1 F 2 F 1 F 5 La torre di Hanoi La leggenda narra che dei sacerdoti di un tempio di Brahma lavorino per spostare una pila di 64 dischi d oro da un piolo ad un altro, utilizzandone uno di appoggio e seguendo delle regole; alla fine del lavoro ci sarà la fine del mondo (par. 8.2). La complessità di spazio è O(n); infatti le chiamate ricorsive si espandono in profondità, non sono contemporanee: F 5, F 4, F 3, F 2, ritorno, F 1, ritorno F 2, calcola F 3, ritorno, A B C La torre di Hanoi La configurazione finale dovrà essere: A B C La torre di Hanoi La regola è la seguente: si può spostare un solo disco alla volta non si può mettere un disco grande su uno piccolo. La soluzione più intuitiva è quella ricorsiva: se spostiamo la pila di n-1 dischi da A a B, possiamo muovere il primo disco da A a C e poi spostare la pila di n-1 dischi da B a C. Indichiamo con H(n, A, B,C) il problema di Hanoi di dimensione n. 13

14 La torre di Hanoi La torre di Hanoi La scomposizione ricorsiva sarà perciò: H(n-1, A, C, B) H(1, A, B, C) //muove un disco H(n-1, B, A, C) Possiamo scrivere le chiamate ricorsive nel caso n=3. Applichiamo l espansione della formula ricorsiva e vediamo come si muovono i dischi. H(3,A,B,C) H(2,A,C,B) H(1,A,B,C) H(2,B,A,C) H(1,A,B,C) H(1,A,C,B) H(1,C,A,B) H(1,B,C,A) H(1,B,A,C) H(1,A,B,C) La torre di Hanoi Complessità. Quanti sono gli spostamenti ei dischi? Per spostare un disco da un piolo ad un altro, ed ottenere la stessa configurazione, si deve spostare 2 volte la pila di dischi che gli sta sopra; quindi ogni disco si muove un numero di volte che è doppio rispetto al disco che gli sta immediatamente sotto. Contiamo gli spostamenti a partire dal primo: La torre di Hanoi disco 1 1 spostamento *2 = 4 = *4 = 8 = *8 = 16 = 2 4 n 2 n-1 sommiamo gli spostamenti n-1 = 2 n -1 quindi O(2 n ) l algoritmo è esponenziale La torre di Hanoi Si può anche scrivere un algoritmo iterativo, che rimane esponenziale, osservando il movimento dei dischi: disco1 A C disco2 A B C disco3 A C B A C I dischi pari percorrono ciclicamente in ordine alfabetico i pioli, i dischi dispari li percorrono in ordine inverso. 14