Algoritmi e Strutture Dati Università di Camerino Corso di Laurea in Informatica (12 CFU) I periodo didattico Emanuela Merelli

Presentazione sul tema: "Algoritmi e Strutture Dati Università di Camerino Corso di Laurea in Informatica (12 CFU) I periodo didattico Emanuela Merelli"— Transcript della presentazione:

1 Algoritmi e Strutture Dati Università di Camerino Corso di Laurea in Informatica (12 CFU) I periodo didattico Emanuela Merelli email:emanuela.merelli@unicam.it

2 Lezione 3 Tecniche di Progettazione Argomento : Divide et Impera Obiettivo conoscitivo :

3 Tecniche Algoritmiche: Divide et Impera

4 Tecniche di progettazione di algoritmi Approccio Incrementale –Insertion sort: Se è ordinato A[1..j-1] si inserisce A[j]... Approccio Divide et impera –Merge sort: divido il problema in n sottoproblemi e opero ricorsivamente sugli n problemi Programmazione Dinamica –…–…

5 Divide-et-impera Un algoritmo si dice ricorsivo se al suo interno (tra i suoi comandi) sono presenti chiamate a se stesso per gestire sottoproblemi analoghi a quello dato L’approccio seguito dagli algoritmi ricorsivi è quello di suddividere il problema dato in sottoproblemi simile a quello di partenza ma di dimensione inferiore Quindi, una volta che i sottoproblemi sono stati risolti ricorsivamente, combinare le soluzioni trovate per creare la soluzione al problema dato Divide Impera Combina

6 Divide et Impera Divide et impera: –Divide: Se l’istanza del problema da risolvere è troppo “complicata” per essere risolta direttamente, dividila in due o più “parti” –Risolvi ricorsivamente: Usa la stessa tecnica divide et impera per risolvere le singole parti (sottoproblemi) –Combina: Combina le soluzioni trovate per i sottoproblemi in una soluzione per il problema originario.

7 MergeSort: Algoritmo Dividi: se S contiene almeno due elementi (un solo elemento è banalmente già ordinato), rimuovi tutti gli elementi da S e inseriscili in due vettori, S 1 e S 2, ognuno dei quali contiene circa la metà degli elementi di S. (S 1 contiene i primi n/2 elementi e S 2 contiene i rimanenti n/2 elementi). Risolvi ricorsivamente: ordina gli elementi in S 1 e S 2 usando MergeSort (ricorsione). Combina: fondi gli elementi di S 1 e S 2 ottenendo un unico vettore S ordinato (merge)

8 Mergesort: esempio 2 24 36 10 87 83 21 39 58 24 36 10 87 24 36 2436 10 87 10 24 36 8783 21 39 5821 39 58 83 10 21 24 36 39 58 83 87 10 8724 36 2436

9 Merge Sort: Algoritmo Merge-sort(A,p,r) if p < r then q= └ (p+r)/2 ┘ Merge-sort(A,p,q) Merge-sort(A,q+1,r) Merge(A,p,q,r) Rimuovi il più piccolo dei due elementi affioranti in A[p..q] e A[q+1..r] e inseriscilo nel vettore in costruzione. Continua fino a che i due vettori sono svuotati. Copia il risultato in A[p..r].

10 Esempio 1 A = 1 2 2 3 4 5 6 6 1 2 3 62 4 5 6 2 54 61 32 6 46132652 Sequenza iniziale fusione

11 Merge 122736384754 123253268961 1 12 23 … e così via

12 Ricorrenze Quando un algoritmo contiene una chiamata ricorsiva a se stesso, il suo tempo di esecuzione può spesso essere descritto da una equazione di ricorrenza o ricorrenza. Una ricorrenza è una equazione o una disequazione che descrive una funzione in termini del suo valore su input sempre più piccoli. Un'equazione ricorsiva esprime il valore di f(n) come combinazione di f(n 1 ),...,f(n k ) dove n i < n, i=1..k.

13 Equazioni ricorsive Indichiamo con T(n) il tempo di esecuzione di un problema di dimensione n. E con  (1) un tempo costante Suddividiamo un problema in a sottoproblemi, ciascuno dei quali ha una dimensione 1/b rispetto al problema principale e supponiamo di impiegare un tempo D(n) per suddividere e un tempo C(n) per combinare le soluzioni dei sottoproblemi. Si ottiene la seguente ricorrenza: T(n) =  ( 1) se n < c aT(n/b) + D(n) + C(n) se n > c

14 Esempio del Merge Sort Dove: Divide in un tempo  (1) Impera in 2T(n/2) Combina in  (n) T(n) =  ( 1) se n=1 2T(n/2) +  (n) se n > 1

15 Equazioni ricorsive: un esempio semplice T(n) = 1 se n = 1 T(n/2) + 1 se n > 1 Come si risolve ???

16 Metodo iterativo T(n) = T(n/2) + 1 T(n/4) + 1 + 1 T(n/8)+1 + 1 + 1 T(n/n)+1......................... + 1..................... 1 + 1......................... + 1 k Ci fermiamo quando 2 k =n k chiamate ricorsive

17 Dobbiamo valutare k sappiamo che 2 k = n, quindi log 2 ( 2 k ) = log 2 (n), ovvero k = log 2 (n)

18 Induzione Dobbiamo dimostrare che una affermazione è vera per ogni n≥0 Teorema. se 1.affermazione(0) è vera. 2.affermazione(n-1) vera implica affermazione(n) vera. Allora affermazione(n) vera per ogni n ≥ 0

19 Dimostrazione per induzione: esempio  n i=1 i = n(n+1)/2 affermazione(n) =  1 i=1 i = 1(1+1)/2 = 1 OK affermazione(1) = affermazione(n-1) ----> affermazione(n):  n-1 i=1 i = (n-1)(n)/2  n i=1 i = n(n+1)/2---->

20 Dimostrazione per induzione: esempio  n i=1 i =...ma  n-1 i=1 i + n = (n-1)(n)/2 + n = n(n+1)/2 L’uguaglianza tra questi due termini non è altro che affermazione(n-1) e quindi la assumiamo vera per ipotesi induttiva.

21 Metodo di sostituzione Primo passo: Tentiamo di “indovinare” una possibile soluzione: T(n) ≤ clog 2 (n) Secondo passo: la verifichiamo per induzione come segue: Assumiamo che T(n’) ≤ clog 2 (n’) per n’ < n e dimostriamo che T(n) ≤ clog 2 (n) c è una costante (indipendente da n) che determineremo strada facendo…

22 T(n) = T(n/2) + 1 ≤ clog 2 (n/2) + 1 = clog 2 (n) - clog 2 (2) + 1 = clog 2 (n) - c + 1 se c ≥ 1 allora ≤ clog 2 (n) Ipotesi induttiva !!! 

23 Equazioni ricorsive: un esempio più complicato T(n) =  (1) se n = 1 2T(n/2) +  (n) se n > 1 Soluzione T(n) =  (n log(n))

24 Albero di ricorsione Cn + 2T(n/2) C(n/2) + 2T(n/4) C(n/4) + 2T(n/8) = c n = c n + …… + = n(log(n))  (1) …… = c n Il fattore log(n) deriva dal fatto che l’albero ha un altezza log(n)

25 “Master Method o Metodo dell’esperto” T(n) = aT(n/b) + f(n) a  1, b > 1, f(n) > 0 Poniamo x = log b a f(n) = O(n x-  ) con  >0 allora T(n) =  (n x ) f(n) =  (n x ) allora T(n) =  (n x log(n)) f(n) =  (n x+  ) con  >0 af(n/b) ≤ cf(n) con c n 0

26 … Merge sort T(n) =  (n log(n)) Insertion sortMerge sort Worst case Average case Best case  (n 2 )  (n log(n))  (n)  (n log(n))

27 Perchè ordinare è importante... velocizza molto la ricerca !!! Binary-search(A,x) i=0 j=length(A)-1 while i<j do k=  (i+j)/2  if A[k]=x then return true if A[k]>x then j=k-1 if A[k]<x then i=k+1 if A[i]=x then return true else return false

28 Analisi di Binary search D(t)=j-i al tempo t D(0) = n-1......... D(t+1) = D(t)/2 Usciamo dal while quando D(t)<2...... ovvero se t ≥ log 2 n. Quindi T(n) =  (log 2 n)

29 Priority Queue (Code a Priorità) Dati: un insieme di elementi, ognuno dei quali ha una chiave (un intero per esempio). Operazioni: inserimento, trova il massimo, estrazione del massimo (massima chiave). Applicazioni delle PQ: Job scheduling Event-driven simulations

30 Implementazione (facile) usando vettori Prima soluzione: vettore ordinato. Ricerca massimo:  (1) operazioni estrazione massimo:  (1) operazioni inserimento:  (n) operazioni Seconda soluzione vettore non ordinato. Ricerca massimo:  (n) operazioni estrazione massimo:  (n) operazioni inserimento:  (1) operazioni Si può fare meglio ???

31 Grafi e Alberi G=(V,E) V={1,2,3,4,5,6,7,8} E={(1,2),(1,3),(1,4),(3,4),(6,7),(7,8)} 1 4 2 3 5 6 7 8 {1,3,4,1} è un ciclo Un grafo senza cicli è aciclico

32 Un albero è un grafo aciclico con un numero di nodi uguale al numero di archi più uno ( |E|=|V|-1 ) 1 4 2 3 5 6 7 8 Albero 1 4 2 3 5 6 7 8 Foresta

33 r x qy w Radice r è la radice x è il padre di y y è un figlio di x x e q sono avi di w w e q sono discendenti di x q è fratello di y Foglie h(a) altezza del nodo a: h(x)=1 h(y)=h(q)=2 h(w)=3