1 / 40

Tema 5 Grafos.

Tema 5 Grafos. Un grafo se define como un par G = (V, A), donde V es un conjunto finito no vacío de vértices A es un conjunto de pares de vértices de V, es decir, las aristas . Ejemplo: Los vértices representan ciudades y almacenan el nombre de la ciudad

aimon
Télécharger la présentation

Tema 5 Grafos.

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Tema 5 Grafos.

  2. Un grafo se define como un par G = (V, A), donde V es un conjunto finito no vacío de vértices A es un conjunto de pares de vértices de V, es decir, las aristas. Ejemplo: Los vértices representan ciudades y almacenan el nombre de la ciudad Las aristas representan la ruta y la distancia kilométrica entre las ciudades que unen. Grafos BILBAO 606 BARCELONA OVIEDO 395 622 445 538 MADRID 437 ALICANTE 531 1006 534 SEVILLA 207 MALAGA 221 MELILLA

  3. Tipos de Grafos 251 MADRID ALBACETE • Según el tipo de arista: • Arista dirigida: par ordenado de vértices (u,v) • El primer vértice u es el origen de la arista • El segundo vértice v es el término (o vértice final). • (u, v) ≠ (v, u). • Arista no dirigida: par no ordenado de vértices (u, v) • (u, v) = (v, u). • SE DEFINEN: • Grafos dirigidos (todas las aristas son dirigidas) • Expresan relaciones asimétricas y de jerarquía • Grafos no dirigidos (todas las aristas son no dirigidas) • Expresan relaciones simétricas y de colaboración es-hermano-de ZIPI ZAPE IB2458 MAD BCN autor-de “El Buscón” Quevedo ejemplo novela

  4. V a b U d X c e V W g a b f U d X Y c e W g f Y Incidencia, Adyacencia y Grado • Incidencia: La arista (u,v) es incidente con los vértices u y con v). De forma que: • Aristas a, d, y b son incidentes en V • Adyacencia: Dos vértices u y v son adyacentes si existe la arista (u, v) o (v, u). • Grado de un vértice: Determinado por el número de vértices adyacentes al nodo. • Grado de X = 3 • Si el grafo es dirigido: • Grado de salida: número de vértices adyacentes desde el nodo. • Grado de salida de W = 0 • Grado de salida de Y = 2 • Grado de entrada: número de vértices adyacentes al nodo. • Grado de entrada de W = 4 • Grado de entrada de Y = 0

  5. Grafo dirigido Grafo no dirigido a b a b e e c d c d <a,b>: camino simple de longitud 1. <e,d,a,b>: camino de longitud 3. <a,c,d>: no es un camino. <e,e>: camino, bucle y ciclo <a,b,e,d,c>: camino simple de longitud 4. <a,c,d,a,b,e>: camino de longitud 5. <a,e>: no es un camino. <e,e>: camino, bucle y ciclo Más terminología • Camino, bucle y ciclo: • Grafo simple/multigrafo • Grafos etiquetados/ponderados

  6. public interface Grafo { • public void insertaVertice( int n); • /** Inserta un vértice en el grafo siempre que no • se supere el número máximo de nodos permitidos **/ • public void eliminarVertice (int v); • /** Elimina un vértice del grafo **/ • public void insertaArista (int i, int j); • /** Inserta una arista entre los vértices i y j **/ • public void eliminarArista (int i, int j); • /** Elimina la arista entre los vértices i y j **/ • public boolean esVacio (Grafo g); • /** Devuelve true si el grafo no contiene ningún vértice **/ • public boolean existeArista (int i, int j); • /** Devuelve true si existe una arista que una los vértices i y j. **/ • public int gradoIn (int i); • /** Devuelve el grado de entrada del vértice i **/ • public int gradoOut (int i); • /** Devuelve el grado de salida del vértice i **/ • public int incidencia (int i) • /** Devuelve la incidencia del vértice i **/ • public int tamano(); • /** Devuelve el tamaño (número de aristas) del grafo **/ • public boolean esDirigido (Grafo g) ; • /** Devuelve true si el grafo g es dirigido **/ • public void ponerMaxNodos (int n); • /** Asigna el número máximo de nodos permitidos en el grafo**/ • public void ponerDirigido (boolean d); • /** Determina si es un grafo dirigido o no dirigido **/ • } Interfaz de Grafo

  7. Implementación de Grafos: Matriz de Adyacencias

  8. Matriz de adyacencias • Tabla bidimensional que guarda las adyacencias entre pares de vértices de un grafo. • Vértices: enteros en el conjunto {0,1,…,n-1} • Aristas: pares de tales enteros. • Cada fila y cada columna representan un vértice del grafo y cada posición representa una arista (o la ausencia de esta) cuyo vértice origen se encuentra en la fila y vértice final se encuentra en la columna.

  9. a a b b e e c c d d Ejemplos Grafo no dirigido Grafo dirigido matriz simétrica

  10. a b Vértices: a b c d e Índices: 0 1 2 3 4 e c d Representación en matriz de adyacencias • Los vértices se representan mediante índices. • Matriz de adyacencias se implementa como un array A bidimensional de n x n donde: • La celda [i, j] guarda información referente a la arista (v, w) donde v es el vértice con índice i y w es el vértice con índice j. • Para grafos no etiquetados, las celdas guardan valores booleanos: • true: existe la arista • false: no existe la arista

  11. Clase GrafoMA en JAVA public class GrafoMA implements Grafo { private boolean dirigido; private int maxNodos; private int numVertices; private boolean matrizAdy[ ][ ]; } • Grafos simples, dirigidos o no dirigidos, no etiquetados • Dos constructores: grafo vacío y grafo de tamaño n. public GrafoMA (boolean d) { maxNodos = numVertices = 0; dirigido = d; } public GrafoMA (int n, boolean d) { dirigido = d; maxNodos = n; numVertices = 0; matrizAdy = new boolean[n][n]; } }

  12. Insertar aristas • La inserción de una arista (i, j) en la matriz supone asignar a la celda correspondiente el valor true. • En grafo dirigido: • las filas representan el vértice origen (i) • las columnas representan el vértice destino (j) • En grafo no dirigido: • La arista (i,j) es igual a la arista (j,i) (para que la matriz mantenga la propiedad de la simetría. public void insertaArista(int i, int j) { matrizAdy[i][j] = true; if (!dirigido) matrizAdy[j][i] = matrizAdy[i][j]; }

  13. Eliminar aristas • La eliminación de una arista (i, j) en la matriz supone asignar a la celda correspondiente el valor false. public void eliminarArista(int i, int j) { matrizAdy[i][j] = false; if (!dirigido) matrizAdy[j][i] = false; }

  14. Insertar vértices • El tratamiento de los vértices implicaría modificar el tamaño de la tabla (o modificar los índices en caso de querer eliminar un vértice): • Simplificación del método: • No se permite añadir vértices si se supera el tamaño máximo del grafo (valor del campo maxNodos). • Si el número de nodos es menor al tamaño máximo, se asigna el valor false a las celdas correspondientes y se actualiza el campo numVertices

  15. Insertar vértices • Método que inserta n vértices en la tabla si existe espacio para ellos: public void insertaVertice(int n) { if ( n > maxNodos - numVertices ) System.out.println("Error, se supera el número de nodos máximo"); else { for (int i=0; i<numVertices+n; i++) { for (int j=numVertices; j<numVertices+n; j++) matrizAdy[i][j] = matrizAdy[j][i] = false; } numVertices = numVertices + n; } }

  16. a b e c d Grado de salida y entrada de un vértice (I) • Grado de salida: • Dado que las filas representan los vértices origen, el grado de salida de un vértice i es el valor de la suma de la fila i. • Grado de entrada: • Dado que las columnas representan los vértices destino, el grado de entrada de un vértice j es el valor de la suma de la columna j. Grado de salida (a) = 1 Grado de entrada (a)= 2

  17. Grado de salida y entrada de un vértice (II) public int gradoIn(int x) { int gIn = 0; for (int i=0; i<numVertices; i++) //recorrido por filas if (matrizAdy[ i ][ x ]) //manteniendo la posición de la columna en [ j ] gIn++; return gIn; } public int gradoOut(int x) { int gOut = 0; for (int j= 0; j<numVertices; j++) //recorrido por columnas if (matrizAdy[ x ][ j ]) // manteniendo la posición de la fila en [ i ] gOut++; return gOut; }

  18. Incidencia de un vértice y tamaño del grafo • Incidencia: • Grafo no dirigido: la incidencia de un vértice viene dada por su grado de entrada • Grafo dirigido: grado de entrada + grado de salida • Tamaño: • Definido por el número de aristas. Si el grafo es no dirigido, las aristas se cuentan dos veces, luego se ha de dividir entre dos el número de aristas contadas. public int incidencia (int i) { if (!dirigido) return gradoIn(i); else return gradoIn(i)+gradoOut(i); } public int tamano() { int tm = 0; for (int i=0; i<numVertices; i++) for (int j=0; j<numVertices; j++) if (matrizAdy[i][j]) tm++; if (dirigido) return tm; else return tm/2; }

  19. Método que comprueba si un grafo es dirigido • Para comprobar si un grafo es dirigido o no, basta con comprobar si se trata de una matriz simétrica, donde la posición [i, j] = [j,i]. public boolean esDirigido (Grafo g) { boolean dir = true; for (int i=0; i<numVertices; i++) for (int j=0; j<numVertices; j++) if (matrizAdy[i][j] != matrizAdy[j][i]) dir = false; return dir; }

  20. Listas de Adyacencias

  21. Lista de adyacencias En una lista de adyacencias, a cada vértice i se le asocia una lista enlazada con todos los vértices j adyacentes a i. Sólo se reserva memoria para las aristas adyacentes a i. El grafo se representa por medio de un array de n componentes, (n= número de vértices del grafo) donde cada componente constituye la lista de adyacencias correspondiente a cada vértice del grafo. Cada nodo de la lista consta de un campo indicando el vértice adyacente. Si el grafo fuese etiquetado o valorado, habría que añadir un segundo campo para mostrar el valor de la etiqueta o el peso de la arista.

  22. 0 1 0 null 4 1 null 2 3 2 null 3 null 4 null 3 4 1 1 3 0 1 0 Ejemplo

  23. Representación en lista de adyacencias Los vértices se representan mediante índices. a b Vértices: a b c d e Índices: 0 1 2 3 4 e c d • Lista de adyacencias se implementa como un array A de tamaño n: • Cada componente i contiene la lista de nodos adyacentes al vértice i. • Cada nodo de la lista guarda información sobre índice del vértice. • Uso del TAD ListaOrdenada.

  24. Clase Lista • public interface Lista_ord { • boolean estaVacia () ; • Lista copiar(); • void insertar (int x) ; • void eliminarElemento (int x); • int obtenerClave (); • NodoLista obtenerInicio(); • void avanzar (); • boolean busqueda (int x); • } • public class Lista { • public int dato; • public Lista sig; • public Lista () { • dato = 0; • sig = null; • } • }

  25. Clase GrafoLA en JAVA Grafos simples, dirigidos o no dirigidos, no etiquetados public class GrafoLA implements Grafo { private boolean dirigido; private int maxNodos; private int numVertices; private Lista listaAdy [ ]; } • Dos constructores: grafo vacío y grafo de tamaño n. • public GrafoLA (boolean d) { • maxNodos = numVertices = 0; • dirigido = d; • } • public GrafoLA (int n, boolean d) { • dirigido = d; • maxNodos = n; • numVertices = 0; • listaAdy = new Lista[n]; • }

  26. Insertar aristas La inserción de una arista (i, j) en la lista de adyacencias supone insertar un nodo con clave j en la lista con índice i. Si el grafo es no dirigido: arista (i, j) = arista (j, i) Hay que insertar en la lista con índice jel nodo con clave i. • public void insertaArista(int i, int ) { • if ( i >= numVertices ) • System.out.println("Error, no existe el vértice en el grafo"); • else { • listaAdy[i].insertar(j); • if (!dirigido) • listaAdy[j].insertar(i); • } • }

  27. Eliminar aristas La eliminación de una arista (i, j) consiste en eliminar el nodo con clave j de la lista con índice i. Si el grafo es no dirigido, habrá que eliminar el nodo con clave i de la lista con índice j: • public void eliminaArista(int i, int j) { • if ( j >= numVertices ) • System.out.println("Error, no existe el vértice en el grafo"); • else { • listaAdy[i].eliminarElemento(j); • if (!dirigido) • listaAdy[j].eliminarElemento(i); • } • }

  28. Insertar vértices No se permite insertar vértices si se supera el límite de vértices del grafo (valor del campo maxNodos). El método insertarVertices tiene como argumento un entero que indica el número de vértices que se desea añadir al grafo. Si no se supera el número máximo de nodos del grafo, se inicializan las n listas correspondientes a los vértices que se añaden al grafo Se actualiza el campo numVertices del grafo. public void insertaVertice (int n) { if ( n > maxNodos - numVertices ) System.out.println("Error, se supera el número de nodos máximo del grafo"); else { for (int i=numVertices; i<numVertices+n; i++) listaAdy[i]= new Lista(); } numVertices += n; }

  29. Grado de salida y entrada de un vértice (I) Grado de salida de v: Número de elementos de la lista de adyacencia de v. Grado de entrada de v: Número de veces que aparece v en las distintas listas de adyacencia. a b e a null b null c d c null d null e null a d a b b e b b Grado de salida (a) = 1 Grado de entrada (a)= 2

  30. Grado de salida y entrada de un vértice (II) public int gradoIn(int v) { int gIn = 0; for (int i=0; i<numVertices; i++) if (i!=v){ if ( listaAdy[i].busqueda(v) ) gIn++; } return gIn; } public int gradoOut (int i) { //contar los elementos de la lista int gOut=0; NodoLista aux = listaAdy[i].obtenerInicio(); while (aux!=null){ gOut++; aux=aux.obtenerSig(); } return gOut; }

  31. Incidencia de un vértice y tamaño del grafo Incidencia: Grafo no dirigido: incidencia = grado de entrada Grafo dirigido: grado de entrada + grado de salida Tamaño: Definido por el número de aristas (i.e., número de nodos de las distintas listas). Si el grafo es no dirigido, las aristas se cuentan dos veces, luego se ha de dividir entre dos el número de aristas contadas. Uso del método auxiliar numElems. public int incidencia (int i) { if (!dirigido) return gradoIn(i); else return gradoIn(i)+gradoOut(i); } public int tamanno () { int tm = 0; for (int i=0; i<numVertices; i++) { tm += numElems(listaAdy[i]); } if (!dirigido) tm = tm/2; return tm; } static int numElems (Lista lista) { NodoLista aux = lista.obtenerInicio(); int resul = 0; while (aux != null) { resul += 1; aux = aux.obtenerSig(); } return resul; }

  32. Método que comprueba si un grafo es dirigido En un grafo dirigido: (i,j) ≠ (j,i) En un grafo no dirigido: (i,j)=(j,i). Para comprobar si se trata de un grafo dirigido, se comprueba que, para cada par de vértices i,j, el vértice j se encuentra en la lista de adyacencias del vértice i; e igualmente que el vértice i se encuentra en la lista de adyacencias del vértice j. public boolean esNoDirigido () { boolean dir = true; for (int i=0; i<numVertices; i++) for (int j=0; j<numVertices; j++){ if (listaAdy[i].busqueda(j)!=listaAdy[j].busqueda(i)) dir = false; } return dir; }

  33. Imprimir la lista de adyacencias public void imprimirGrafo () { System.out.println("Tamaño máximo del grafo: " + maxNodos + "\n"); System.out.println("El grafo contiene " + numVertices + " vértices: \n"); for (int i=0; i<numVertices; i++) { System.out.print ("vértice " + i + ": "); escribir (listaAdy [i]); } } static void escribir (Lista lista) { NodoLista aux; aux = lista.obtenerInicio(); while (aux != null) { System.out.print(aux.obtenerClave() +", "); aux = aux.obtenerSig(); } System.out.println("FIN"); }

  34. Recorridos de Grafos En profundidad En anchura

  35. Recorrido del Grafo • Un grafo puede ser recorrido en profundidad o en amplitud. • Aspectos que hay que considerar (comparado con el recorrido de árboles): • Puesto que un árbol es un grafo orientado sin circuitos, al avanzar en el recorrido no cabe la posibilidad de que se vuelva a visitar un vértice ya visitado. En el recorrido de un grafo sí cabe la posibilidad de al avanzar visitar un vértice ya visitado. • Partiendo de la raíz de un árbol se pueden visitar todos los vértices, mientras que en un grafo se puede dar la posibilidad de que no se alcancen todos los vértices desde un vértice. Habría que comenzar el recorrido en otro vértice para poder alcanzar todos los vértices.

  36. Recorrido en profundidad (I) • Preferencia a visitar a los vértices conectados con el último visitado. • Recorrido en profundidad: • Parte recursiva que recorre parcialmente un subgrafo a partir de un vértice de inicio • Parte no recursiva que se encarga de relanzar el proceso en cada vértice no visitado. • Vector de valores lógicos para marcar los vértices visitados. • Se utilizan los índices de los vértices para iniciar y marcar el proceso de recorrido.

  37. 2 5 4 3 1 Recorrido en profundidad (II) Se toma como vértice inicial 1, v1← visitado (el conjunto de vértices adyacentes a v1 es 2,3) Se toma vértice 2: v2 ← visitado (el conjunto de vértices adyacentes a v2 es 3,4) Se toma vértice 3 v3 ← visitado (el conjunto de vértices adyacentes a v3 es 1) //v1 ya está visitado por lo que se termina el recorrido en profundidad a partir de v3 Se toma el vértice 4 v4 ← visitado (el conjunto de vértices adyacentes a v4 es 3) //v3 ya está visitado por lo que se termina el recorrido en profundidad a partir del v4. No es posible alcanzar más vértices desde v1, de manera que hay que seleccionar un nuevo vértice desde el que recomenzar la exploración en profundidad. Se toma el vértice 5: v5 ← visitado (el conjunto de vértices adyacentes a v5 es 4) //v4 ya está visitado de manera que se termina el recorrido en profundidad a partir del vértice 5

  38. Recorrido en profundidad (III) public void profundidad (Grafo g) { boolean visitados[] = new boolean[g.numVertices]; for (int i=0;i<g.numVertices;i++) //inicializar vector: todos los campos a false visitados[i]=false; for (int i=0;i<g.numVertices;i++) { //Relanzar el recorrido en cada vértice no visitado if (!visitados[i]) recorrerProfundidad(g, i, visitados); } } public void recorrerProfundidad (Grafo g, int v, boolean[] visitados) { visitados[v] = true; //se marca el vértice v como visitado System.out.println(v); //se examinan los vértices adyacentes a v para continuar el recorrido for (int i=0; i<g.numVertices;i++) { if ((v!=i) && (!visitados[i]) && (g.existeArista(v,i)) ) recorrerProfundidad(g, i, visitados); } }

  39. Recorrido en amplitud • Se elige un vértice no visitado v como punto de partida • Se pasa a visitar cada uno de sus vértices adyacentes • Se continúa visitando los adyacentes a estos últimos y así sucesivamente hasta que no se puedan alcanzar más vértices. • Si queda algún vértice sin visitar, se selecciona y se vuelve a relanzar el proceso. • Es necesario utilizar una estructura de datos cola: • En la cola se van almacenando los vértices a medida que se llega a ellos. • Los vértices se marcan en la cola como visitados • Son tratados cuando se extraen de la cola al tiempo que se introducen en la cola los adyacentes al vértice tratado

  40. public static void amplitud (Grafo g) throws ColaVacia { Cola cola = new Cola(); boolean visitados[] = new boolean[g.obtenerNumVertices()]; int v; //vértice actual for (int i=0;i<g.obtenerNumVertices();i++) //Se inicializa el array visitados[] a false visitados[i]=false; //El recorrido en amplitud se inicia en cada vértice no visitado for (int i=0; i<g.obtenerNumVertices(); i++) { //se pone en la cola el vértice de partida y se marca como visitado if (!visitados[i]){ cola.encolar (i); visitados[i]=true; while (!cola.estaVacia()) { //desencolar, solo mostrar por pantalla v = cola.desencolar (); System.out.println(v); //encolar los nodos adyacentes a v. for (int j=0; j < g.obtenerNumVertices(); j++){ if ((v !=j) && (g.existeArista(v, j) && (!visitados[j])) { cola.encolar( j ); visitados[j]=true; } } } } } }

More Related