Sistemi e Tecnologie Informatiche Complessità di calcolo.

Presentazione sul tema: "Sistemi e Tecnologie Informatiche Complessità di calcolo."— Transcript della presentazione:

1 Sistemi e Tecnologie Informatiche Complessità di calcolo

2 #include int main(void) { int numero1 = 5; int numero2 = 0; if (numero1==numero2) printf(“I due numeri coincidono\n"); return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 #include int main(void) { int numero1 = 5; int numero2 = 0; int numero3 = 8; int numero4 = 12; printf(“La somma dei numeri è %d\n", numero1+numero2+numero3+numero4); printf(“Il prodotto dei numeri è %d\n", numero1*numero2*numero3*numero4); return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

3 #include int main(void){ printf(“I primi 10000 numeri naturali sono: \n"); for(int i=0;i<10000;i++) printf(“%d “, i); } 1 2 3 4 5 6 7 8 9 10 11 12 #include int main(void) { int numero1 = 5; int numero2 = 0; int numero3 = 8; int numero4 = 12; printf(“La somma dei numeri è %d\n", numero1+numero2+numero3+numero4); printf(“Il prodotto dei numeri è %d\n", numero1*numero2*numero3*numero4); return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

4 In questa lezione impareremo che … La nozione di efficienza è fondamentale ai fini della valutazione di un algoritmo Esistono due valutazioni di efficienza: Tempo di calcolo Quantità di memoria necessaria E’ possibile valutare l’efficienza di un algoritmo ( … e di un programma) attraverso l’analisi della complessità

5 Intuitivamente … Un algoritmo (programma) si può definire “efficiente” se richiede “poche” risorse di calcolo Un algoritmo si può definire ottimale per la risoluzione di un problema se, tra tutti gli algoritmi esistenti, è quello che risolve il problema in modo più efficiente

6 Intuitivamente … Le due principali caratteristiche per la valutazione dell’efficienza di un algoritmo sono: il tempo totale di esecuzione la quantità totale di memoria necessaria all’esecuzione

7 Misuriamo l’efficienza di un algoritmo Implementiamolo Scegliamo dei dati in input Armiamoci di cronometro Eseguiamo il programma su un calcolatore e misuriamo il tempo totale di esecuzione “Se il programma ha richiesto poco tempo è efficiente, se richiede molto tempo è inefficiente”

8 Confrontiamo l’efficienza di algoritmi diversi Implementiamo un secondo algoritmo Scegliamo dei dati in input Ricicliamo il cronometro del test precedente Eseguiamo il nuovo programma su un calcolatore e misuriamo il tempo totale di esecuzione “Se l’implementazione del secondo algoritmo ha richiesto meno tempo del precedente è più efficiente, diversamente è meno efficiente”

9 Misuriamo l’efficienza di un algoritmo L’approccio appena proposto è palesemente scorretto! Esso non tiene conto del fatto che i tempi di esecuzione di un programma sono influenzati: Dal compilatore utilizzato per tradurre in programma il codice sorgente dell’algoritmo Dal calcolatore utilizzato per l’esecuzione del programma Dalla significatività dei dati in input … e da una miriade di altri fattori!

10 Misuriamo l’efficienza di un algoritmo Un approccio più rigoroso potrebbe quindi consistere nel : Selezionare un insieme di dati di input significativi Utilizzare lo stesso compilatore per tutti i programmi Utilizzare lo stesso calcolatore per tutti i test ed infine Eseguire gli stessi test per tutti i programmi

11 Misuriamo l’efficienza di un algoritmo Il tempo di esecuzione di un algoritmo non è spesso una misura affidabile dell’efficienza di un algoritmo Le misurazioni operate, seppure rigorose, sono poco generalizzabili E’ preferibile un tipo di valutazione più astratto che, senza entrare nel merito di compilatori e calcolatori, sappia stimare la quantità complessiva di lavoro richiesta da un algoritmo per risolvere un certo problema

12 Misuriamo l’efficienza di un algoritmo La quantità di lavoro richiesta per l’esecuzione di un algoritmo può essere descritta come l’insieme di istruzioni che esso esegue Più istruzioni ci sono, più i tempi di esecuzione si allungano L’algoritmo ottimale è quello che richiede l’esecuzione di meno istruzioni Per valutare l’insieme di istruzioni eseguito da un algoritmo ne scorriamo il codice e “contiamo” una ad una le istruzioni che saranno eseguite

13 Un primo esempio … #include int main(void) { int numero1 = 5; int numero2 = 0; if (numero1==numero2) printf(“I due numeri coincidono\n"); return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 1234512345 Totale istruzioni: 5 #include int main(void) { int numero1 = 5; int numero2 = 0; int numero3 = 8; int numero4 = 12; printf(“La somma dei numeri è %d\n", numero1+numero2+numero3+numero4); printf(“Il prodotto dei numeri è %d\n", numero1*numero2*numero3*numero4); return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 12345671234567 Totale istruzioni: 7

14 Un esempio più complesso! #include int main(void){ int ultimo_numero, penultimo_numero, int i, conta_numeri; i=1; conta_numeri=0; scanf("%d", &penultimo_numero); while(i<=9) { scanf("%d", &ultimo_numero); if( penultimo_numero<ultimo_numero ) conta_numeri++; penultimo_numero=ultimo_numero; i++; } printf("%d\n", conta_numeri); return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

15 Regole per la misurazione dell’efficienza di un algoritmo 1. Il costo di esecuzione di una istruzione semplice è 1 2. Il costo di esecuzione di un ciclo (while,for) è dato dalla somma del costo totale di esecuzione della condizione di test e dalla somma del costo totale di esecuzione del corpo del ciclo int numero1 = 5; int numero2 = 0; numero1 = numero2+1; for (int i = 0; i < 5; i++) { numero1 = numero1+1; numero2 = numero2+1; } 111111 5x1 5x(1+1)

16 Regole per la misurazione dell’efficienza di un algoritmo 1. Il costo di esecuzione di una istruzione condizionale (if) è dato dal costo di esecuzione del test più il costo di esecuzione dell’istruzione eseguita nel caso la condizione sia vera 2. Il costo di esecuzione di una funzione è pari al costo di esecuzione di tutte le istruzioni che la compongono if (numero1 > 0) printf(“Numero positivo”); 1111 void positivo(int numero1) { if (numero1 > 0) printf(“Numero positivo”); } 1111

17 Un esempio più complesso! #include int main(void){ int ultimo_numero, penultimo_numero, int i, conta_numeri; i=1; conta_numeri=0; scanf("%d", &penultimo_numero); while(i<=9) { scanf("%d", &ultimo_numero); if( penultimo_numero<ultimo_numero ) conta_numeri++; penultimo_numero=ultimo_numero; i++; } printf("%d\n", conta_numeri); return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

18 Ancora più complesso! int PosizioneElemento(int Voti[], int elem, int n) /* Effettua la ricerca esaustiva di elem tra i primi n elementi di Voti. Il valore di ritorno e` -1 se elem non e` presente in Voti, altrimenti e` l'indice della posizione di elem. */ { int i = 0; // Verifichiamo se la fine dell’elenco è stata raggiunta // o se l’elemento corrente coincide con quello cercato while ( i<n-1 && Voti[i] != elem) i++; // Consideriamo il prossimo elemento if (Voti[i] == elem) return i; // L’elemento è stato individuato else return -1; // L’elemento non è presente } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Non conosciamo a priori la taglia dei dati in input (e.g., il numero dei voti tra cui cercare l’elemento) E’ ancora possibile calcolare il costo di esecuzione dell’algoritmo anche se questo sarà espresso in funzione della taglia dell’input (n) Nel caso in esame 1 + 2n + 2 = 3 + 2n

19 Nota Non è sempre possibile conoscere a priori quali e quante istruzioni un programma eseguirà dal momento che il suo comportamento è condizionato dai dati in input che utilizziamo Esistono quindi dati di input per i quali l’esecuzione si arresta subito, e dati di input per i quali l’esecuzione può richiedere molto tempo Nella valutazione dell’efficienza di un algoritmo si è spesso interessati a sapere come si comporta lo stesso: nel caso migliore, considerando i dati di input che minimizzano il numero di istruzioni da eseguire nel caso peggiore, considerando i dati di input che massimizzano il numero di istruzioni da eseguire

20 Complessità Dato un algoritmo, quando non è possibile conoscere in partenza il tipo di input che si elabora, si procede con la valutazione del caso peggiore Valuteremo perciò il costo di esecuzione di un programma come: il conteggio delle istruzioni che esso esegue in funzione della dimensione dell’input con riferimento al caso peggiore

21 Valutazione di costo int PosizioneElemento(int Voti[], int elem, int n) /* Effettua la ricerca esaustiva di elem tra i primi n elementi di Voti. Il valore di ritorno e` -1 se elem non e` presente in Voti, altrimenti e` l'indice della posizione di elem. */ { int i = 0; // Verifichiamo se la fine dell’elenco è stata raggiunta // o se l’elemento corrente coincide con quello cercato while ( i<n-1 && Voti[i] != elem) i++; // Consideriamo il prossimo elemento if (Voti[i] == elem) return i; // L’elemento è stato individuato else return -1; // L’elemento non è presente } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Caso migliore (i.e., troviamo subito l’elemento): f(n) = 4 Caso peggiore (i.e., l’elemento non è presente) f(n) = 1 + 2n +2 = 3 + 2n

22 Confrontare due algoritmi Come è possibile trarre vantaggio dalla conoscenza del costo (complessità) di due algoritmi per decidere quali dei due è migliore? E.g. A e B sono algoritmi di ordinamento di elenchi, sia n la taglia dell’elenco di input L’algoritmo A esegue 350 + 2n istruzioni L’algoritmo B esegue 100 + 3n istruzioni L’algoritmo C esegue 6 + 2n 2 istruzioni 350 + 2n (A) > 100 + 3n (B)

23 In sintesi … Le tecniche di analisi del costo di esecuzione di un algoritmo introdotte: operano delle assunzioni esemplificative (e.g., tutte le istruzioni semplici hanno lo stesso costo di esecuzione) determinano esattamente il numero complessivo di istruzioni da eseguire in corrispondenza di un determinato input L’analisi di algoritmi particolarmente complessi può rivelarsi tuttavia difficoltosa per via dell’eccessiva lunghezza ed ingestibilità dell’equazione risultante In questi casi siamo interessati ad ottenere una stima approssimata che sia più facile da gestire