La clase Grafo. 4 Algoritmos de recorrido de grafos. La clase Vertice. Tema 9: GRAFOS Segunda Parte Estructuras de Datos y Algoritmos Curso 2002/03

Transcripción

1 La clase Grafo public class Grafo { Tema 9: GRAFOS Segunda Parte Estructuras de Datos y Algoritmos Curso 00/03 private static final int TAMANYO_INICIAL=0; private Vertice tabla []; private int numvertices; private TablaHash diccio; public Grafo() {... public insarista (String orig,string dest,int cost) {... public String tostring() {... La clase Vertice Algoritmos de recorrido de grafos public class Vertice { String nombre; //el nombre del vértice Lista ady; // la lista de vértices adyacentes (aristas) public Vertice(String v) { nombre=v; Lista: ady=new Lista(); public void insertar(object x); // public la posición String del punto de tostring() interés continua { apuntando al mismo elemento public return void borrar() ady.tostring(); throws DesbordamientoInferior; // borra el elemento que ocupa la posición del punto de interés (queda marcando al siguiente) public Object recupera(); public boolean esvacia(); public void inicio(); public void fin(); public void siguiente() throws PosicionIncorrecta; public boolean esfin(); public String tostring(); DFS: recorrido en profundidad (Depth First Search), generalización del recorrido en preorden de un árbol. BFS: recorrido en anchura (Breath First Search), generalización del recorrido por niveles de un árbol. 3

2 Recorrido en profundidad (DFS) Algoritmo de Recorrido en profundidad Explora sistemáticamente las aristas del grafo de forma que primero se visitan los vértices adyacentes a los visitados más recientemente. Así se va profundizando en el grafo. Algoritmo de recorrido en profundidad: Contador (ordenrecorrido) Vector de naturales (R) para marcar los vértices ya visitados (R[v]>0) y almacenar el orden de recorrido. R[v]: orden en el que se visita el vértice v. Recorrido en Profundidad ordenrecorrido=0; vv: R[v]=0; vv: Si (R[v]==0) entonces DFS(v) R mantiene el orden de recorrido finrp Método privado recursivo DFS(v) ordenrecorrido++; R[v]=ordenRecorrido; wadyacentes(v): Si (R[w]==0) entonces DFS(w) Ejemplo: Recorrido DFS Recorrido en profundidad en Java Nodos R v/w /,3,, /,, / / / /3, / /, R int R[]; int OrdenRecorrido; public void RecorridoEnProfundidad () { R=new int[numvertices]; OrdenRecorrido=; for (int i=0;i<numvertices;i++) R[i]=0; for (int i=0; i<numvertices; i++) if (R[i]==0) DFS(i); private void DFS (int i) { R[i]=OrdenRecorrido++; Lista b=tabla[i].ady; b.inicio(); while (!b.esfin()) { Arista w=(arista) b.recupera(); if (R[w.dest]==0) DFS(w.dest); b.siguiente(); 7 8

3 Ejercicio: Recorrido en anchura (BFS) Hacer una traza del recorrido en profundidad sobre el grafo siguiente: V = { V0, V,V,V3,V,V,V E = { (VO,V), (V0,V3), (V,V3), (V,V), (V,V0), (V,V), (V3,V), (V3,V), (V3,V), (V,V), (V,V) Explora sistemáticamente las aristas del grafo de forma que primero se visitan los vértices más cercanos al que estamos explorando. Algoritmo de recorrido en anchura: Contador (OrdenRecorrido) Vector de naturales (R) para marcar los vértices ya visitados (R[v]>0) y almacenar el orden de recorrido. Cola (Q) para gestionar los vértices no visitados public interface cola { void insertar (Object x); Object quitarprimero () throws DesbordamientoInferior; Object primero () throws DesbordamientoInferior; boolean esvacia(); void vaciar(); 9 0 Algoritmo de Recorrido en anchura Ejemplo: Recorrido BFS Recorrido en Amplitud OrdenRecorrido=0; vv: R[v]=0; Q=new ColaEnlazada(); vv: Si (R[v]==0) entonces BFS(v) R mantiene el orden de recorrido Método privado para el recorrido en Amplitud BFS(v) OrdenRecorrido++; R[v]=OrdenRecorrido; Q.insertar(v); mientras (!Q.esVacia()) { u=q.quitarprimero(); wadyacentes(u): Si R[w]==0 { OrdenRecorrido++; R[w]=OrdenRecorrido; Q.insertar(w) Nodos R Q v u w <> <> <> <,3> <,3,> <,3,,> <3,,> <,> <,,> <,,,8> <,,8> <,8> <8> <8,7> <7> <> <9> <> R

4 Recorrido en anchura en java public void RecorridoEnAmplitud() { R=new int[numvertices];ordenrecorrido=;q=new colavec(); for (int i=0; i<numvertices; i++) R[i]=0; for (int i=0; i<numvertices; i++) if (R[i]==0) BFS(i); private void BFS (int v) { R[v]=OrdenRecorrido++; q.insertar(new Integer(v)); while (!q.esvacia()) { Integer u= (Integer) q.quitarprimero(); Lista b=tabla[u.intvalue()].ady; b.primero(); while (!b.esfin()) { Arista w=(arista) b.recupera(); if (R[w.dest]==0) { R[w.dest]=OrdenRecorrido++; q.insertar(new Integer(w.dest)); b.siguiente(); Ejercicio: Hacer una traza del recorrido en amplitud sobre el grafo siguiente: V = { V0, V,V,V3,V,V,V E = { (VO,V), (V0,V3), (V,V3), (V,V), (V,V0), (V,V), (V3,V), (V3,V), (V3,V), (V,V), (V,V) 3 Ordenación topológica en GDA Algoritmo de Ordenación Topológica Aplicaciones: Representación de las fases de un proyecto en un GDA Evaluación de atributos en la fase de análisis semántico de un compilador Algoritmo para el recorrido según la OT Utilizar el recorrido en profundidad para ordenar los vértices según un orden (parcial) tal que u,vv, si (u,v)e, u v. Basta ir anotando en una pila global (P) los vértices completamente explorados por DFS. OTP ordenrecorrido=0; vv: R[v]=0; p= new pilavec(); vv: Si (R[v]==0) entonces DFST(v) ; Método privado recursivo DFST(v) ordenrecorrido++; R[v]=ordenRecorrido; wadyacentes(v): Si (R[w]==0) entonces DFST(w); p.apilar(v);

5 Ejemplo: Ordenación topológica Ejercicio Nodos R P v/w <> /,3,, <> <> 3/,, <> / <> 7/ <7,> <,7,> 8/ <8,,7,> <3,8,,7,> /3, <,3,8,,7,> / <,,3,8,,7,> <,,,3,8,,7,> 9/, <9,,,,3,8,,7,> Implementación del algoritmo de Ordenación topológica en Java Grafo ordenado topológicamente 7 8 BÚSQUEDA DE CAMINOS MÍNIMOS EN GRAFOS Problema del camino mínimo sin pesos La longitud del camino sin pesos mide el número de aristas Encontrar el camino más corto (medido por el número de aristas) desde un cierto vértice O a cualquier otro vértice Problema del camino mínimo con pesos positivos (algoritmo de Dijkstra) La longitud del camino con pesos es la suma de los costes de las aristas del camino Las aristas tienen costes no negativos Se trata de encontrar el camino más corto (medido con su coste total) desde el vértice origen al resto de vértices El problema anterior es un particular de éste, en el que las aristas tiene coste Problema: dado el siguiente grafo, encontrar el camino más corto (medido por el número de aristas) desde su Vértice a cualquier otro vértice v 0 v v v Problema 0 : encontrar el Camino más corto desde a Solución 0 : //la no //lahay distancia longitud mínima 0 de de es a es 0 distanciamin[vorigen] = 0; 0; 9 0

6 Problema: dado el siguiente grafo, encontrar el camino más corto (medido por el número de aristas) desde su Vértice a cualquier otro vértice v 0 v distanciam[vorigen] = 0; 0; distanciamin[primervadyacente(vorigen)] = ; ; distanciamin[últimovadyacente(vorigen)] = ; ; v 0 distanciam[vorigen] = 0; distanciam[vorigen] = 0; v v v v v Problema : encontrar el Camino más corto desde a sus Vértices más cercanos Solución : los // // la la Vértices distancia más mínima cercanos de de son 0 sus /v adyacentes, es a v 0 /v es distanciamin[primervadyacente(vorigen)] están a Arista de longitud (mínima) = ; ; distanciamin[últimovadyacente(vorigen)] = ; ; Problema : encontrar el Camino más corto desde a los Vértices más cercanos a los Vértices adyacentes a Solución // : los Vértices más cercanos son sus adyacentes // distancia mínima de de v 0 - es (v no 0 a - es (v no tiene) están a Aristas de longitud (mínima) distanciamin[primervadyacente(primervadyacente(vorigen)] = ; ; Cómo distanciamin[segundovadyacente(primervadyacente(vorigen)] = ; ; Usar recordar una distanciamin[últimovadyacente(primervadyacente(vorigen)] = ; ; dónde Cola distanciamin[primervadyacente(últimovadyacente(vorigen)] = ; ; distanciamin[segundovadyacente(últimovadyacente(vorigen)] = ; ; seguir? distanciamin[últimovadyacente(últimovadyacente(vorigen)] = ; distanciamin[últimovadyacente(últimovadyacente(vorigen)] = ; Problema: dado un grafo, encontrar el camino más corto (medido por el número de aristas) desde un Vértice dado, origen, a cualquier otro vértice Reformulación de Problema: Recorrido en Anchura o Breath First Search (BFS) desde el origen, en la que el vector R pasa a ser distanciamin: distanciamin[i] representa la distancia mínima de origen al Vértice i si distanciamin[i] ==, el Vértice i NO se ha visitado aún por lo que la distancia mínima de origen al Vértice i es la máxima posible distanciamin[origen] == 0 si distanciamin[i] > 0, el Vértice i SÍ se ha visitado, desde un cierto vanterior/ distanciamin[i]=distanciamin[vanterior] + Resolución del problema de caminos mínimos sin pesos CaminoMinimoSinPeso(origen) vv: distanciamin[v]= ; q.insertar(origen); while (!q.esvacia()) { v=q.quitarprimero() ; wadyacentes(v): Coste del algoritmo: O( E ) Lineal con el tamaño del grafo (número de arcos) if (distanciamin[w] == ) { distanciamin[w] = distanciamin[v] + ; q.insertar(w); 3

7 Problema: dado el siguiente grafo, encontrar el camino más corto (medido por el número de aristas) desde su Vértice a cualquier otro vértice v 0 v v v Comprobar == inf evita que distanciamin[3] pase a valer 3 distanciamin[] = distanciamin[3] + Vertice s DistanciaMin 0 3 q = q = 0 q = q = 0, q =, q=,, q=, q = 3, public void CaminoMinimoSinPeso(int origen){ distanciamin = new int[numvertices]; for (int i=0 ; i<=numvertices ; i++) distanciamin[i]=infinito ; q=new ColaVec(); distanciamin[origen]=0 ; q.insertar(new Integer(origen)); try { while (!q.esvacia()) { int v=((integer)q.quitarprimero()).intvalue() ; Lista b=tabla[v].ady; b.inicio(); while (!b.esfin()) { Arista a = (Arista) b.recupera(); int w = a.dest(); if (distanciamin[w] == INFINITO ) { distanciamin[w] = distanciamin[v] + ; q.insertar(new Integer(w)); b.siguiente(); catch (DesbordamientoInferior e) {// No puede ocurrir Encontrar no solo el coste sino también el camino Mostrar por pantalla el camino Usar un vector para guardar el camino: P[i] es el vértice anterior a i en el camino mínimo CaminoMinimoSinPeso(origen) vv: distanciamin[v]= ; vv: P[v]=- ; q.insertar(origen); while (!q.esvacia()) { v=q.quitarprimero() ; wadyacentes(v): void imprimircamino(int destino) { if (P[destino]!=-) { imprimircamino(p[destino]); System.out.println(tabla[destino].nombre); if (distanciamin[w] == ) { P[w]=v; distanciamin[w] = distanciamin[v] + ; q.insertar(w); 7 8

8 Resolución del problema de caminos mínimos con pesos Algoritmo de Dijkstra Algoritmo de Dijkstra Cambio en el ajuste del vector de distancias El valor distanciamin[v] sólo se modificaba una vez Ahora el algoritmo debe decidir si para llegar a un cierto vértice w es mejor pasar por v o no: distanciamin[w]=min(distanciamin[w], distanciamin[v]+coste(v,w)) Cambio en la selección del vértice a tratar Seleccionar el vértice más próximo ahora no es el tratado más recientemente sino el de menor coste La estrategia NO es usar una cola (First-In First-Out) El primero visitado no es el más próximo necesariamente En general utilizaremos un conjunto C para guardar los vértices no tratados: al principio son todos y en cada iteración se elimina uno, aquel que tiene el valor de distanciamin menor. 9 Dijkstra (origen) Coste del algoritmo: O( V ) vv: distanciamin[v]= ; Mejora: Usar una Cola de Prioridad C={V; //todos los vértices por tratar para representar C while ( C!=) { v=el elemento de C con menor valor de distanciamin; Eliminar v de C; wadyacentes(v): if (distanciamin[w]>distanciamin[v]+coste(v,w)) { distanciamin[w] = distanciamin[v] + coste(v,w) ; 30 Dijkstra (origen) Complejidad temporal (n= V ) Matriz de adyacencias y C una lista vv: distanciamin[v]= ; (n) C={V; //todos los vértices por tratar while ( C!=) { n- iteraciones v=el elemento de C con menor valor de distanciamin; Eliminar v de C; n n( n ) wadyacentes(v): T ( n) k( n i) k ( n ) i if (distanciamin[w]>distanciamin[v]+coste(v,w)) { distanciamin[w] = distanciamin[v] + coste(v,w) ; En la iteración i: C Seleccionar Eliminar Bucle n-i (n-i) (n-i) (n-i) 3 Dijkstra (origen) Complejidad temporal (n= V ) Listas de adyacencias y C un minheap vv: distanciamin[v]= ; (n) C={V; //todos los vértices por tratar while ( C!=) { n- iteraciones v=el elemento de C con menor valor de distanciamin; Eliminar v de C; n wadyacentes(v): T ( n) gradog log( n i) ( E log n) i if (distanciamin[w]>distanciamin[v]+coste(v,w)) { distanciamin[w] = distanciamin[v] + coste(v,w) ; En la iteración i: C Seleccionar y Eliminar Bucle n-i (log n-i) (gradog log (n-i)) 3

9 Implementación del algoritmo de Dijkstra La clase ElementoHeap Opción : Estructurar D como un minheap Implementar C como un vector de bits Utilizar un vector para marcar la posición de cada vértice en el heap Opción : Usar una cola de prioridad implementada como un minheap en la que cada elemento es un par (vértice, DistanciaMin[vértice]) Usar un vector para marcar los vértices ya visitados (desencolados). De esta forma se trata las posibles repeticiones de vértices en la cola de prioridad Seguro que el vértice se trata con el menor valor de DistanciaMin Ya no se vuelve a tratar porque se marca 33 public class ElementoHeap implements Comparable{ int dest; // vértice w int coste; // DistanciaMin[w] static ElementoHeap infneg=new ElementoHeap(); ElementoHeap() {this(0); ElementoHeap (int d) { this(d,0); ElementoHeap (int d, int c) { dest=d; coste=c; public boolean menorque (Comparable otro) { return (coste< ((ElementoHeap)otro).coste); public int compareto (Object otro) { return coste < ( (ElementoHeap)otro).coste? - : coste > ( (ElementoHeap)otro).coste? : 0; 3 Implementación del algoritmo de Dijkstra Ejercicios: public void dijkstra(int origen){ distanciamin = new int[numvertices]; for (int i=0 ; i<=numvertices ; i++) distanciamin[i] = INFINITO ; qprioridad = new MonticuloBinario(newnew ElementoHeap()); distanciamin[vorigen] = 0; qprioridad.insertar(new ElementoHeap(origen, 0)); try { while (!q.esvacia()) { ElementoHeap par = ((ElementoHeap)q.eliminarMin()); v = par.dest(); if (desencolados[v] == 0) { desencolados[v] = ; Lista b= tabla[v].ady(); b.inicio(); while (!b.esfin()) { Arista a = (Arista) b.recupera(); int w = a.dest; int costevw = a.coste(); if ( distanciamin[w] > distanciamin[v] + costevw) { distanciamin[w] = distanciamin[v] + costevw ; qprioridad.insertar(new ElementoQ(w, distanciamin[w] )); b.siguiente(); catch (DesbordamientoInferior e) {// No puede ocurrir.- Hacer una traza del algoritmo de Dijkstra sobre este grafo, tomando como vértice origen v 0 0 v 8 v v.- Implementar en Java las operaciones sobre grafos, incluyendo recorridos y obtención de caminos siguiendo los algoritmos vistos en clase 3.- Implementar en Java las operaciones sobre grafos, incluyendo recorridos y obtención de caminos bajo el supuesto de que los grafos con los que vamos a trabajar sean densos 3 3