Ricorsione. Moreno Marzolla Dipartimento di Informatica Scienza e Ingegneria (DISI) Università di Bologna

Transcript

1 Moreno Marzolla Dipartimento di Informatica Scienza e Ingegneria (DISI) Università di Bologna

2 2

3 Definizione informale: la ricorsione è un procedimento mediante il quale si definisce una entità in termini di se stessa 3

4 in natura broccolo romanesco 4

5 Triangolo di Sierpinski By Beojan Stanislaus, CC BY-SA 3.0, 5

6 nelle arti visive Immagine sulla confezione del cacao Droste (anno 1904); fonte Wikipedia Copertina dell'album Ummagumma dei Pink Floyd (anno 1969); fonte Wikipedia 6

7 in FINFA

8 Definizione ricorsiva in matematica: Definizione di un concetto usando il concetto stesso Definizione ricorsiva in C: Una funzione che invoca (direttamente o indirettamente) se stessa 8

9 Esempio: successione di Fibonacci Modello (non realistico) di crescita di una popolazione di conigli Una coppia all'inizio del primo mese A partire dal termine del secondo mese di vita, ogni coppia produce un'altra coppia alla fine di ogni mese I conigli non muoiono mai (!) F(n) = coppie al termine del mese n F(1) = 1 F(2) = 1 F(n) = F(n 1) + F(n 2) per ogni n > 2 Leonardo Fibonacci (Pisa, 1170 Pisa, ca. 1250) 9

10 I conigli di Fibonacci

11 Numeri di Fibonacci in natura Il numero di spirali orarie e antiorarie nei fiori di girasole, nelle pigne e in altri vegetali (es., ananas) tendono ad assumere valori appartenenti alla successione di Fibonacci 11

12 Fibonacci in C Metodo ricorsivo per il calcolo della successione di Fibonacci F(1) = 1 F(2) = 1 F(n) = F(n 1) + F(n 2) per ogni n > 2 int fib(int n) if (n <= 2) else return fib(n - 1) + fib(n 2); 12

13 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 13

14 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; Ret int main( void ) printf("%d\n", fib(3)); return 0; 14

15 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; n 3 Ret int main( void ) printf("%d\n", fib(3)); return 0; 15

16 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; n 3 Ret int main( void ) printf("%d\n", fib(3)); return 0; 16

17 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; n1 n?? 3 Ret int main( void ) printf("%d\n", fib(3)); return 0; 17

18 Esempio di esecuzione #include <stdio.h> n1 n Ret?? 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 18

19 Esempio di esecuzione #include <stdio.h> n n1 n 2 Ret?? 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 19

20 Esempio di esecuzione #include <stdio.h> n n1 n 2 Ret?? 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 20

21 Esempio di esecuzione #include <stdio.h> n n1 n 2 Ret?? 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 21

22 Esempio di esecuzione #include <stdio.h> n1 n 1?? 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 22

23 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; n1 n 1 3 Ret int main( void ) printf("%d\n", fib(3)); return 0; 23

24 Esempio di esecuzione #include <stdio.h> n2 n1 n?? 1 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 24

25 Esempio di esecuzione #include <stdio.h> n2 n1 n Ret?? 1 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 25

26 Esempio di esecuzione #include <stdio.h> n n2 n1 n 1 Ret?? 1 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 26

27 Esempio di esecuzione #include <stdio.h> n n2 n1 n 1 Ret?? 1 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 27

28 Esempio di esecuzione #include <stdio.h> n n2 n1 n 1 Ret?? 1 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 28

29 Esempio di esecuzione #include <stdio.h> n2 n1 n 1?? 1 3 Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 29

30 Esempio di esecuzione #include <stdio.h> n2 n1 n Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 30

31 Esempio di esecuzione #include <stdio.h> n2 n1 n Ret int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; int main( void ) printf("%d\n", fib(3)); return 0; 31

32 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; 2 int main( void ) printf("%d\n", fib(3)); return 0; 32

33 Esempio di esecuzione #include <stdio.h> int fib(int n) if (n <= 2) else int n1 = fib(n-1); int n2 = fib(n-2); return n1 + n2; 0 int main( void ) printf("%d\n", fib(3)); return 0; 33

34 Albero delle chiamate ricorsive fib(6) fib(5) fib(4) fib(3) fib(2) fib(2) fib(4) fib(3) fib(2) fib(1) fib(3) fib(2) fib(2) fib(1) fib(1) 34

35 Costo computazionale Sia T(n) il numero di chiamate chiamate alla funzione fib() che servono per calcolare fib(n) 1 chiamata per fib(1) T(1) = 1 1 chiamata per fib(2) T(2) = 1 3 chiamate per fib(3) T(3) = 3 5 chiamate per fib(4) T(4) = 5 T(n) = T(n - 1) + T(n - 2) + 1 fib(3) fib(2) fib(4) fib(3) fib(2) fib(1) fib(2) fib(1) 35

36 Quanto è grande T(n)? Calcoliamo un limite inferiore per T(n) Sfruttiamo il fatto che T(n) è non decrescente, cioè T(n) T(n-1) T (n) = T (n 1)+T (n 2)+1 2 T (n 2)+1 4 T (n 4) T (n 6) k 1 k 2 T (n 2 k )+ 2 i i=0... n/2 n/ n/2 2 36

37 Albero della ricorsione La funzione fib(n) richiede un numero di chiamate ricorsive almeno esponenziale di n La sua inefficienza deriva dal fatto che ricalcola più volte gli stessi valori fib(6) fib(5) fib(4) fib(3) fib(2) fib(2) fib(1) fib(4) fib(3) fib(2) fib(1) fib(3) fib(2) fib(2) fib(1) 37

38 Versione iterativa di fib(n) Possiamo riscrivere fib(n) in forma iterativa, ottenendo una versione molto più efficiente Non è sempre così: le funzioni ricorsive non diventano automaticamente più efficienti se riscritte in modo iterativo int fib(int n) if (n <= 2) else int i, fn; int fn1=1, fn2=1; for (i=3; i<=n; i++) fn = fn1 + fn2; fn2 = fn1; fn1 = fn; return fn; 38

39 Versione iterativa di fib(n) fn2 fn1 fn 1 1 i= i= i= i= int fib(int n) if (n <= 2) else int i, fn; int fn1=1, fn2=1; for (i=3; i<=n; i++) fn = fn1 + fn2; fn2 = fn1; fn1 = fn; return fn; 39

40 La differenza tra un algoritmo di costo Fibonacci ricorsivo Intel 2015 A.D. Fibonacci iterativo Commodore 1982 A.D. fib(10) 0.001s 0.066s fib(20) 0.001s 0.150s fib(30) 0.013s 0.233s fib(50) s 0.400s 40

41 Fattoriale Metodo ricorsivo per il calcolo del fattoriale 0! = 1 n! = n (n 1)! per ogni n > 0 int fatt(int n) if (n == 0) else return n * fatt(n 1); 41

42 Elevamento a potenza potenza(a,n) calcola an per a > 0, n 0 potenza(a, 0) = 1 potenza(a, n) = a potenza(a, n-1), se n > 0 double potenza(double a, int n) if (n == 0) return 1.0; else return a * potenza(a, n-1); Esercizio per casa: scrivere una versione di potenza() che funzioni anche quando n < 0 42

43 Una funzione ricorsiva corretta ha le caratteristiche seguenti Include uno o più casi base, in cui il valore della funzione viene calcolato senza invocare la funzione Include una o più invocazioni ricorsive della funzione; nelle chiamate ricorsive generalmente si usano parametri che "avvicinano" ai casi base 43

44 Attenzione La ricorsione deve terminare Per la successione di Fibonacci, la ricorsione termina nei casi base fib(1) e fib(2) Per il fattoriale, il caso base è fatt(0) Per l'elevamento a potenza, il caso base è potenza(a,0) Ogni chiamata dovrebbe avvicinare al caso base Attenzione, però... /* Per quali valori di n la funzione seguente termina? */ int fun(int n) if ( n == 0 ) else return (n + fun(n-2)); 44

45 Le torri di Hanoi Narra la leggenda che in un tempio indiano si trovi una stanza contenente una lastra di bronzo con sopra tre pioli di diamante. Dopo la creazione dell'universo, 64 dischi d'oro sono stati infilati in uno dei pioli in ordine decrescente di diametro, con il disco più largo appoggiato al piano di bronzo. Da allora, i monaci del tempio si alternano per spostare i dischi dal piolo originario ad un altro piolo, seguendo le rigide regole di Brahma: i dischi vanno maneggiati uno alla volta, e non si deve mai verificare che un disco più largo sovrasti uno più piccolo sullo stesso piolo. Quando tutti i dischi saranno spostati su un altro piolo, l'universo avrà fine. Fonte: George Gamow, One, two, tree... infinity!, Dover Publications,

46 Le torri di Hanoi Gioco matematico tre pioli n dischi di dimensioni diverse Inizialmente tutti i dischi sono impilati in ordine decrescente (più piccolo in alto) nel piolo di sinistra Scopo del gioco Impilare in ordine decrescente i dischi sul piolo di destra Senza mai impilare un disco più grande su uno più piccolo Muovendo un disco alla volta Utilizzando se serve anche il piolo centrale 46

47 src tmp dst Idea Per spostare n dischi dal piolo src al piolo dst, usando tmp come appoggio Se c'è un solo disco Spostalo da src a dst Se ci sono n dischi Sposta gli n - 1 dischi in cima a src verso tmp, usando dst come appoggio Sposta un disco da src a dst Sposta n - 1 dischi in cima a tmp verso dst, usando src come appoggio 47

48 Soluzione ricorsiva per le torri di Hanoi /* hanoi.c */ void hanoi(int src, int dst, int tmp, int n) if (n == 1) printf("muovi da %d a %d\n", src, dst); else hanoi(src, tmp, dst, n-1) printf("muovi da %d a %d\n", src, dst); hanoi(tmp, dst, src, n-1) hanoi(1,3,2,n) sposta n dischi dal piolo 1 al piolo 3, usando il piolo 2 come appoggio n - 1 dischi da src a tmp 1 disco da src a dst n - 1 dischi da tmp a dst 48

49 1 2 3 Esempio con 3 dischi 3 dischi da 1 a 3 2 dischi da 1 a 2 1 disco da 1 a dischi da 2 a 3 1 disco da 3 a disco da 2 a disco da 1 a

50 Numero di chiamate ricorsive void hanoi(int src, int dst, int tmp, int n) if (n == 1) printf("muovi da %d a %d\n", src, dst); else hanoi(src, tmp, dst, n-1) printf("muovi da %d a %d\n", src, dst); hanoi(tmp, dst, src, n-1) Quanti spostamenti sono necessari per risolvere il problema con n dischi? T(1) = 1 T(n) = 2 T(n 1) + 1 per n > 1 Domanda: Quale è la soluzione della ricorrenza? Se i monaci eseguissero una mossa al secondo, per trasferire tutti i 64 dischi servirebbe un tempo pari a circa 127 volte l'età del nostro sole 50

51 Ricerca binaria ricorsiva /* ricerca-binaria-ric.c : versione ricorsiva della ricerca binaria */ #include <stdio.h> int ricbinaria_ric(int v[], int i, int f, int k) if ( i > f ) return -1; /* non trovato */ else int m = (i + f) / 2; if (v[m] == k) return m; /* trovato in posizione m */ else if (v[m] > k) return ricbinaria_ric(v, i, m-1, k); else return ricbinaria_ric(v, m + 1, f, k); int ricbinaria(int v[], int n, int k) return ricbinaria_ric(v, 0, n-1, k); 51

52 mutua (indiretta) Una funzione f1 ne chiama un'altra f2 (che ne chiama un'altra f3 ) che chiama f1 Es.: definiamo, usando la ricorsione mutua, due funzioni pari e dispari che accettano un intero positivo n e ritornano 1 se n è pari (risp. dispari), 0 altrimenti Idea: pari(n) = dispari(n - 1) dispari(n) = pari(n - 1) Base della ricorsione: pari(0) = 1 dispari(0) = 0 52

53 /* pari-dispari.c : determina se un numero e' pari o dispari usando due funzioni mutuamente ricorsive */ #include <stdio.h> /* Dichiarazione delle funzioni pari e dispari */ int pari(int n); int dispari(int n); /* Definizione delle funzioni pari e dispari */ int pari(int n) if (n == 0) else return dispari(n 1); int dispari(int n) if (n == 0) return 0; else return pari(n 1); int main( void ) int i; for (i=0; i<10; i++) printf("%d pari=%d dispari=%d\n", i, pari(i), dispari(i)); return 0; 53