LABORATORIO DI ALGORITMI E STRUTTURE DATI A-L. Ingegneria e scienze informatiche Cesena A.A: 2016/2017 Docente: Greta Sasso

Transcript

1 LABORATORIO DI ALGORITMI E STRUTTURE DATI A-L Ingegneria e scienze informatiche Cesena A.A: 2016/2017 Docente: Greta Sasso

2 Grafi Un grafo è una struttura definita come un insieme di nodi (o vertici) che possono essere collegati tra di loro da archi. Grafo connesso: un grafo si dice connesso se per ogni coppia di nodi esiste un cammino (sequenza di archi) che li collega. Grafo orientato: un grafo si dice orientato (o diretto) se i suoi archi sono caratterizzati da una direzione. In questo caso un arco collega un nodo di partenza con un nodo di arrivo. Grafo pesato: un grafo si dice pesato se ad ogni arco e associato un peso numerico. Notazione che utilizzeremo di seguito: Indichiamo un grafo con la lettera G. Indichiamo con V[G] il set di vertici nel grafo G. Indichiamo con E[G] il set di archi nel grafo G.

3 o Possibile formato di testo per un grafo : Prima riga : numero di vertici del grafo Righe successive alla seconda: <id vertex1> <id vertex2> < peso arco diretto tra vertex1 e vertex2 > Per semplicità utilizziamo valori interi tra 0 e n 1 per la label dei vertici A=0, b=1, c=2, d=3, e=4

4 Matrice di adiacenza Struttura dati per la rappresentazione in memoria di un grafo G, diretto e pesato. È una matrice di dimensione n*n (n numero nodi) tale che: m[u][v] = 1 se (u,v) E[G] 0 se (u,v) E[G] Se il grafo non è orientato, la matrice è simmetrica: m[u,v]==m[v][u] Proprietà fondamentali: Occupazione di spazio O ( V[G] 2 ) Tempo di verifica di esistenza di un arco tra due vertici : O(1) Tempo di visita degli archi adiacenti a un vertice v: O( V[G] ), perché occorre analizzare una riga intera della matrice di dimensione n.

5

6 Lettura di un grafo da file in matrice di adiacenza int **read_adjmatrix(char *file, unsigned int *n) { FILE *in; int **G = NULL; //Apriamo il file e leggiamo il numero di nodi if ((in = fopen(file, "r"))!= NULL && fscanf(in, "%u", n)!= EOF) { if ((G = matrix_alloc(*n))!= NULL) { int i, j, weight; } while (fscanf(in, "%d %d %d\n", &i, &j, &weight)!= EOF) { //lettura di una riga del file con controllo if (i >= 0 && i < *n && j >= 0 && j < *n) G[i][j] = weight; } } fclose(in); } return G;

7 #include<limits.h> #define NIL INT_MIN int **matrix_alloc( unsigned int n) { int **m = NULL; int i,j; m = (int **)malloc(n * sizeof(int *)); if (m == NULL) return NULL; for ( i = 0; i < n; i++) { m[i]= (int *)malloc(n * sizeof(int )); if (m[i] == NULL) return NULL; for (j = 0; j < n; j++) m[i][j] = NIL; } return m; }

8 Liste di adiacenza Struttura dati per la rappresentazione in memoria di un grafo G, diretto e pesato. L insieme dei nodi adiacenti è mantenuto in modo esplicito tramite un array di dimensione n in cui ogni cella memorizza l identificativo del nodo e l insieme dei nodi adiacenti. Proprietà fondamentali: Occupazione di spazio O ( V[G] + E[G] ). Tempo di verifica di esistenza di un arco tra due vertici u,v : O( adj( u ) ) Tempo di visita degli archi adiacenti a un vertice v: O( adj( v ) ) Indichiamo con adj(x) l insieme dei nodi adiacenti a un nodo x

9

10 Struttura dati per la lista di adiacenza typedef struct VERTEX { int id; int wgt; struct VERTEX *next; }vertex; vertex * vertex_alloc( int id, int weight) { vertex *v = (vertex *)malloc(sizeof(vertex)); } if (v!= NULL) { v->id = id; v->wgt = weight; v->next = NULL; } return v;

11 Lettura di un grafo da file in liste di adiacenza vertex **read_adjlist(char *file, int *n) { FILE *in; vertex **G = NULL; if ((in = fopen(file, "r"))!= NULL && fscanf(in, "%u", n)!= EOF) { //si alloca l array di puntatori per il numero dei vertici totali G = (vertex **)calloc(*n,sizeof(vertex *)); if (G!= NULL) { int i, j, weight; vertex *tmp; //si legge un arco e lo si inserisce nella riga corrispondente al Nodo sorgente i, in testa alla lista while (fscanf(in, "%d %d %d\n", &i, &j, &weight)!= EOF) { if (i >= 0 && i < *n && j >= 0 && j < *n) { if ((tmp = vertex_alloc(j, weight))!= NULL) { tmp->next = G[i]; G[i] = tmp; } } } } fclose(in); } } return G;

12 Stampa di un grafo in lista di adiacenza void printlist( vertex ** l, int dim) { int i, j; vertex * tmp; for (i = 0; i < dim; i++) { tmp = l[i]; } printf("\nid[%d] ", i); while (tmp!= NULL) { printf(" -> [id:%d w:%d] ", tmp->id, tmp->wgt); tmp = tmp->next; } } printf("\n");

13 Visita di un grafo La visita di un grafo è una procedura per l esplorazione di un grafo, in cui tutti gli archi e i nodi sono visitati almeno una volta. La visita di un grafo è la base di molti algoritmi complessi (Es. l'individuazione di cicli all'interno del grafo stesso, stabilire se un grafo e connesso o meno, etc.. )

14 Visita generica di un grafo: L insieme S contiene i nodi scoperti che vengono estratti uno dopo l altro dopo la loro visita. Il controllo sull essere «scoperto» di un nodo ci permette di evitare visite duplicate Costo ( n + m) visita(graph G, Node r) SET S createset S.insert( r) marca il nodo r come scoperto while S.size() > 0 do Node u S.remove() esamina nodo u foreach v G.adg(u) do esamina arco (u,v) if v non è stato già scoperto then //marca il nodo v come scoperto S.insert( v) end if end for end while

15 Visita generica di un grafo: L ordine con cui vengono visitati i nodi dipende dalla politica di estrazione implementata dalla procedura remove L insieme S : Scelta della struttura dati Coda : con politica di rimozione FIFO, si ottiene una visita in ampiezza BFS Pila : con politica di rimozione LIFO, si ottiene una visita in profondità DFS Altro : ordine alfabetico, ordine crescente, etc

16 Visita in ampiezza Breadth First Search È una procedura di visita di un grafo G Dato un vertice sorgente, produce un albero di copertura per la componente connessa a cui appartiene il vertice sorgente Costo computazionale: O( V[g] + E[G] ) Informazioni aggiuntive utilizzate: Colore di un nodo (c[]) : WHITE ( non visitato), GREY( in visita ), BLACK( già visitato ) Puntatore al padre (p[]) contiene le informazioni per ricostruire l albero di copertura Distanza ( d[] ) mantiene la distanza, in termini di numero di archi, dal nodo sorgente

17 Corrisponde alla visita per livelli di un albero in cui i figli di un nodo vengono visitati dopo aver visitato tutti gli altri nodi situati allo stesso livello del padre Insieme S è realizzato tramite struttura dati CODA, con politica di rimozione FIFO Si ottiene dalla visita un albero di copertura BF Si utilizza un vettore di booleani che rappresenta l insieme di nodi già scoperti IDEA: Si sceglie la sorgente S e si selezionano i nodi adiacenti colorandoli in grigio e salvandoli in coda Si seleziona un elemento salvato in coda e lo si analizza Si colorano in grigio e si salvano in coda tutti i nodi adiacenti Il nodo è completamente visitato una volta analizzati tutti i suoi vicini, e lo si colora di nero Si itera il procedimento finché sono presenti nodi in coda

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34 Albero di copertura ottenuto a partire dal nodo sorgente

35 BFS( G, u ) foreach v V[G] do c[v] WHITE p[v] NIL d[v] end for Q createqueue( V[G] ) C[u] GREY D[u] 0 Enqueue( Q, u) while not isempty(q) do v dequeue(q) foreach w G.adj do if c[w]= WHITE then c[w] GREY p[w] v d[w] d[v] + 1 enqueue( Q,w ) end if end for c[v] BLACk end while

36 Visita in profondità Depth First Search È una procedura ricorsiva di visita di un grafo G Dato un vertice sorgente, produce un albero di copertura per la componente connessa a cui appartiene il vertice sorgente Costo computazionale: O( V[g] + E[G] ) Informazioni aggiuntive utilizzate: Colore di un nodo (c[]) : WHITE ( non visitato), GREY( in visita ), BLACK( già visitato ) Puntatore al padre (p[]) contiene le informazioni per ricostruire l albero di copertura Inizio visita (s[]) marcatore temporale intero Fine visita ( t[]) marcatore temporale intero

37 Corrisponde alla visita in ordine anticipato di un albero Al momento della visita di un nodo u, ci si allontana il più possibile da questo visitando gli altri nodi che si trovano lungo il cammino Insieme S è realizzato tramite struttura dati PILA, con politica di rimozione LIFO Il sottografo dei precedessori non forma più un albero, ma una foresta DF composta da vari alberi. Vengono memorizzate per ogni vertice delle informazioni temporali comprese fra 1 e 2* V perché ciascuno dei vertici può essere scoperto una sola volta e la sua visita può essere completata una sola volta Si utilizza un vettore di booleani che rappresenta l insieme di nodi già scoperti

38 IDEA: Si sceglie la sorgente S come nodo attuale: a S, e lo si colora di grigio Scegliamo arbitrariamente uno dei nodi adiacenti u G.adj (a) Se u è stato già visitato, torniamo indietro al predecessore, altrimenti procediamo ripetendo il procedimento con a u Si itera il procedimento per tutti i nodi di G

39

40

41

42

43

44

45

46

47

48

49

50 Albero di copertura ottenuto a partire dal nodo sorgente

51 DFS( G, u ) foreach v V[G] do c[v] WHITE p[v] NIL s[v] NIL t[v] NIL end for Time 0 foreach u V[G] do if c[u]=white then DFS-visit(G,u) end if end for DFS-VISIT( G, u ) time = time + 1 c[u] GREY s[u] time foreach v G.adj(u) do if c[v]=white then p[v] u DFS-VISIT(G,v) end if end for c[u] BLACK time time+1 t[u] time Con la ricorsione si utilizza implicitamente lo stack del sistema

52 Si consideri un grafo orientato non pesato G rappresentato mediante una matrice N*N di adiacenza dove M[i][j]=1 se e solo se esiste l arco orientato (i,j). Si consideri poi un array C di K (K=dimensione) numeri interi tutti compresi fra 0 e N-1. Scrivere una procedura efficiente che, dato in input la matrice M, l array C e due interi S e D, restituisce true se e solo se il vettore C rappresenta un cammino ( quindi una sequenza di vertici visitati) dal nodo S al nodo D. non è richiesto che C sia un cammino minimo. Quanto costa la procedura? Matrice di Adiacenza M[5][5] ESEMPIO Array C[K] Output: true [ Esercizi proposti 7.1 ]

53 Implementare la visita BFS scegliendo fra lista o matrice di adiacenza Per semplicità si possono utilizzare le procedure fornite per la creazione della lista/matrice di adiacenza a partire da un file di testo Step 2: Quali sono le differenze utilizzando le due diverse strutture dati? Step 3: Implementare la versione iterativa della DFS [ Suggerimento: la differenza fra le due visita è la politica di rimozione ] [ Esercizi proposti 7.2 ]

54 Si consideri un grafo orientato con N nodi numerati da 0 a N-1. il grafo è rappresentato da una matrice di adiacenza. Scrivere una procedura per calcolare l indice del nodo con grado uscente massimo ( l indice del vertice con il numero maggiore di archi uscenti). Quanto costa la soluzione? ESEMPIO Matrice di Adiacenza M[5][5] Output: indice 0 [ Esercizi proposti 7.3 ]

55 Domande e discussione Domande?