Grafos

GRAFOS

ESTRUCTURA DE DATOS

JULIO CESAR NUÑEZ TEJERO INGENIERA EN COMPUTACIÓN

DES CIENCIAS DE LA INFORMACIÓN

TOSHIBA

UNIVERSIDAD AUTONOMA DEL CARMEN

2 Julio Cesa NuñezTejero

Universidad Autónoma del Carmen Ciudad del Carmen, Campeche Campus I

Estructura de Datos DES - Ciencias de la Información

Contenido 1. INTRODUCCIÓN Y CONCEPTOS BÁSICOS ..................................................................................... 3

1.1. OPERACIONES Y SUS RESPECTIVAS DESCRIPCIONES: ....................................................................... 4 1.2. REPRESENTACIONES DE GRAFOS ..................................................................................................... 3

1.2.1. Matriz de adyacencias ......................................................................................................... 4 1.2.2. Listas de adyacencias ......................................................................................................... 6 1.2.3. Lista enlazada de listas de adyacencia.............................................................................. 7

2. ALGORITMOS ..................................................................................................................................... 6

2.1. ÁRBOLES GENERADORES MÍNIMOS ...................................................................................... 6 2.1.1. ALGORITMO DE BORŮVKA ............................................................................................ 10 2.1.2. ALGORITMO DE PRIM ..................................................................................................... 13 2.1.3. ALGORITMO DE KRUSKAL .............................................................................................. 17

2.2. APLICACIONES ......................................................................................................................... 21 2.2.1.1. Televisión por cable ............................................................................................... 21 2.2.1.2. Diseño de circuitos ................................................................................................. 21 2.2.1.3. Conexión de islas ................................................................................................... 21 2.2.1.4. Agrupación de Datos de Expresión Genética ..................................................... 22 2.2.1.5. Aproximaciones Basadas en MST ........................................................................ 22

2.2.2. ÁRBOL GENERADOR MÁXIMO (MaxST) ....................................................................... 23 2.2.3. Problema de la Fiabilidad de la Red................................................................................ 23 2.2.4. Problema del Cuello de Botella ....................................................................................... 24

2.3. ÁRBOLES DE CAMINO MÍNIMO .............................................................................................. 25 2.3.1. ALGORITMO DE DIJKSTRA ............................................................................................ 21 2.3.2. ALGORITMO DE BELLMAN-FORD .................................................................................. 30 2.3.3. ALGORITMO DE WARSHALL-FLOYD ............................................................................. 35 2.3.4. APLICACIONES................................................................................................................. 37

2.3.4.1. Multidifusión ........................................................................................................... 37 2.3.4.2. Aproximaciones Basadas en SPT......................................................................... 38




Introducción y Conceptos Básicos

Un grafo es una entidad matemática introducida por Euler en 1736 para representar entidades (vértices) que pueden relacionarse libremente entre sí, mediante el concepto de arista. Se puede definir un Grafo basado en estas ideas, el cual contiene elementos sobre los que esta definida una relación de vecindad o adyacencia. Un vértice puede relacionarse con cualquier otro vértice y establecer cualquier número de relaciones. Hay muchas situaciones en las cuales el modelado más conveniente de los datos de una aplicación es mediante grafos, por ejemplo la representación de una red de carreteras, calles, telecomunicaciones, electrificación, internet, planificación de tareas, etapas de un proceso industrial, etc. Un grafo G = (V, A) se define por:

• Un conjunto de n vértices, V, a los cuales se hace referencia por sus

• Un conjunto de m aristas, A, que conectan vértices entre sí. Una arista es

el vértice i está conectado con el vértice j. •

mismo). Un subgrafo de G es cualquier grafo G’ = (V, A’) donde A’ sea un subconjunto de A Dependiendo de si el orden de los vértices en las aristas importa o no tenemos:

• conectado con el vértice j no implica que el vértice j esté conectado con el vértice i.

• Grafo no dirigido: El orden no importaEjemplos de grafos y su representación:

El grafo de la figura 1 se define por: V = [1..7], A = { 1,2 , 1,3 , 2,1 , 2,3 , 2,4 , 3,1 , 3,2 , 3,4 , 3,5 , 4,2 , 4,3 , 5,3 , 5,6 , 5,7 , 6,5 , 7,5 }. El grafo de la figura 2 se define por: V = [1...7], A , 2,3 , 2,4 , 3,2 ,

3,5 , 5,6 , 5,7 }.

Grafo no dirigido Grafo dirigido 7

4

5

2 3

6

1

7

4

5

2 3

6

1




En muchas aplicaciones de los grafos las aristas llevan asociada información adicional. En ese caso hablaremos de grafos etiquetados. Si esa información es

numérica y tiene el significado del coste necesario para recorrer esa arista, entonces usaremos el nombre de grafo ponderado o red. Red: Grafo en el que cada arista lleva asociado un coste (longitud)

• Grafo = g/g es un grafo • Vértice = v/v es un vértice de un grafo Nodo Nulo • Rótulo Vértice = R/R es un rótulo de un vértice de un grafo • Rótulo Arco = R/R es un rótulo de un arco de un grafo • Índice = i/i es la dirección que permite encontrar un vértice adyacente

a un vértice dado Índice Nulo

Operaciones y sus respectivas descripciones: Con alcance para hacer recorridos y recavar información del grafo Primer Vértice: Grafo Vértice Primer Vértice (G): Vértice Como el número de vértices de un grafo es finito, se puede hablar de la lista de vértices (siempre se los puede organizar como una lista, sin que esto implique que hay uno distinguido). Esta operación devuelve el primer vértice de la lista de vértices del grafo G. Si G no tiene nodos, devuelve Nodo Nulo. Siguiente Vértice: (Vértice Grafo) Vértice Siguiente Vértice (V,G): Vértice Esta operación devuelve el primer vértice que sigue a V en la lista de vértices del grafo G. Si G no tiene nodos o V=Nodo Nulo se plantea una situación de error. Cuando V es el último vértice de la lista de vértices de G la operación devuelve Nodo Nulo. Primer Adyacente: (Vértice Grafo) Índice Primer Adyacente (V,G): Índice Como el número de vértices de un grafo es finito, obviamente el número de vértices adyacentes a uno dado, también lo es. Por lo tanto se puede hablar de la lista de vértices adyacentes (o lista de adyacentes) a un vértice V (siempre se los puede organizar como una lista, sin que esto implique que hay uno distinguido). Esta operación devuelve el índice del primer vértice de la lista de adyacentes del vértice V del grafo G. Si G no tiene nodos o V=Nodo Nulo se plantea una situación de error. Si V no tiene nodos adyacentes devuelve Índice Nulo. Siguiente Adyacente: (Vértice Índice Grafo) Índice Siguiente Adyacente (V,I,G): Índice




Esta operación devuelve el índice del siguiente vértice adyacente al de índice I de la lista de adyacentes del vértice V en el grafo G. Si V=Nodo Nulo o I=Índice Nulo o G no tiene nodos, se plantea una situación de error. Cuando I es el índice del último adyacente de la lista de adyacentes del vértice V, la operación devuelve Índice Nulo. Vértice: (Índice Grafo) Vértice Vértice (I,G): Vértice Esta operación devuelve el vértice que se encuentra en la dirección I correspondiente a la lista de adyacentes de V. Existirá error si I=Índice Nulo o si G no tiene nodos. Rótulo Vértice: (Vértice Grafo) Rótulo_Vértice Rótulo Vértice (V, G): Rótulo_Vértice Esta operación es sólo aplicable a grafos con vértices rotulados. Entrega la información asociada al vértice V del grafo G. Si G no tiene nodos o si V=Nodo Nulo se plantea una situación de error. Rótulo Arco: (Vértice Vértice Grafo) Rótulo_Arco Rótulo Arco (V1,V2,G)

Rótulo_Arco Esta operación es sólo aplicable a grafos con arcos rotulados. Entrega la información asociada al arco (V1,V2) del grafo G. Si G no tiene nodos o si no

existe el arco (V1,V2) se plantea una situación de error.

Para ampliar el alcance del TDA permitiendo la creación y/o modificación de un grafo, se incorporan las siguientes operaciones: Crear Grafo Nulo: Grafo Grafo Crear Grafo Nulo (G) Al ejecutarse esta operación el grafo G queda sin nodos y en condiciones de recibirlos. Es aplicable a cualquier grafo. Insertar Vértice: (Rótulo_Vértice Grafo) Grafo Vértice Insertar Vértice (R, G): Vértice Esta operación incorpora un nuevo vértice V en el grafo G. Si se trata de un grafo con vértices rotulados, le asocia a V el rótulo R (siempre que se trate de un grafo con vértices rotulados, en caso contrario no debería figurar el argumento R). Devuelve el valor V. Insertar Arco: (Rótulo_Arco Vértice Vértice Grafo) Grafo Índice Insertar Arco (R,V1,V2,G): Índice




Esta operación incorpora un nuevo arco (V1,V2) en el grafo G. Si se trata de un

grafo con arcos rotulados le asocia a dicho arco el rótulo R (siempre que se trate de un grafo con arcos rotulados, en caso contrario no debería figurar el argumento R). Devuelve el valor I que es la dirección del vértice V2, en la lista de

adyacentes a V1 en el grafo G.

Eliminar Vértice: (Vértice Grafo) Grafo Eliminar Vértice (V, G) Esta operación elimina el vértice V del grafo G. Elimina también todos los arcos en los que V está involucrado. Si V no es un vértice de G, G permanece sin modificaciones. Eliminar Arco: (Vértice Vértice Grafo) Grafo Eliminar Arco (V1,V2,G)

Si (V1,V2) es un arco del grafo G entonces esta operación lo elimina, si no el

grafo G permanece sin modificaciones. Si se trata de un multi-grafo, se deberá incorporar un parámetro más que permita identificar el arco a eliminar.



Representaciones de grafos Aunque en general al representar datos de la vida real mediante un grafo los vértices suelen llevar asociada información, en lo que sigue supondremos que esa información se almacena en una lista indexada y por lo tanto podemos hacer referencia a los vértices utilizando únicamente el índice donde están almacenados en esa lista. En lo que sigue las representaciones hacen referencia únicamente a la manera de almacenar las aristas. Las operaciones básicas sobre grafos son las de comprobación de existencia de arista entre dos vértices (o conocer su longitud, si el grafo es etiquetado), recorrer la lista de vértices adyacentes a uno dado, la inserción y borrado de una arista, y la inserción y borrado (junto con las aristas asociadas) de un vértice. En muchas aplicaciones, sin embargo, el conjunto de vértices no varía durante la ejecución. Las dos representaciones principales de grafos son las siguientes:

• Matriz de Adyacencia (MA): Se utiliza una matriz de tamaño n n donde

las filas y las columnas hacen referencia a los vértices para almacenar en cada casilla la longitud entre cada par de vértices del grafo. La celda MA[i, j]

almacena la longitud entre el vértice i y el vértice j. Si su valor es infinito significa que no existe arista entre esos vértices, y MA[i, i] = 0.

• Lista de Adyacencia (LA): Se utiliza un vector de tamaño n (un elemento por cada vértice) donde LA[i] almacena la referencia a una lista de los

vértices adyacentes a i. En una red esta lista almacenará también la longitud de la arista que va desde i al vértice adyacente. Existen varias posibilidades a la hora de representar la lista de vértices: arrays dinámicos, listas enlazadas o usar una lista de adyacencia aplanada: Se almacenan todas las listas de manera contigua en un único vector, VA, de tamaño m, y en el vector LA se almacenan índices al vector VA. La lista de adyacencia del vértice i se encuentra en VA[LA[i] .. LA[i+1]-1]. Esta representación es útil cuando no se vaya a modificar el grafo.

La eficiencia de las operaciones básicas en cada representación es la siguiente:

Operación

Matriz de Adyacencia Lista de Adyacencia

Espacio ocupado (n2) (m+n)

Longitud entre vértices / Existencia de aristas

O(1) O(grado(i))

Recorrido vértices adyacentes a i (n) (grado(i))

Recorrido todas las aristas (n2) (m)

Inserción/borrado arista O(1) O(grado(i))

Inserción/borrado vértice O(n2) O(n)



Según el modelo del grafo, dichos esquemas se deben completar adecuadamente.

Matriz de Adyacencias

Arreglo de

listas

Adyacencia

s

Lista de

Listas de

Adyacencia

s V1

V1

V2

V2

V3 V3

…

Vn

V4

Matriz de adyacencias Se trata de una representación mediante un arreglo de dos dimensiones (matriz). Los índices de la matriz representan los vértices del grafo y cada una de las componentes [i,j] toma un valor lógico según el arco (i,j) pertenezca o no al grafo que representa.

En este caso, los conjuntos Vértice e Índice coinciden. Para el siguiente ejemplo El esquema es:

2 … i

… j

… LM

V1 V2 V3 … Vn

v v

v

v v v v v

v

1 2 i … j … LM

v f



• Si el grafo tiene los vértices rotulados, la estructura se debe completar

con un mapeo Vértice Rótulo_Vértice. • Si el grafo tiene los arcos rotulados, las componentes de la matriz

además deberán alojar esa información. • Si se trata de un multi-grafo, cada una de las componentes [i,j] de la

matriz alojará una lista con los rótulos de los arcos (i,j). Si (i,j) no es un arco del grafo, la componente [i,j] tendrá una lista vacía.

• Si se quiere dar cierta flexibilidad a la representación en relación con el número de vértices, puede declararse una matriz más grande, siempre guardar el grafo desde la componente [1,1] y completar la estructura con un cursor al último vértice. De esta forma se puede trabajar con operaciones de actualización, siempre con la limitación que implica un arreglo como estructura subyacente.



Listas de adyacencias Los índices del arreglo representan los vértices del grafo y cada una de las componentes [i] tiene un enlace a la lista de adyacentes al vértice i. En este caso el tipo Índice está compuesto por las direcciones de las celdas de las listas de adyacentes y el enlace Nulo. Es decir, al siguiente caso:

Le corresponde:

1

2

…

i

…

j

…

k

…

LM

• Si el grafo tiene los vértices rotulados, la estructura se debe completar con un mapeo Vértice Rótulo_Vértice.

• Si el grafo tiene los arcos rotulados, las celdas de las listas de adyacentes deberán alojar dicha información.

• Para dar cierta flexibilidad a la representación respecto del número de vértices, puede declararse un arreglo con más componentes, siempre guardar el grafo desde la componente [1] en lugares consecutivos y completar la estructura con un cursor al último vértice del arreglo. De esta forma se puede trabajar con operaciones de actualización, siempre con la limitación que implica un arreglo como estructura subyacente.



Lista enlazada de listas de adyacencia

Con el propósito de flexibilizar más la propuesta anterior, en este caso se reemplaza el arreglo de vértices por una lista enlazada de vértices. Cada celda tendrá un apuntador a la lista de adyacentes correspondiente. En esta opción cada vértice es la dirección de la celda correspondiente en la lista enlazada de vértices y los índices son las direcciones de las celdas de las listas de adyacentes. Entonces, para el caso:

El esquema de representación es:

• Si el grafo tiene los vértices rotulados, la estructura se debe completar incorporando la información en las celdas de la lista de vértices.

• Si el grafo tiene los arcos rotulados, las celdas de las listas de adyacentes deberán alojar dicha información.



Para el caso de un grafo no dirigido G, se los representa primero como un grafo dirigido equivalente G´ y luego se elige alguna de las estructuras de datos presentadas anteriormente. G´ se obtiene a partir de G de la siguiente manera: Para cada vértice v de G , v es vértice de G´ Para cada arco (v1,v2) de G se cumple que (v1,v2) y (v1,v2) deben pertenecer a

G´ Ejemplo. Dado la siguiente red no dirigida, donde se indican la longitud/coste de

cada arista:

Representación mediante matriz de adyacencia:

1 2 3 4 5 6 7

1 0 8 1

2 8 0 5 2

3 1 5 0 7 5

4 2 7 0

5 5 0 9 3

6 9 0

7 3 0

7

4 3

2 7 5

5

2 5 3

9

8 1

6

1



Representación mediante listas de adyacencia: En las listas se almacenan pares (vértice adyacente, longitud de arista).

1 (2,8)

(3,1)

2 (1,8)

(3,5) (4,2)

3 (1,1)

(4,7) (2,5)

(5,5)

4 (2,2)

(3,7)

5 (3,5)

(7,3) (6,9)

6 (5,9)

7 (5,3)

Representación mediante listas de adyacencia aplanadas (vector de índices, LA, y de adyacencia, VA):

1 2 3 4 5 6 7

1 3 6 10

12

15

16

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

(2,8)

(3,1)

(1,8)

(3,5)

(4,2)

(1,1)

(4,7)

(2,5)

(5,5)

(2,2)

(3,7)

(3,5)

(7,3)

(6,9)

(5,9)

(5,3)



2

5 d

4

1 1

e f

2 1 2

Algoritmos

ÁRBOLES GENERADORES MÍNIMOS Un árbol generador mínimo (MST) de un grafo G con pesos es un árbol generador de G cuya suma de pesos de las aristas es mínima. En otras palabras, un árbol generador mínimo es un árbol constituido por un subconjunto de aristas de un grafo no dirigido, con dos propiedades:

1. Expande el grafo, es decir, incluye todos los vértices del grafo

2. Es mínimo, es decir, el peso total de todos las aristas es lo más pequeño

posible

El problema del árbol generador mínimo se incluye siempre en los libros de texto porque tiene muchas aplicaciones, es un ejemplo importante donde algoritmos ambiciosos siempre alcanzan una solución óptima, y se necesitan estructuras de datos inteligentes para que funcionen eficientemente. Un árbol generador mínimo no es necesariamente único. En todo este capítulo se va a llamar árbol generador mínimo al de peso mínimo. Figura 1: Grafo con pesos;

a 4 b 3 c

g 1 h



2

d

1

e f

1 2

2

d

1 1

e f

2

2

d

f

2

2

d

1

e f

1 2

La figura 2 muestra algunos de los árboles generadores posibles del grafo de la figura 1. Todos ellos tienen un peso total de 14. Figura 2: Algunos árboles generadores mínimos

a b c 3

a 4 b 3 c

g 1 h g 1 h

a 4 b 3 c 4 3

a b c

g 1 h g 1 h



Antes de explorar los algoritmos de MST, se expondrán algunos hechos importantes sobre los árboles generadores. Mediante G + e se denotará el grafo que se obtiene al insertar la arista e en G.



Cualquier par de vértices de un árbol están conectados por un camino único. Dado que el árbol es conexo, cualquier par de vértices en el árbol están conectados por al menos un camino. Sea T un árbol, y se asume que hay dos caminos distintos P1 y P2 desde el vértice u al vértice v. Existe una arista e = (x, y) de P1 que no es

una arista de P2. Se puede ver que (P1 P2) – e es conexo y contiene el camino

Pxy desde el vértice x al vértice y. Pero entonces Pxy + e es un ciclo. Lo cual es una

contradicción. Así, debe de haber al menos un camino entre los dos vértices en el árbol. Sea T un árbol generador de un grafo G, y sea e una arista de G que no está en T. Entonces, T + e contiene un único ciclo. Sea e = (u, v). Dado que T no contiene ciclos, cada ciclo de T + e contiene a e. Además, X es un ciclo de T + e si y sólo si X – e es un camino de u a v en T. Por el lema 1, tal camino es único en T. De esta manera, T + e contiene un único ciclo. En este capítulo se van a estudiar tres algoritmos que se conocen muy bien para resolver el problema del árbol generador mínimo:

• Algoritmo de Borůvka

• Algoritmo de Prim

• Algoritmo de Kruskal Sea F1, F2,…, Fk un bosque de árboles generadores de G, y sea (u, v) el más

pequeño de todas las aristas con solamente un punto final u V(F1). Entonces hay

un árbol generador óptimo de entre todos los árboles generadores que

K contiene a (u, v) y que contiene todas las aristas en U E(Fi ) .



ALGORITMO DE BORŮVKA

En cada paso de Borůvka, cada supervértice selecciona su arista adyacente más pequeño. Estas aristas se añaden al MST, evitando ciclos. Entonces los nuevos supervértices, por ejemplo, los componentes conexos se calculan contrayendo el grafo sobre las aristas que se añaden al MST. Este proceso se repite hasta que solamente queda un supervértice. En otras palabras se contraen n-1 aristas. La unión de estas aristas forma un árbol generador mínimo.

Algoritmo: BORŮVKA

Entrada: Un grafo no dirigido y con peso G = (V, E, w)

Salida: Un árbol generador mínimo T.

T Mientras |T| < n -1 hacer

F Un bosque formado por las aristas más pequeños que inciden en cada vértice de G

G G\ F

T T F



2

5 d

4

1 1

e f

2 1 2

2

5 d

4

1 1

e f

2 1 2

Ejemplo: Figura 3: Ejecución del algoritmo de BORŮVKA sobre el grafo de la figura 1

a c 4 3 (a, b, c, d, e, f)

(g,

g 1 h

(a) (b)

a b c 4 3

(a, b, c, d, e, f)

2

(a, b, c, d, e, f, g, h)

(g, h)

1

h

2

(c) (d) (e)



La figura 3 ilustra la ejecución del algoritmo de BORŮVKA sobre el grafo de la figura 1. En la figura 3(a), cada vértice elegido es la arista más pequeño que incide si causar ciclos. En la figura 3(b), los vértices a, b, c, d, e y f se contraen en un supervértice, y los vértices g y h se contraen en otros supervértices. En la figura 3(d), los dos supervértices se contraen en un supervértice. Todas l a s aristas contraídas constituyen un árbol generador como se muestra en la figura 3(e). Nótese que en cada paso de Borůvka se reduce el número de vértices en un factor de al menos dos. Por lo tanto, el bucle while se ejecutará al menos O (log n) veces. En cada iteración, todas las contracciones se pueden realizar en tiempo O(m). En total, el algoritmo de Borůvka se ejecuta en tiempo O (m log n).



ALGORITMO DE PRIM

Se elige un vértice arbitrariamente y se trabaja con un árbol generador mínimo parcial. En cada paso se añade una arista que conecte con el vértice más cercano pero que no esté todavía en el actual árbol generador mínimo parcial. Así se va formando el árbol generador hasta que el árbol incluye todos los vértices del grafo dado. Esta estrategia es voraz en el sentido de que en cada paso el árbol generador parcial crece añadiéndole la arista más pequeña entre todas las aristas vecinas posibles. Esquema:

1. Empezar en un vértice cualquiera v. El árbol consta inicialmente sólo del nodo v.

2. Del resto de vértices, buscar el que esté más próximo a v (es decir, con la arista (v, w) de coste mínimo). Añadir w y la arista (v, w) al árbol.

3. Buscar el vértice más próximo a cualquiera de estos dos. Añadir ese vértice y la arista al árbol de expansión.

4. Repetir sucesivamente hasta añadir los n vértices.

La solución se construye poco a poco, empezando con una solución “vacía”. Implícitamente, el algoritmo maneja los conjuntos:

1. V: Vértices del grafo.

2. U: Vértices añadidos a la solución.

3. V-U: Vértices que quedan por añadir.

Se usan dos arrays: 1. MAS_CERCANO: Para cada vértice de V-U indica el vértice de U

que se encuentra más próximo.

2. MENOR_COSTE: Indica el coste de la arista más cercana.

Estructura del algoritmo de Prim: C[v, w] Matriz de costes

1. Inicialmente U= {1}. MAS_CERCANO[v]= 1.

MENOR_COSTE[v]= C[1, v], para v= 2..n 2. Buscar el nodo v, con MENOR_COSTE mínimo.

Asignarle un valor muy grande (para no volver a cogerlo). 3. Recalcular MAS_CERCANO y MENOR_COSTE de los nodos

de V-U. Para cada w de V-U, comprobar si C[v, w] es menor que MENOR_COSTE[w].

4. Repetir los dos puntos anteriores hasta que se hayan añadido los n nodos.



Algoritmo: PRIM Entrada: Un grafo no dirigido y con peso G = (V, E, w)

Salida: Un árbol generador mínimo T.

T

Sea r un vértice elegido arbitrariamente del conjunto V.

U {r}

Mientras |U| < n hacer

Encontrar un u U y v V – U tal que la arista (u, v) sea la arista mínimo entre U y V – U.

TT{(u,v)}

T T{v}{v}

Ejemplo La figura 4 ilustra la ejecución del algoritmo de PRIM sobre el grafo de la figura 1. Se empieza por el vértice a. Dado que (a, b) es la arista mínimo que incide sobre a, se incluye en el árbol generador que se está construyendo (figura 4(a)). En la figura 4(b), se añade la arista (b, d) porque es la arista más pequeña entre {a, b} y V – {a, b}. Cuando hay un empate, como en la figura 4(c), cualquier arista más pequeña podría funcionar bien. Se procede de esta forma hasta que se expanden todos los vértices. El árbol generador mínimo definitivo se muestra en la figura 4(h).



2

5 d

4

1 1

e f

2 1 2

2

5 d

4

1 1

e f

2 1 2

Figura 4: Ejecución del algoritmo de Prim sobre el grafo de la figura 1

a b c 4 3

a b c 4 3

2

d 5 4

1 1

e f

2 1 2

g 1 h g 1 h

(a) Se añade (a, b) (b) Se añade (b, d)

a b c 4 3

a b c 4 3

2

d 5 4

1 1

e f

2 1 2

g 1 h g 1 h

(c) Se añade (d, e) (d) Se añade (d, f)



2

d

1 1

f

2

2

5 d

4

1 1

e f

2 1 2

2

5 d

4

1 1

e f

2 1 2

a b c 4 3

a b c 4 3

2

d 5 4

1 1

e f

2 1 2

g 1 h g 1 h

(e) Se añade (f, h) (f) Se añade (g, h)

a b c 4 3

a b c

g 1 h g 1 h

(g) Se añade (b, c) (h) Árbol generador mínimo

El algoritmo de Prim parece que pasa la mayor parte de su tiempo buscando la arista más pequeña para crecer. Un método más directo para encontrar una arista más pequeña consiste en buscar en las listas de adyacentes de los vértices de V; entonces cada iteración cuesta un tiempo del orden O(m). Produciendo un tiempo total de ejecución del orden de O(mn). Utilizando pilas binarias, se puede mejorar a un orden O(m log n). Utilizando pilas de Fibonacci, el algoritmo de Prim se ejecuta en tiempo O(m + n log n).



ALGORITMO DE KRUSKAL

Se crea un bosque donde cada vértice del grafo es inicialmente un árbol. Luego se ordenan según el peso todas las aristas del grafo. Para cada arista (u, v), se realiza lo siguiente: Si el vértice u y v pertenecen a dos árboles diferentes, entonces se añade (u, v) al bosque, combinando los dos árboles en un único árbol. Se procede así hasta que todas las aristas hayan sido procesadas. Esquema: G= (V, A)

1. Empezar con un grafo sin aristas: G’= (V, Ø)

2. Seleccionar la arista de menor coste de A.

3. Si la arista seleccionada forma un ciclo en G’, eliminarla. Si no, añadirla a

G’.

4. Repetir los dos pasos anteriores hasta tener n-1 aristas.

Implementación del algoritmo Necesitamos:

• Ordenar las aristas de A, de menor a mayor: O(a log a).

• Saber si una arista dada (v, w) provocará un ciclo. Una arista (v, w) forma un ciclo si v y w están en la misma componente conexa. La relación “estar en la misma componente conexa” es una relación de equivalencia. Usamos la estructura de relaciones de equivalencia con punteros al padre:

• Inicialización: crear una relación de equivalencia vacía (cada nodo es una componente conexa).

• Seleccionar las aristas (v, w) de menor a mayor. • La arista forma ciclo si: Encuentra(v)=Encuentra(w) • Añadir una arista (v, w): Unión(v, w) (juntar dos componentes conexas en

una).



Algoritmo: KRUSKAL Entrada: Un grafo no dirigido y con peso G = (V, E, w) Salida: Un árbol generador mínimo T.

Ordenar las aristas en E en orden no decreciente de pesos.

T

Crear un conjunto para cada vértice. Para cada arista (u, v) clasificado en orden hacer

x FIND(u)

y FIND(v)

Si x y

entonces T

T {(u, v)}

UNION(x, y)

Ejemplo La figura 5 ilustra la ejecución del algoritmo de Kruskal sobre el grafo de la figura 1. Inicialmente, cada vértice es un árbol del bosque. Las aristas clasificadas en orden son: ((d, e), (g, h), (e, f), (d, f), (b, d), (e, g), (f, h), (b, c), (a, b), (c, h), (a, g)). Como (d, e) une dos árboles distintos en el bosque, de ese modo se combinan los dos árboles A continuación se considera (g, h). El vértice g y el vértice h pertenecen a dos árboles diferentes, por lo tanto se añade la arista (g, h) al bosque como se muestra en la figura 5(b). En la figura 5(d), cuando se procesa (d, f), ambos d y f pertenecen al mismo árbol, por lo tanto, no se hace nada con esa arista. El mínimo árbol generador final se muestra en la figura 5(h).



2

5 d

4

1 1

e f

2 1 2

2

5 d

4

1 1

e f

2 1 2

Figura 5: Ejecución del algoritmo de Kruskal sobre el grafo de la figura 1

a b c 4 3

a b c 4 3

2

d 5 4

1 1

e f

2 1 2

g 1 h g 1 h

(a) Se añade (d, e) (b) Se añade (g, h)

a b c 4 3

a b c 4 3

2

d 5 4

1 1

e f

2 1 2

g 1 h g 1 h

(c) Se añade (e, f) (d) Se añade (b, d)



2

5 d

4

1 1

e f

2 1 2

2

d

1

e f

2 1

2

5 d

4

1 1

e f

2 1 2

a b c 4 3

a b c 4 3

2

d 5 4

1 1

e f

2 1 2

g 1 h g 1 h

(e) Se añade (e, g) (f) Se añade (b, c)

a b c 4 3

a b c 4 3

g 1 h g 1 h

(g) Se añade (a, b) (h) Arbol generador mínimo

Ordenar las aristas en orden no decreciente se realiza en tiempo O(m log m). El tiempo total de ejecución para determinar si una arista junta dos árboles diferentes en el bosque se realiza en tiempo O(m (m, n)), donde es la función inversa de Ackermann. Por lo tanto, el tiempo de ejecución asintótico del algoritmo de Kruskal´s es O(m log m), el cual es el mismo que O(m log n) ya que

log m = (log n), a esta conclusión se llega observando que m= O(n2) y m= (n).



APLICACIONES Los árboles generadores mínimos son útiles en la construcción de redes, para describir la manera de conectar un conjunto de sitios utilizando la menor cantidad total de cable. La mayor parte del trabajo de los árboles generadores mínimos ha sido conducido por las compañías de comunicación.

Televisión por cable Un ejemplo es una compañía de televisión por cable instalando cable a un nuevo vecino. Si se está obligado a enterrar el cable solamente a lo largo de determinados caminos, entonces habría un grafo que represente qué puntos se conectan por esos caminos. Algunos de esos caminos podrían ser más caros porque son más largos o requiere que el cable se entierre a mayor profundidad. Un árbol generador para esos grafos podría ser un subconjunto de esos caminos que no tenga ciclos pero que conecte cada casa. Habría varios árboles generadores posibles. Un árbol generador mínimo podría ser uno con el mínimo coste total.

Diseño de circuitos En el diseño de un circuito electrónico, a menudo es necesario para cablear algunas clavijas juntas para hacerlas eléctricamente equivalentes. Un árbol generador mínimo necesita la menor cantidad de cable para interconectar un conjunto de puntos.

Conexión de islas Supongamos un grupo de islas que queremos conectar con puentes para que sea posible viajar de una isla a cualquier otra del grupo. Más allá, supongamos que el gobierno desea gastarse el mínimo dinero en este proyecto. Los ingenieros son capaces de calcular el coste de un puente de conexión para cada par de islas posibles. El conjunto de puentes que te permiten viajar de una isla a cualquier otra con el mínimo coste para el gobierno es el árbol generador mínimo.



Agrupación de Datos de Expresión Genética Los árboles generadores mínimos también proporcionan una manera razonable de agrupar puntos en el espacio en grupos naturales. Por ejemplo, Ying Xu y sus colaboradores describen un nuevo marco para representar un conjunto de genes multi-dimensionales expresando los datos como un árbol generador mínimo. Una propiedad clave de esta representación es que la expresión de datos de cada agrupación de genes corresponde a un subárbol del MST, el cuál rigurosamente convierte un problema de agrupamiento multidimensional en un problema de partición del árbol. Ellos han demostrado que aunque en las relaciones entre datos están muy simplificadas en la representación MST, no se pierde información esencial en el caso de agrupaciones. Observaron que hay dos ventajas claves en la representación de un conjunto multidimensional de datos sobre un MST. Uno es que la estructura simple de árbol facilita eficientemente la implementación con rigor de algoritmos de agrupación, los cuales de otra manera exigen mucho esfuerzo computacional. La otra es que pueden superar muchos de los problemas con los que se enfrentan los algoritmos de agrupación clásicos ya que un MST basado en agrupaciones no depende del detalle de la forma geométrica de la agrupación. Una nueva herramienta de software llamada EXCAVATOR (Expresión data Clustering Analyse and Visualization Resource”) se ha desarrollado basándose en este nuevo marco. Los resultados del agrupamiento sobre datos de expresión genética (1) de levadura de cerveza (2) en la respuesta de los fibroblastos humanos al suero (3) Arabidopsis en respuesta a la obtención de quitina es muy prometedor.

Aproximaciones Basadas en MST La construcción del árbol generador mínimo (MST) de un grafo es el primer paso para la obtención de soluciones aproximadas a otros problemas. Un ejemplo es el Problema del Viajante (TSP). El enunciado es: Dado G, grafo completo con pesos en las aristas, se desea hallar un ciclo hamiltoniano, es decir que pase una vez por cada vértice, de peso mínimo. Este problema se clasifica como NP-Completo incluso cuando la función de peso satisfaga la desigualdad triangular, por ejemplo, para todos los vértices x, y, z V, w(x, z) w(x, y) + w(y, z). La desigualdad triangular se presenta en muchas situaciones prácticas. Se puede ver que la estrategia siguiente ofrece un algoritmo aproximado con factor 2 de aproximación para el problema del vendedor viajante con la desigualdad triangular. Primeramente, se encuentra un árbol generador mínimo T para el grafo dado. Luego se dobla el MST y se construye un trayecto T’. Finalmente, se añaden atajos para que ningún vértice sea visitado más de una vez, lo cual se hace recorriendo en árbol en preorden. El camino resultante tiene longitud de no más de dos veces el óptimo. Más adelante se verá que las aproximaciones basadas en MST proporcionan una buena aproximación para los problemas de árboles de Steiner.



ÁRBOL GENERADOR MÁXIMO (MaxST) Para algunos problemas prácticos, es necesario considerar los árboles generadores máximos: Si queremos determinar un árbol generador cuyo peso es máximo entre todos los árboles generadores para una red (G, w) dada. Evidentemente, un árbol generador T para (G, w) es máximo si y sólo si T es mínimo para para (G, -w). De ahí que se pueda encontrar un árbol generador máximo reemplazando w por –w y utilizando uno de los algoritmos de Prim, kruskal o Borůvka. Alternativamente, se podría también quedarse con w y solamente reemplazar mímino por máximo en los algoritmos de Prim, Kruskal o Borůvka. Para el algoritmo de Kruskal, se necesita ordenar las aristas en orden decreciente de pesos. Ejemplo de aplicación del algoritmo de MaxST Se considera el problema de enviar información confidencial a n personas. Se define un grafo G con n vértices correspondiente a n personas; dos vértices i y j son adyacentes si es posible enviar información directamente desde i a j. para cada arista ij, sea pij la probabilidad de que la información enviada sea oída por

casualidad; supongamos que estas probabilidades son independientes para cada uno. Ahora se sustituye qij = 1 – pij, es decir, por la probabilidad de que la

información enviada no sea escuchada por casualidad. A fin de enviar información a todas las n personas, se busca un subgrafo generador de G para el que la producción de los qij (sobre las aristas que inciden en el subgrafo) es máxima.

Reemplazando qij por w(ij) = log qij se reduce el problema a encontrar un árbol

generador de máximo peso.

Problema de la Fiabilidad de la Red

Se consideran los vértices del ejemplo anterior como los nodos de una red de comunicación y sea interpretado pij como la probabilidad de que la conexión entre

i y j falle. Entonces un árbol generador máximo es un árbol en que maximiza la probabilidad de que la comunicación no sea interrumpida entre todos los nodos de la red.



Problema del Cuello de Botella

Sea (G, w) una red, donde G es un grafo conexo, y sea

W = V0

e1 V1

e2 V2 …

en Vn ,

Un camino. Entonces c(W) = min {w(ei): i = 1, …, n} se le llama capacidad del camino

W. Para cada par de vértices (u, v) de G, se quiere determinar el camino de u a v con máxima capacidad. El siguiente teorema de Hu reduce el problema del cuello de botella a encontrar un árbol generador máximo. Así, los algoritmos de Prim, Kruskal y Borůvka – modificados para encontrar el árbol generador máximo- se pueden utilizar para resolver el problema del cuello de botella. Sea (G, w) una red sobre un grafo conexo G, y sea T un árbol generador máximo. Entonces, para cada par (u, v) de vértices, el único camino desde u hacia v en T es un camino de máxima capacidad en G.



ÁRBOLES DE CAMINO MÍNIMO Se considera una red no dirigida y conexa con un nodo especial llamado origen o raíz. A cada arista se le asocia una distancia, un número no negativo. El objetivo es encontrar el conjunto de aristas que conecten todos los nodos tal que la suma de las longitudes de las aristas desde el origen a cada nodo es mínimo. Le llamamos árbol de camino mínimo (SPT) que tiene como raíz el origen. Para minimizar las longitudes totales de los caminos, el camino desde la raíz a cada nodo debe ser el camino de conexión mínimo. De otra manera, se sustituye tal camino por el camino mínimo y se consigue un árbol generador menos “pesado” cuyas longitudes totales del camino desde la raíz a todos los nodos son más pequeñas. MST no siempre es un árbol de caminos mínimos. Los árboles de caminos mínimos no son necesariamente únicos. La figura 1 muestra dos árboles de camino mínimo con origen el vértice a para el grafo de la figura 0. La figura 1(a) va desde a a g, y luego desde g a e. En la figura 1(b), se va desde a a b, desde b a d, y desde d a e. Todos estos caminos son de longitud 7, que es la longitud del camino mínimo de a a e. Nótese que el peso total de las aristas de los dos árboles de camino mínimo puede que no sea la misma. Por ejemplo, el peso total de las aristas del árbol de camino mínimo en la figura 1(a) es 18, mientras que el árbol de caminos mínimos en la figura 1(b) es 17. (El peso total de las aristas del árbol generador mínimo es 14). Siempre y cuando todos los pesos de las aristas sean no negativos, el árbol de camino mínimo está bien definido. Desafortunadamente, las cosas se complican cuando se tienen aristas con pesos negativos. Para un grafo no dirigido, un camino se vuelve mínimo cuando repetidamente se añade una arista con peso negativo a él. En esta situación, un camino mínimo que contiene una arista con peso negativo no está bien definido ya que siempre se puede encontrar un camino con menor peso yendo hacia atrás y así sucesivamente sobre aristas de peso negativo. Se considera la arista de la figura 2. En este grafo, la arista (d, e) tiene peso negativo. Como en un grafo no dirigido una arista puede ser atravesado en ambos sentidos, un camino que repetidamente utiliza (d, e) reducirá su longitud. Sin embargo, para un grafo dirigido, siempre y cuando no existan ciclos con peso negativo que se puedan alcanzar desde la raíz, los pesos del camino mínimo están bien definidos. Así, cuando se habla sobre tópicos relacionados con caminos mínimos, habitualmente se centran en resolver problemas sobre grafos dirigidos. Sin embargo, la mayor parte de los algoritmos pueden ser fácilmente adaptados a grafos no dirigidos. A continuación se describen algoritmos para construir árboles de caminos mínimos. El algoritmo de Dijkstra asume que todos los pesos del grafo son no negativos. Sin embargo, el algoritmo de Bellman-Ford permite pesos negativos en las aristas del grafo. Si no hay ciclo con pesos negativos, el algoritmo de Bellman- Ford genera el camino mínimo y sus pesos. De lo contrario, el algoritmo detecta ciclos negativos e



2

5 d

4

1 1

e f

2 1 2

2

5 d

4

1 1

e f 2 1 2

indica que no existe solución.

Figura 0: Ejemplo de grafo no dirigido y con pesos

a 4 b 3 c

g 1 h

Figura 1: Árboles de caminos mínimos con raíz en el vértice a para el grafo de la figura 0.

a 4 b 3

c

a b c 4 3

2

d 5 4

1 1

e f

2 1 2

g 1 h g 1 h

(a) (b)



2

5 d

4

-1 e

1

f

2 1 2

Figura 2: Grafo no dirigido con una arista con peso negativo.

a 4 b 3 c

g 1 h



ALGORITMO DE DIJKSTRA

El algoritmo de Dijkstra resuelve el problema de encontrar el camino mínimo desde un origen a un destino. Resulta que uno puede encontrar el camino mínimo desde un origen dado a todos los vértices de un grafo al mismo tiempo; de ahí, este problema a veces se llama el problema del camino mínimo con un origen único. De hecho, este algoritmo se puede utilizar para entregar el conjunto de aristas que conectan todos los vértices tal que la suma de las longitudes de las aristas desde el origen hasta cada nodo sea mínimo. Para cada vértice v V, el algoritmo de Dijkstra mantiene un atributo [v], el cual es un límite superior del peso del camino mínimo desde el origen a v. Se llama [v] al camino mínimo estimado. Inicialmente, el camino mínimo estimado de todos los vértices restantes al vértice origen se fija a . El algoritmo de Dijkstra también mantiene el conjunto S de vértices cuyos pesos del camino mínimo definitivo desde el origen todavía no se ha determinado. El algoritmo selecciona repetidamente el vértice u S con el mínimo camino mínimo estimado y reevalúa el camino mínimo estimado de los vértices adyacentes a u. La reevaluación es a menudo referida a un paso de generación. Una vez que el vértice se elimina de S, se determina el peso del camino mínimo desde el origen y el algoritmo termina.



1

5 d

4

1 1

e f

2 1 2

Entrada: Un grafo dirigido y con peso G = (V, E, w); Un vértice origen s.

Salida: Un árbol generador T con el camino mínimo con raíz s.

Para cada vértice v V hacer

[v]

[v] NIL

[s] 0

T

S V

Mientras S hacer

Elegir u S con el mínimo [u]

S S - {u}

Si u s entonces T T {( [u], u)}

Para cada vértice v adyacente a u hacer Si

[v] > [u] + w(u, v) entonces

[v] [u] + w(u, v)

[v] u

Ejemplo:

Figura 3: Grafo dirigido y con pesos

a 4 b 3 c

g 1 h



0 4

1

5 d

4

1 1 e f

2 1 2

5

4 7

1

5 5 d

4

1 1 e

2

f

1 2

5

Figura 4: Se elige el vértice a, y las aristas (a, b) y (a, g) se expanden.

a 4 b 3 c

g 1 h Figura 5: Se elige el vértice b, y las aristas (b, c) y (b, d) se expanden. La arista (a, b) se añade al árbol de camino mínimo.

a 4 b 3 c

g 1 h



7

1

5 5 d

4

1 1 e f

6

2 1 2

6

7

1

5 5 d

4

1 1 e f

7

2 1 2

5

Figura 6: Se elige el vértice g, y las aristas (g, e) y (g, h) se expanden. La arista (a, g) se añade al árbol de camino mínimo.

a b c

g 1 h

Figura 7: Se elige el vértice d, y la arista (d, e) se expande. La arista (b, d) se añade al árbol de camino mínimo.

a b c

g 1 h



7

1

5 d

4

1 1 e f

6 7 2 2 1

7

1

5 d

4

1 1 e f

6 2 2 1

6

7

1

5 d

4

1 1 e f

7

2 1 2

Figura 8: Se elige el vértice h. La arista (g, h) se añade al árbol de camino mínimo.

a b c

g 1 h

Figura 9: Se elige el vértice e, y la arista (e, f) se expande. La arista (d, e) se añade al árbol de camino mínimo.

a b c

g 1 h Figura 10: Se elige el vértice c, y la arista (c, h) se expande. La arista (b, h) se añade al árbol de camino mínimo.

a b c 4 3

g 1 h



1

5 d

4

1 1 e f

7 2 2 1

1

5 d

4

1 1

e f

-3 1

2

1

5 d

1

e f

1

Figura 11: Se elige el vértice f, y las aristas (f, d) y (f, d) se expanden. La arista (e, f) se añade al árbol de camino mínimo.

a b c 4 3

Figura 12: Arbol de camino mínimo construido mediante el algoritmo de Dijkstra para el grafo de la figura 3.

a b c 4 3

g 1 h Figura 13: Grafo dirigido, con pesos y con una arista con peso negativo

a b c 2 2

g 1 h



1

5 d

1

e 1

f

1

5 d

4

1 1

e f 5 2

-3 1

5 6

1

5 d

e

-3 1

f

2

Figura 14: Fallo con el algoritmo de Dijkstra.

a b c 2 2

1

Figura 15: Árbol de camino mínimo erróneo.

a 2 b 2 c

g 1 h Figura 16: Árbol de camino mínimo correcto.

a b c 2 2

g h



Se considera el grafo de la figura 3. La siguiente figura ilustra como funciona el algoritmo de Dijkstra al construir el árbol de camino mínimo con raíz en el vértice a. Inicialmente, todos los valores [.] son , excepto [a] = 0. El conjunto S contiene todos los vértices del grafo. El vértice a, que se muestra como vértice sombreado en la figura 4, tiene el mínimo valor y se elige como vértice u en el bucle while. Se elimina a de S. Entonces las aristas (a, b) y (a, g), que se muestran con líneas de puntos, se expanden. En la figura 5, el vértice sombreado b tiene el mínimo valor entre todos los vértices de S y se elige como vértice u en el bucle while. Se elimina b de S. La arista en negro (a, b) se añade al árbol de camino mínimo que se está construyendo, y las aristas (b, c) y (b, d) se expanden. Ambos vértices d y g en la figura 6 tienen el mínimo valor entre todos los vértices de S. Se elige g como vértice u en el bucle while. Se elimina g de S. La arista en negro (a, g) se añade al árbol de camino mínimo, y las aristas con líneas discontinuas (g, e) y (g, h) se expanden.

Dado que el vértice d en la figura 7 tiene un valor mínimo entre todos los vértices de S, se elige el vértice u en el bucle while. Se elimina d de S. La arista en negro (b, d) se añade al árbol de camino mínimo, y la arista (d, e) con líneas discontinuas se expande. Ambos vértices e y h en la figura 8 tienen el mínimo valor entre todos los vértices de S. Ahora se elige h como vértice u en el bucle while. Se elimina h de S. La arista en negro (g, h) se añade al árbol de camino mínimo. Ninguna arista se expande. Ahora el vértice e en la figura 9 tiene el mínimo valor entre todos los vértices de S. Se elige u como vértice en el bucle while. Se elimina e de S. La arista en negro (d, e) se añade al árbol de camino mínimo que se está construyendo y la arista de líneas discontinuas (e, f) se expande. Ambos vértices c y f en la figura 10 tienen el mínimo valor entre todos los vértices de S. Se elige c como vértice u en el bucle while. Se elimina c de S. La arista en negro (b, c) se añade al árbol de camino mínimo y la arista de líneas discontinuas (c, h) se expande. Ahora el vértice f es el único vértice en S (figura 11), y se elige como vértice u en el bucle while. Se elimina f de S. La arista en negro (e, f) se añade al árbol de camino mínimo, y las aristas (f, d) y (f, h) con líneas discontinuas se expanden. En la figura 12 se muestra el árbol de camino mínimo construido mediante el algoritmo de Dijkstra. Se puede observar en el ejemplo anterior que una vez que el vértice se elimina de S, su valor permanece invariable. Esto es cierto siempre y cuando todos los pesos



de las aristas sean no negativos. El fundamento detrás de esto es muy directo porque siempre se elige el vértice en S con el mínimo valor . Sin embargo, esto puede no mantenerse en grafos dirigidos con pesos negativos entre aristas. El algoritmo de Dijkstra selecciona el vértice u S con el mínimo camino mínimo estimado y reevalúa el camino mínimo estimado para todos los vértices adyacentes a u. En el caso peor, la complejidad mediante el algoritmo de Dijkstra depende de la manera de encontrar el nodo con el mínimo camino mínimo estimado. Una implementación sencilla que examina todos los nodos de S para

Encontrar la mínima ejecución en tiempo O(n2). Una modificación del algoritmo de Dijkstra, donde el mínimo se puede encontrar usando pilas binarias con tiempo O(log n), por lo que el tiempo de la ejecución total es del orden de O(m log n). Usando pilas de Fibonacci, se puede conseguir un tiempo de ejecución del orden de O(m + n log n). La figura 13 muestra un ejemplo de un grafo no dirigido con aristas con peso negativo que para el que el algoritmo de Dijkstra produce una respuesta incorrecta. Al aplicar el algoritmo de Dijkstra al grafo de la figura 13, se alcanzará el estado que se muestra en la figura 14. Dado que la arista (g, e) es de peso negativo -3, el peso del camino (a, g, e) es 5 - 3 = 2. El cual es mejor que el peso del camino mínimo final (a, b, d, e), que es de peso total 4. Además, la arista (e, f) se ha expandido. No hay manera mediante el algoritmo de Dijkstra de volver a expandir todas las aristas afectados por un efecto dominó. El grafo del la figura 15 muestra el árbol de camino mínimo erróneo que se ha obtenido mediante el algoritmo de Dijkstra. Nótese que (g, e) es de peso negativo, y está ausente en el árbol de camino mínimo construido mediante el algoritmo de Dijkstra. El árbol de camino mínimo correcto se muestra en la figura 16.



ALGORITMO DE BELLMAN-FORD

Los algoritmos de caminos mínimos aprovechan generalmente la propiedad de que un camino mínimo entre dos vértices contiene otros caminos mínimos dentro de él. Esta propiedad de subestructura óptima admite ambas; la programación dinámica y el método voraz. Se ha visto que el algoritmo de Dijkstra puede fallar cuando se calcula el árbol de caminos mínimos cuando el grafo tiene alguna arista con peso negativo. El algoritmo de Bellman-Ford funciona de una forma más general que el algoritmo de Dijkstra: resuelve el problema del árbol de camino mínimo incluso cuando el grafo tiene aristas negativos. Si hay un ciclo con pesos negativos, el algoritmo indica que no existe solución. Recalcar que el algoritmo de Dijkstra únicamente extiende aquellas aristas que inciden en los vértices elegidos con el mínimo camino estimado. El fallo del algoritmo de Dijkstra para grafos con aristas con pesos negativos se debe al hecho de que no se calcula el efecto dominó causado por aristas negativas. Si se revisa la figura 14 otra vez, y se promocionara el efecto de la arista negativa hacia delante, se podría haber construido un árbol de camino mínimo correcto. Esto sirve de ejemplo al diseño del algoritmo de Bellman-Ford el cual expande todas las aristas en cada iteración. Inicialmente, el camino mínimo estimado del resto de vértices excepto el origen se asigna . Luego el algoritmo realiza n-1 pasadas sobre todas las aristas del grafo. En cada pasada, si [v] > [u] + w(u, v), entonces se asigna a el valor de [v] a

[u] + w(u, v) y se modifica el predecesor del vértice v. Una importante

característica del algoritmo de Bellman-Ford es que en la iteración kesima, el camino mínimo estimado para el vértice v, por ejemplo, [v], es igual a la longitud del camino mínimo desde el origen a v con k aristas como máximo. Si después de n -1 pasadas, existe una arista (u, v) tal que [v] > [u] + w(u, v), entonces se ha detectado un ciclo negativo. De otra forma, para todos los restantes vértices excepto el origen, se construye el árbol de camino mínimo añadiendo las aristas a partir de su predecesor a ellos.



Algoritmo: BELLMAN-FORD Entrada: Un grafo dirigido y con peso G = (V, E, w); Un vértice origen s. Salida: Un árbol generador T con el camino mínimo con raíz s.

Para cada vértice v V hacer

[v]

[v] NIL

[s] 0

Para i 0 hasta n – 1 hacer Para

cada (u, v) E hacer

Si [v] > [u] + w(u, v) entonces

[v] [u] + w(u, v)

[v] u

Para cada (u, v) E hacer

Si [v] > [u] + w(u, v) entonces Output

“Existe un ciclo negativo” Exit

T

Para cada v V – s hacer

T T {( [v], v)} El algoritmo de Bellman-Ford se ejecuta en tiempo O(m n) ya que hay O(n) iteraciones, y cada iteración se realiza en tiempo O(m). La corrección obedece al

hecho de que en la iteración kesima, el camino mínimo estimado para cada vértice es igual a la longitud del camino mínimo desde el origen a ese vértice con k aristas como máximo. Ya que un camino simple en G contiene al menos n-1 aristas, el camino mínimo estimado se estabiliza después de n-1 iteraciones a menos que exista un ciclo negativo en el grafo. Las siguientes figuras muestran cómo funciona la ejecución del algoritmo de BELLMAN-FORD. En la figura 13, las aristas con líneas oscuras registran que



0 2

1

5 d

4

1 1 e

-3 1

f

2

5

aquellos que causan algún efecto en la generación. Inicialmente, [a] = 0. En la figura 17, la generación de la arista (a, b) cambia [b] de a 2; y la generación de la arista (a, g) cambia [g] de a 5. El camino mínimo estimado [a], [b] y [g] están finalizados. El camino mínimo estimado [c], [d], [e], [f] y [h] son todavía ya que sus correspondientes vértices no pueden ser alcanzados desde el vértice a por un camino con sólo una arista. En la figura 18, la generación de la arista (b, c) cambia [c] de a 4; la generación de la arista (b, d) cambia [d] de a 3; la generación de la arista (g, e) cambia [e] de a 2; y la generación de la arista (g, h) cambia [h] de a 6. Hasta esta etapa, el camino mínimo estimado [a], [b], [c], [d], [e] y [g] están finalizados. El camino mínimo estimado [f] es todavía ya que el vértice f no puede ser alcanzado desde el vértice a por un camino con al menos dos aristas, y el camino mínimo estimado [h] será modificado posteriormente. En la figura 19, la generación de la arista (e, f) cambia [f] de a 3. En la figura 20, la generación de la arista (f, h) cambia [h] de 6 a 5. La figura 21 muestra el árbol final de camino mínimo construido mediante la aplicación del algoritmo de Bellman-Ford. Ejemplo: Figura 17: Los caminos mínimos estimados [b] y [g] se modifican.

a b c

g 1 h



0 2 4

1

5 3 d

4

1 1 e

-3 2

1

f

2

5 6

0 2 4

1

5 3 d

4

1 1 e

-3 2 3

1

f

2

5 6

0 2 4

1

5 d

3 4

1 1 e

-3

f 2 3

1 2

5 5

Figura 18: Los caminos mínimos estimados [c], [d], [e] y [h] se modifican.

a b c

g 1 h

Figura 19: El camino mínimo estimado [f] se modifica.

a b c

g 1 h

Figura 20: El camino mínimo estimado [h] se modifica.

a b c 2 2

g 1 h



0 2 4

1

5 d

3 4

1 1

e

-3

f 2 3

1 2

5 5

Figura 21: Árbol de camino mínimo construido mediante el algoritmo de Bellman- Ford.

a b c 2 2

g 1 h



ALGORITMO DE WARSHALL-FLOYD

El algoritmo de Floyd-Warshall compara todos los posibles caminos a través grafo entre cada par de vértices. Se permiten aristas con pesos negativos y se supone que no hay ciclos de peso negativo para poder aplicar el aplicar este algoritmo.

El algoritmo es capaz de hacer esto con sólo V3 comparaciones (esto es notable

considerando que puede haber hasta V2 aristas en el grafo, y que cada combinación de aristas se prueba). Lo hace mejorando paulatinamente una estimación del camino mínimo entre dos vértices, hasta que se sabe que la estimación es óptima. Sea un grafo G con conjunto de vértices V, numerados de 1 a N. Sea además una función caminoMinimo(i,j,k) que devuelve el camino mínimo de i a j usando únicamente los vértices de 1 a k como puntos intermedios en el camino. Ahora, dada esta función, nuestro objetivo es encontrar el camino mínimo desde cada i a cada j usando únicamente los vértices de 1 hasta k + 1. Hay dos candidatos para este camino: un camino mínimo, que utiliza únicamente los vértices del conjunto (1...k); o bien existe un camino que va desde i hasta k + 1, después de k + 1 hasta j que es mejor. Sabemos que el camino óptimo de i a j que únicamente utiliza los vértices de 1 hasta k está definido por caminoMinimo(i,j,k), y está claro que si hubiera un camino mejor de i a k + 1 a j, la longitud de este camino sería la concatenación del camino mínimo de i a k + 1 (utilizando vértices de (1...k)) y el camino mínimo de k + 1 a j (que también utiliza los vértices en (1...k)). Por lo tanto, podemos definir caminoMinimo(i,j,k) de forma recursiva:

caminoMinimo(i, j, k) = min(caminoMinimo(i, j, k-1),

caminoMinimo(i, k, k-1) + caminoMinimo(k, j, k-

1)); caminoMinimo(i, j, 0) = pesoArista(i, j);

Esta fórmula es la base del algoritmo Floyd-Warshall. Funciona ejecutando primero caminoMinimo(i,j,1) para todos los pares (i,j), usándolos para después hallar caminoMinimo(i,j,2) para todos los pares (i,j)... Este proceso continúa hasta que k = n, y habremos encontrado el camino mínimo para todos los pares de vértices ( i,j) usando algún vértice intermedio.



Algoritmo Warshall Floyd Convenientemente, cuando calculamos el k-esimo caso, se puede sobrescribir la información salvada en la computación k -1. Esto significa que el algoritmo usa memoria cuadrática. Hay que cuidar la inicialización de las condiciones: /* Suponemos que la función pesoArista devuelve el coste del camino que va de i a j (infinito si no existe). También suponemos que n es el número de vértices y pesoArista(i,i) = 0 */ int camino[ ][ ];

/* Una matriz bidimensional. En cada paso del algoritmo, camino[i][j] es el camino mínimo de i hasta j usando valores intermedios de (1…k-1). Cada camino[i][j] es inicializado a pesoArista(i,j) */

procedimiento FloydWarshall ()

para k: = 0 hasta n − 1

para todo (i,j) en (0...n − 1) camino[i][j] = mín ( camino[i][j], camino[i][k]+camino[k][j]);

Comportamiento con Ciclos Negativos Para que haya coherencia numérica, Floyd-Warshall supone que no hay ciclos negativos (de hecho, entre cualquier pareja de vértices que forme parte de un ciclo negativo, el camino mínimo no está bien definido porque el camino puede ser infinitamente pequeño). No obstante, si hay ciclos negativos, Floyd-Warshall puede ser usado para detectarlos. Si ejecutamos el algoritmo una vez más, algunos caminos pueden decrementarse pero no garantiza que, entre todos los vértices, caminos entre los cuales puedan ser infinitamente pequeños, el camino se reduzca. Si los números de la diagonal de la matriz de caminos son negativos, es condición necesaria y suficiente para que este vértice pertenezca a un ciclo negativo.



APLICACIONES El problema del árbol de caminos mínimos aparece en la práctica y se presenta como un subproblema en muchos algoritmos de optimización de redes. El árbol de camino mínimo se utiliza mucho en multidifusión de IP y en algunas de las aplicaciones a nivel de multidifusión para algoritmos de ruteo.

Multidifusión La multidifusión es uno de los mecanismos por el que el poder de Internet puede ser más utilizado de una manera eficiente. Cuando más de un receptor está interesado en recibir una transmisión desde un remitente o un conjunto de remitentes, la multidifusión es el mecanismo más eficiente y viable. El ruteo de la multidifusión se refiere a la construcción de un árbol con raíz en el origen y que se extiende a todos los destinatarios. Generalmente, hay dos tipo de árboles; árboles de Steiner y árboles de caminos mínimos. Los árboles de Steiner o árboles de grupos compartidos, tienden a minimizar el coste total del árbol resultante. Los árboles de caminos mínimos o árboles basados en el origen tienden a minimizar el coste de cada camino desde el origen a cualquier destino. A continuación, se describe brevemente los dos protocolos muy conocidos de ruteo: Protocolo de Ruteo de Información y Primer Camino mínimo Abierto (OSPF). RIP es un protocolo de vector de distancias que permite el ruteo para intercambiar información sobre destinos para rutas de computación a través de la red. Los destinos pueden ser redes o un destino especial utilizado para convertir a una ruta por defecto. En RIP, los algoritmos de Bellman-Ford hacen que cada router periódicamente realice un broadcast de sus tablas de ruteo a todos sus vecinos. Por lo tanto, el router conoce las tablas de sus vecinos y decide a qué vecino destino remite un paquete. OSPF es un protocolo de ruteo desarrollado por el Protocolo de Internet (IP) para redes. OSPF se creó porque a mediados de los 80, RIP fue cada vez más incapaz de servir a las extensas y heterogéneas redes de Internet. Como la mayor parte de los algoritmos que unen estados, OSPF utiliza un modelo de grafo teórico de red topológica para calcular los caminos mínimos. Cada router periódicamente publica información acerca del estado de sus conexiones. OSPF propaga información sobre las adyacencias a todos los routers de la red donde cada router localmente calcula los caminos mínimos por el algoritmo de Dijkstra.

Aproximaciones Basadas en SPT Además de las aplicaciones a problemas de ruteo en redes, los algoritmos de árboles de caminos mínimos podrían también servir como una buena aproximación para algunos problemas NP-Completos. Por ejemplo, para árboles de caminos mínimos con raíz en algún vértice es una 2-aproximación para el problema del árbol generador con coste mínimo de ruteo (MRCT), el cual es un problema NP-Completo.

BIBLIOGRAFIA

http://es.wikipedia.org/wiki/Algoritmo_de_Floyd-Warshall

http://imp.act.uji.es:8080/algoritmica/repo/Tocho3 http://www.dma.fi.upm.es/gregorio/grafos/ArbolesOptimos/descargas/Memoria_Teoria.pdf http://www.ing.ula.ve/~aguilar/actividad-docente/AYDA/Clase4MiniSem.pdf

http://es.wikipedia.org/wiki/Algoritmo_de_Floyd-Warshall

http://imp.act.uji.es:8080/algoritmica/repo/Tocho3

http://www.dma.fi.upm.es/gregorio/grafos/ArbolesOptimos/descargas/Memoria_Teoria.pdf

http://www.dma.fi.upm.es/gregorio/grafos/ArbolesOptimos/descargas/Memoria_Teoria.pdf

http://www.ing.ula.ve/~aguilar/actividad-docente/AYDA/Clase4MiniSem.pdf

Grafos

Documents

Transcript of Grafos