Modelli di Calcolo & Metodologie di Analisi

Transcript

1 Modelli di Calcolo & Metodologie di Analisi

2 Modelli di Calcolo (1/4) Turing Machine (Alan Turing, 1936): S a b b a Nastro infinito bidirezionale Ogni cella può contenere un simbolo di un certo alfabeto finito Passo computazionale: lettura/scrittura di una cella, spostamento della testina, variazione dello stato Modello di riferimento nello studio della calcolabilità e della complessità computazionale

3 Modelli di Calcolo (2/4) Random Access Machine (1963): Nastro di input ACC R1 R2 R3 Programma R4 R5 PC Nastro di output Ogni registro/cella può contenere un intero grande a piacere Passo computazionale: operazione di I/O, operazione logico-aritmetica, lettura/scrittura in memoria

4 Modelli di Calcolo (3/4) La Random Access Machine (RAM) permette operazioni su interi arbitrariamente grandi in un unico passo computazionale (misura di costo uniforme): ipotesi poco realistica Ipotesi più realistica: il costo delle operazioni dipende dalla dimensione degli operandi coinvolti (misura di costo logaritmico) Esempio: qual è il tempo di esecuzione? int x=1; for (int i=1; i<=n; i++) x=x*2; Criterio di costo uniforme: ~n Criterio di costo logaritmico: ~n^2

5 Modelli di Calcolo (4/4) Approccio alternativo: limiteremo la dimensione degli interi rappresentabili a c log n bit (dove c è un opportuna costante ed n è la dimensione dell istanza del problema). Gli algoritmi che studieremo saranno quindi tutti implementabili su macchine RAM con interi di dimensione <=n^c Altri modelli computazionali: Parallel Random Access Machine (PRAM), External Memory Model

6 Esercizio: costo di findmax? int findmax (int[] v) { int currentmax=v[0]; for (int i=1; i<v.length; i++) if (v[i]>currentmax) currentmax=v[i]; return currentmax; Dipende dalla lunghezza dell array (dimensione dell input) Dipende dalla configurazione dei dati di input (caso peggiore: elementi ordinati in maniera crescente; caso migliore: massimo in prima posizione)

7 Costo dei seguenti metodi Java? public static int[] metodo1 (int[] V) { int[] W=new int[v.length]; for (int i=0; i<v.length; i++) W[i]=V[i]; return W; public static void metodo2 (int n) { for (int i=1; i<=n*n; i++) System.out.print ((i * i) + " "); System.out.print ("\n"); public static void metodo3 (int n) { for (int i=1; i<=n; i++) for (int j=1; j<=i; j++) System.out.print ((j) + " "); System.out.print ("\n");

8 Fattoriale public class Fattoriale { public static int fattoriale (int n) { if (n==1) return 1; else return n*fattoriale (n-1); public static void main (String[] args) { System.out.println (fattoriale (5));

9 isprime public class Primes { public static boolean isprime (int n) { if (n<2) return false; int i=n-1; while (i>1) { if ( (n % i)==0 ) return false; i--; return true;

10 Strutture dati elementari (liste, pile, code, alberi)

11 Liste in Java array (puo contenere tipi di dato primitivi, ha dimensione fissa, molto efficiente) classe Vector (contiene riferimenti ad Object, gestione flessibile della memoria, molti metodi a disposizione, meno efficiente, accesso sincronizzato) classe ArrayList (lista realizzata con array, fornisce anche metodi per ridimensionare l array stesso) classe LinkedList (lista doppiamente collegata) record & puntatori

12 Implementazione del tipo Coda in Java (1/4) public class MyQueueNode { public class MyQueue { public Object info; public MyQueueNode next=null; private MyQueueNode head; private MyQueueNode tail; //constructor... public MyQueue () { head=null; tail=null; public boolean isempty () { return head==null; (continua )

13 Implementazione del tipo Coda in Java (2/4) public void enqueue (Object el) { MyQueueNode myqn=new MyQueueNode (); myqn.info=el; //if queue empty... if (isempty ()) { head=myqn; tail=myqn; else { //queue not empty... tail.next=myqn; tail=tail.next; (continua )

14 Implementazione del tipo Coda in Java (3/4) public Object dequeue () { if (isempty ()) return null; Object el=head.info; //if only one node... if (head==tail) { head=null; tail=null; else { //more than one node... head=head.next; return el;

15 Implementazione del tipo Coda in Java (4/4) public class ProvaMyQueue { public static void main (String[] args) { MyQueue q=new MyQueue (); q.enqueue (10); q.enqueue (15); q.enqueue (20); while (!q.isempty ()) { System.out.print (q.dequeue ()+" "); System.out.print ("\n");

16 BFS in Java (1/4) public class BTreeNode { public class BTree { char info; BTreeNode leftchild=null; BTreeNode rightchild=null; BTreeNode parent=null; BTreeNode root; //constructor... public BTree (BTreeNode r) { (continua ) root=r;

17 BFS in Java (2/4) public void bfsbtree () { MyQueue q=new MyQueue (); q.enqueue (root); while (!q.isempty ()) { BTreeNode u=(btreenode) q.dequeue (); if (u!=null) { //visits node... System.out.print (u.info + " "); q.enqueue (u.leftchild); q.enqueue (u.rightchild); System.out.print ("\n");

18 BFS in Java (3/4) public class ProvaBFS { public static void main (String[] args) { //creates nodes... BTreeNode a=new BTreeNode (); BTreeNode l=new BTreeNode (); BTreeNode b=new BTreeNode (); BTreeNode e=new BTreeNode (); BTreeNode r=new BTreeNode (); BTreeNode o=new BTreeNode (); //sets up tree... a.info='a'; l.info='l'; b.info='b'; e.info='e'; r.info='r'; o.info='o'; (continua )

19 BFS in Java (4/4) a.leftchild=l; a.rightchild=b; l.leftchild=e; l.rightchild=r; b.rightchild=o; BTree bintree=new BTree (a); //runs bfs... bintree.bfsbtree ();

20 Implementazione del tipo Pila in Java (1/4) public class MyStackNode { public class MyStack { public Object info; public MyStackNode next=null; private MyStackNode head; //constructor... public MyStack () { head=null; public boolean isempty () { return head==null; (continua )

21 Implementazione del tipo Pila in Java (2/4) public Object top () { if (isempty ()) return null; else return head.info; public Object pop () { if (isempty ()) return null; Object el=head.info; head=head.next; return el; (continua )

22 Implementazione del tipo Pila in Java (3/4) public void push (Object el) { MyStackNode mysn=new MyStackNode (); mysn.info=el; mysn.next=head; head=mysn;

23 Implementazione del tipo Pila in Java (4/4) public class ProvaMyStack { public static void main (String[] args) { MyStack s=new MyStack (); s.push (10); s.push (15); s.push (20); while (!s.isempty ()) { System.out.print (s.top ()+" "); System.out.print (s.pop ()+" "); System.out.print ("\n");

24 Correttezza di una stringa parentetica public static boolean iscorrect (String s) { MyStack mys=new MyStack (); String token=new String ("token"); int i=0; while (i<s.length ()) { if ( s.charat (i) == '( ) mys.push (token); if (s.charat (i) == ') ) { if (mys.isempty ()) return false; else mys.pop (); i++; if (mys.isempty ()) return true; else return false;

25 Ordinamento

26 Implementazione di MergeSort in Java (1/4) public class MergeSort { public static void mergesort (int[] A, int i, int f) { if (i >= f) return; int m=(i + f) / 2; //recursive calls... mergesort (A, i, m); mergesort (A, m+1, f); merge (A, i, m, f); (continua )

27 Implementazione di MergeSort in Java (2/4) private static void merge (int[] A, int i1, int f1, int f2) { //auxiliary array... int[] X=new int [ f2 - i1 + 1]; //stores initial i1 value... int p=i1; int i=0; int i2=f1+1; //while both subsequences still have items left... while (i1 <= f1 && i2 <= f2) { (continua ) if (A[i1] <= A[i2]) { X[i]=A[i1]; i++; i1++; else { X[i]=A[i2]; i++; i2++;

28 Implementazione di MergeSort in Java (3/4) //if subseq #2 ran out of items... if (i1<=f1) { while (i1<=f1) { X[i]=A[i1]; i++; i1++; else {//subseq #1 ran out of items... while (i2<=f2) { X[i]=A[i2]; i++; i2++; //copies auxiliary vector onto input vector... for (int q=0; q<x.length; q++) { A[p]=X[q]; p++;

29 Implementazione di MergeSort in Java (4/4) public class ProvaMergeSort { public static void main (String[] args) { int v[]={25, 34, 128, -12, -128, 4000, 2, 21; MergeSort.mergeSort (v, 0, v.length-1); for (int i=0; i<v.length; i++) System.out.print (v[i]+" "); System.out.print ("\n");

30 Alberi binari di ricerca (BST)

31 Concetto di chiave Insieme di campi di un record che caratterizza il record stesso Es. { <nome>, <cognome>, <data di nascita>, <indirizzo>, <codice fiscale>, <stato civile>, <professione> Possibili chiavi: {<nome>, <cognome>, <data di nascita>, {<codice fiscale>

32 Interfaccia Comparable in Java Spesso le chiavi sono implementate in Java come riferimenti a Comparable, se occorre stabilire un ordinamento tra le chiavi. Implementata da moltissime classi. Impone un solo metodo: public interface Comparable<T> int compareto (T o) Restituisce: un intero negativo se l oggetto di invocazione è minore di o zero se l oggetto di invocazione è uguale ad o un intero positivo se l oggetto di invocazione è maggiore di o

33 BST in Java public class BSTNode { int key; BSTNode leftchild; BSTNode rightchild; BSTNode parent; public class BST { private BSTNode root; //constructor... public BST () { root=null; //returns root node... public BSTNode getroot () { return root; (continua )

34 BST in Java (operazione search ) //returns node with key==k (or null otherwise)... public BSTNode search (int k) { BSTNode v=root; while (v!=null) { if (v.key==k) return v; else { if (k<v.key) v=v.leftchild; else v=v.rightchild; return null;

35 BST in Java (operazione insert ) //inserts k into BST... public void insert (int k) { //creates new bst node... BSTNode mynode=new BSTNode (); mynode.key=k; mynode.leftchild=null; mynode.rightchild=null; mynode.parent=null; if (root==null) { (continua ) root=mynode; return; BSTNode v=root; BSTNode prev=null; while (v!=null) { prev=v; if (v.key<k) v=v.rightchild; else v=v.leftchild; if (prev.key<k) prev.rightchild=mynode; else prev.leftchild=mynode; mynode.parent=prev;

36 BST in Java (operazioni max e min ) //finds node with max key in subtree... public static BSTNode max (BSTNode t) { BSTNode v=t; while (v.rightchild!=null) v=v.rightchild; return v; //finds node with min key in subtree... public static BSTNode min (BSTNode t) { BSTNode v=t; while (v.leftchild!=null) v=v.leftchild; return v;

37 BST in Java (operazione pred ) //finds node with pred key in BST... public static BSTNode pred (BSTNode u) { if (u.leftchild!=null) return max (u.leftchild); while (u.parent!= null && u.parent.leftchild == u) u=u.parent; return u.parent;

38 Alberi AVL

39 Alberi di Fibonacci Costruzione ricorsiva di un albero di Fibonacci: T0 T1 T2 T3 T4 Sono gli alberi bilanciati piu vicini alla condizione di non bilanciamento (ogni nodo interno ha fattore di bilanciamento pari a 1)

40 Dim. altezza AVL tree=o(log n) Sia Th un albero di Fibonacci di altezza h con nh nodi. E possibile dimostrare che h=θ(log nh) (Adel son-vel skii e Landis) Poiche quelli di Fibonacci sono gli alberi AVL con minor numero di nodi, per ogni altro albero bilanciato di altezza h con n nodi sara necessariamente h=o(log n)

41 Tavole Hash

42 Hashing doppio: implementazione Java (1/5) public class MyHashTable { MyHashItem[] thetable; public class MyHashItem { public MyHashTable (int numslots) { int key; Object elem; //creates table... thetable=new MyHashItem[numSlots]; //creates table items... for (int i=0; i<thetable.length; i++) thetable[i]=new MyHashItem (); //sets all elements to null... for (int i=0; i<thetable.length; i++) thetable[i].elem=null; (continua )

43 Hashing doppio: implementazione Java (2/5) public int h1 (int k) { return (k % thetable.length); public int h2 (int k) { return (k % (thetable.length - 1)) + 1; public int c (int k, int i) { return ((h1(k) + i * h2(k)) % thetable.length); (continua )

44 Hashing doppio: implementazione Java (3/5) public void insert (int k, Object e) { for (int i=0; i<thetable.length; i++) { if (thetable[c (k, i)].elem==null) { thetable[c (k, i)].key=k; thetable[c (k, i)].elem=e; return; System.out.println ("ERROR: table is full!"); (continua )

45 Hashing doppio: implementazione Java (4/5) public Object search (int k) { for (int i=0; i<thetable.length; i++) { if (thetable[c (k, i)].elem==null) return null; if (thetable[c (k, i)].key==k) return thetable[c (k, i)].elem; return null; (continua )

46 Hashing doppio: implementazione Java (5/5) public static void main (String[] args) { //creates hash table... MyHashTable myhs=new MyHashTable (11); String s8="8"; String s10="10"; String s13="13"; myhs.insert (8, s8); myhs.insert (10, s10); myhs.insert (13, s13); for (int i=0; i<15; i++) { String o=(string) myhs.search (i); if (o!=null) System.out.println (o); String aux="*"; for (int i=20; i<30; i++) myhs.insert (i, aux);

47 Grafi & Visite di grafi

48 Nuova versione di MyQueue per valori di tipo int (1/3) public class MyQueueNode { public class MyQueue { public int info; public MyQueueNode next=null; private MyQueueNode head; private MyQueueNode tail; //constructor... public MyQueue () { head=null; tail=null; public boolean isempty () { return head==null; (continua )

49 Nuova versione di MyQueue per valori di tipo int (2/3) public void enqueue (int el) { MyQueueNode myqn=new MyQueueNode (); myqn.info=el; //if queue empty... if (isempty ()) { head=myqn; tail=myqn; else { //queue not empty... tail.next=myqn; tail=tail.next; (continua )

50 Nuova versione di MyQueue per valori di tipo int (3/3) public int dequeue () { if (isempty ()) return -1; int el=head.info; //if only one node... if (head==tail) { head=null; tail=null; else { //more than one node... head=head.next; return el;

51 Matrice di adiacenza & BFS (1/5) public class BFSadjMAT { private boolean[][] adjmat; private boolean[] marks; private int numnodes; //costo: O(n^2) public BFSadjMAT (int numnodes) { this.numnodes=numnodes; adjmat=new boolean[numnodes][numnodes]; for (int i=0; i<numnodes; i++) for (int j=0; j<numnodes; j++) adjmat[i][j]=false; marks=new boolean[numnodes]; (continua )

52 Matrice di adiacenza & BFS (2/5) //costo: O(1) public void addedge (int endpoint0, int endpoint1) { if (endpoint0 >= 0 && endpoint0 < numnodes && endpoint1 >= 0 && endpoint1 < numnodes) adjmat[endpoint0][endpoint1]=true; else System.out.println ("addedge: Endpoint id out of range!"); //costo: O(1) public void removeedge (int endpoint0, int endpoint1) { if (endpoint0 >= 0 && endpoint0 < numnodes && endpoint1 >= 0 && endpoint1 < numnodes) adjmat[endpoint0][endpoint1]=false; else System.out.println ("removeedge: Endpoint id out of range!"); (continua )

53 Matrice di adiacenza & BFS (3/5) //prints ids of visited nodes... //costo: O(n^2) public void BFS (int sourceendpoint) { if (sourceendpoint<0 sourceendpoint>=numnodes) { System.out.println ("BFS: invalid source!"); return; //unmarks all vertices... for (int i=0; i<numnodes; i++) marks[i]=false; //creates queue... MyQueue F=new MyQueue (); //enqueues souce node... F.enqueue (sourceendpoint); //marks source node... marks[sourceendpoint]=true; System.out.print (sourceendpoint+" "); (continua )

54 Matrice di adiacenza & BFS (4/5) //main loop... while (!F.isEmpty ()) { //dequeues current vertex... int u=f.dequeue (); for (int i=0; i<numnodes; i++) { if (adjmat[u][i]==true && marks[i]==false) { F.enqueue (i); marks[i]=true; System.out.print (i + " "); System.out.print ("\n"); (continua )

55 Matrice di adiacenza & BFS (5/5) public static void main (String[] args) { BFSadjMAT mygraph=new BFSadjMAT (7); mygraph.addedge (0, 1); mygraph.addedge (1, 2); mygraph.addedge (2, 0); mygraph.addedge (0, 3); mygraph.addedge (3, 2); mygraph.addedge (2, 4); mygraph.addedge (4, 5); mygraph.addedge (2, 5); mygraph.addedge (5, 3); mygraph.addedge (3, 6); mygraph.bfs (1); System.out.print ("\n");

56 Connettivita & Componenti Connesse (grafi non orientati) algoritmo isconnected (grafo G) boolean scegli arbitrariamente un vertice s in G T visitagenerica (s) if (T ha n nodi) return true else return false O(m+n) (liste di adiacenza) O(n) Le componenti connesse di G possono essere determinate modificando l algoritmo precedente, in modo da iniziare una nuova visita da un vertice non ancora esplorato (se c e ). Tempo di esecuzione: O(m+n).

57 Componenti fortemente connesse (grafi orientati) Per calcolare la componente fortemente connessa contenente il vertice x si puo procedere come segue: 1. Si calcola l insieme D(x) dei vertici raggiungibili da x. E sufficiente una visita generica a partire da x. Costo computazionale: O(m+n). 2. Si calcola l insieme A(x) dei vertici da cui e possibile raggiungere x. Occorre invertire la direzione di tutti gli archi del grafo, e poi eseguire una nuova visita partendo da x. Costo computazionale: O(m+n). A questo punto sara sufficiente individuare tutti i vertici che sono contemporaneamente in D(x) ed A(x), cioe che sono sia discendenti che antenati di x.

58 Componenti fortemente connesse (grafi orientati) Applicando per n volte l algoritmo descritto nella slide precedente, si ottengono le componenti fortemente connesse dell intero grafo. Il costo computazionale sara O(mn+n^2) NB. Esiste un algoritmo migliore (che sfrutta le proprieta della visita DFS) in grado di calcolare le componenti fortemente connesse di un grafo in tempo O(m+n).