Unidad 5.doc

UNIVERSIDAD TECNOLÓGICA NACIONAL

FACULTAD REGIONAL RESISTENCIA

INGENIERÍA EN SISTEMAS

DE INFORMACIÓN

GESTIÓN DE DATOS

APUNTES TEÓRICOS

Unidad 5: TAD Grafo

Profesor Teoría: Ing. Carolina Orcola

Universidad Tecnológica Nacional Ingeniería en Sistemas de InformaciónFacultad Regional Resistencia GESTIÓN DE DATOS

Índice

Unidad 4: El TAD Grafo...................................................................................................................3

Conceptos y Definiciones...............................................................................................................3

Definiciones relacionadas con grafos.........................................................................................4

Representación de los Grafos........................................................................................................4

Matriz de adyacencia.................................................................................................................4

Lista de Adyacencia...................................................................................................................6

Recorridos de un Grafo..................................................................................................................7

Recorrido en Anchura o Amplitud..............................................................................................7

Recorrido en Profundidad..........................................................................................................8

Algoritmos fundamentales con Grafos...........................................................................................9

Algoritmo de Dijkstra..................................................................................................................9

Algoritmo de Floyd...................................................................................................................10

Ejemplo de algoritmo Floyd......................................................................................................12

Ejemplo de algoritmo Dijkstra...................................................................................................13

Algoritmo de Prim.....................................................................................................................14

Año 2008 Página 2


Unidad 4: El TAD GrafoUnidad 4: El TAD Grafo

Con los árboles binarios se han representado relaciones entre objetos en las que existe una jerarquía. Con frecuencia es necesario representar relaciones arbitrarias entre objetos de datos. Los grafos se clasifican en dirigidos y no dirigidos y son modelos naturales de tales relaciones. Así, los grafos se usan para representar redes de alcantarillado, redes de comunicaciones, circuitos eléctricos, etc.. Una vez modelado el problema mediante un grafo se pueden hacer estudios sobre diversas propiedades. Para ello se utilizan algoritmos concretos que resuelvan ciertos problemas.

La teoría de grafos ha sido aplicada en el estudio de problemas que surgen en áreas diversas de las ciencias, como la química, la ingeniería eléctrica y la investigación operativa. El primer paso siempre será representar el problema como un grafo. En esta representación cada elemento, cada objeto del problema, forma un nodo. La relación, comunicación o conexión entre los nodos da lugar a una arista, que puede ser dirigida o bidireccional (no dirigida). En la figura aparece una red de comunicaciones.

Conceptos y Definiciones

Un Grafo consiste en un conjunto de vértices o nodos V y un conjunto de arcos A. Se representa con el par G = {V, A}.

En la figura de la izquierda tenemos un ejemplo de un grafo no dirigido G = {V, A} cuyo conjunto de vértices es V = {1, 2, 3, 4, 5} y el conjunto de arcos es A = {(1, 2), (2, 1), (2, 5), (5, 2), (5, 4), (4, 5), (4, 3), (3, 4), (3, 1), (1, 3)}.

En la figura de la derecha, tenemos un grafo dirigido G = {V, A}, cuyo conjunto de vértices está dado por V = {A, B, C, D, E} y cuyo conjunto de

arcos dirigidos es A = {(A, B), (A, C), (B, D), (D, E), (E, C), (C, E)}.

Un arco o arista está formado por un par de nodos y se escribe (u, v), siendo u y v el par de nodos. Un grafo es dirigido (dígrafo) si los pares de nodos que forman los arcos son ordenados, y se representan u v.

Un grafo no dirigido es aquel en que los arcos están formados por pares de nodos no ordenados, no apuntados, y se representa u – v.

Dado el arco (u, v) en un grafo, se dice que los vértices u y v son adyacentes. Si el grafo es dirigido, el vértice u es adyacente al vértice v; si no es dirigido u es adyacente a v y v es adyacente a u.

Un arco tiene a veces asociado un factor de peso, en cuyo caso se dice que es un grafo valorado.

Pensemos por ejemplo en un grafo formado por diversos pueblos que forman una región, cada par de pueblos

Año 2008 Página 3


puede estar unido o no por un camino vecinal, y un factor de peso puede ser la distancia que los une en km. Este es un grafo valorado no dirigido.

Definiciones relacionadas con grafos

El grado es una cualidad que se refiere a los nodos de un grafo. En un grafo no dirigido el grado de un nodo v, grado (v), es el número de aristas que contiene a v. En un grafo dirigido se distingue entre grado de entrada y grado de salida; grado de entrada de un nodo v, gradent (v), es el número de arcos que llegan a v, mientras que grado de salida, gradsal (v), es el número de arcos que salen de v. La diferencia entre arco y arista es que arista son arcos hacia ambos sentidos.

En los ejemplos sería: Grado(Resistencia)= 4; Grado(1)= 2; Gradent(E)= 2; Gradsal(E)= 1.

Un camino P en un grafo G de longitud n desde un vértice v0 a vn es la secuencia de n+1 vértices:

P = (v0, v1, v2, ..., vn)

tal que (vi, vi+1) Î A (arcos) para 0 <= i <= n. La longitud del camino es el número de arcos que lo forman.

Un camino P = (v0, v1, v2, ..., vn) es simple si todos los vértices que forman el camino son distintos, pudiendo ser iguales únicamente v0y vn, los extremos del camino.

Un ciclo es un camino simple cerrado, es decir que v0= vn, y la longitud de dicho camino es >= 2.

Un grafo no dirigido G es conexo si existe un camino entre cualquier par de nodos que forman el grafo. En el caso de ser un grafo dirigido podemos distinguir entre fuertemente conexo y conexo. Un grafo dirigido es fuertemente conexo si existe un camino entre cualquier par de nodos que forman el grafo; un grafo dirigido es conexo si existe una cadena que une cualquier par de vértices, es decir, si no es fuertemente conexo pero su grafo subyacente (sin dirección en los arcos) es conexo.

Un grafo dirigido que no es fuertemente conexo, puede tener componentes fuertemente conexas incluidas en él, esto es un subconjunto de vértices que cumplen con la condición de fuertemente conexos. En el ejemplo, el subconjunto {F, G, H, I} es una componente fuertemente conexa del grafo dirigido.

Un punto de articulación de un grafo no dirigido es un vértice v que tiene la propiedad de que si se elimina junto a sus arcos, la componente conexa en la que está el vértice se divide en dos o más componentes. En el ejemplo, el vértice E es un punto de articulación.

Representación de los Grafos

A pesar de los tipos de dato para representar un grafo en memoria, se debe tener en cuenta que se debe representar un número (finito) de vértices y de arcos que unen dos vértices. Se puede elegir una representación secuencial, mediante arreglos; o bien una representación dinámica mediante estructuras multienlazadas. La representación mediante arreglos se conoce como matriz de adyacencia, la representación dinámica se denomina lista de adyacencia. La elección de una forma de representación o de otra dependerá de las operaciones que se apliquen sobre los vértices y los arcos del grafo.

Matriz de adyacencia

Sea G = (V, A) un grafo de n nodos, suponemos que los nodos V = (v1, v2, ..., vn) están ordenados y podemos representarlos por sus ordinales {1, 2, ..., n}. La representación de los arcos se hace mediante una matriz A de n x n elementos aij definida por:

Año 2008 Página 4


aij

1 si hay un arco (vi, vj)

0 si no hay un arco (vi, vj)

La matriz se denomina Matriz de Adyacencia. En ocasiones la matriz de adyacencia es una matriz booleana en la que el elemento aij es verdadero si existe un arco (vi, vj) y falso en caso contrario.

En los grafos no dirigidos la matriz de adyacencia siempre será simétrica, ya que cada arco no dirigido (vi, vj) se corresponde con los arcos dirigidos (vi, vj) y (vj, vi).

En los grafos con factor de peso, es decir, grafos valorados, el factor de peso puede reemplazar al 1 o al verdadero de la matriz. La no existencia de un arco se representaría con 0 o con infinito, si se da el caso de que el factor de peso pudiera ser 0. A esta matriz se la denomina matriz valorada.

Ejemplos:

(1) Grafo no dirigido (2) Grafo Dirigido

0 1 0 1 0 1 0 0 1 1

A = 0 0 0 1 0 1 1 1 0 1 0 1 0 1 0

0 0 1 1 0 1 0 0 0 1

A = 0 1 0 0 0 0 1 1 0 0 0 0 0 1 0

(3) Grafo no Dirigido Valorado (4) Grafo Dirigido Valorado

0 2 0 6 0 2 0 0 8 4

A = 0 0 0 3 0 6 5 3 0 5 0 4 0 5 0

0 0 4 2 0 6 0 0 0 8

A = 0 7 0 0 0 0 5 5 0 0 0 0 0 2 0

Al ser una representación estática debe de estar previsto el máximo de nodos al que puede llegar el grafo (N). Los nodos o vértices, a su vez, tienen un identificador, los cuales se guardan en un vector al que llamamos Invértice. El tipo arco podríamos representarlo con un registro con un campo del tipo booleano o numérico, dependiendo de si se trata de un grafo valorado o no, y dos campos uno para vértice origen y otro para vértice destino.

Vértice: tipo_vértice; Tipo_Costo: booleano ó numérico;

Año 2008 Página 5


GRAFO: RegistroCosto: arreglo [1..N][1..N] de tipo_costo;Invert: arreglo [1..N] de tipo_vértice;

fin_Registro;

ARCO: RegistroVo: tipo_vértice;Vd: tipo_vértice;Costo: tipo_costo;

Fin_Registro;

Lista de Adyacencia

La representación de un grafo con Matriz de Adyacencia puede resultar poco eficiente en algunos casos. Así, cuando el número de vértices varía a lo largo del proceso, pudiéndose dar el caso de que el número de ellos sea mayor que el N previsto. También cuando el grafo es disperso, es decir, tiene pocos arcos, y por lo tanto la matriz de adyacencia tiene muchos ceros, resulta poco eficiente la matriz de adyacencia ya que el espacio que ocupa es el mismo que si el grafo tuviera muchos arcos. Cuando se dan alguna de estas ineficiencias se prefiere representar a los grafos mediante Listas de Adyacencias.

Las listas de adyacencias son estructuras multienlazadas formadas por una lista directorio, cuyos nodos representan a los vértices del grafo, y del que además emergen listas enlazadas cuyos nodos son los vértices destino que, a su vez, representan los arcos con vértice origen en el nodo de la lista directorio.

En nuestros ejemplos sería:

(1) Grafo no dirigido (2) Grafo Dirigido

(3) Grafo no Dirigido Valorado (4) Grafo Dirigido Valorado

Grafo: arreglo [1..N] de tipo_vértice; Tipo_Costo: numérico

Tipo_Vertice: Registro Nodo: Registro

Año 2008 Página 6


Info: tipo_vértice;

Lista: nodo;

fin_Registro;

Vd: tipo_vértice;

Costo: tipo_costo;

Sig: nodo;

fin_Registro;

Recorridos de un Grafo

La operación de recorrer una estructura consiste en visitar (procesar) cada uno de los nodos que la componen a partir de uno dado. Así, para recorrer un árbol se parte del nodo raíz, y según el orden se visitan todos los nodos. De igual manera, recorrer un grafo consiste en visitar todos los vértices alcanzables a partir de uno dado. Hay dos formas: recorrido en profundidad y recorrido en amplitud o anchura.

Recorrido en Anchura o Amplitud

Este método comienza visitando el vértice de partida vi, a continuación visitar los adyacentes que no estuvieran ya visitados. Así sucesivamente con los adyacentes. Este método utiliza una cola como una estructura auxiliar en la que se mantienen los vértices que se vayan a procesar posteriormente. La estrategia consiste en:

1. Visitar el vértice de partida vi.2. Meter en la cola el vértice de partida y marcarlo como visitado/procesado.3. Repetir los pasos 4 y 5 hasta que la cola esté vacía.4. Retirar el nodo frente de la cola (vk) de la cola y visitarlo/procesarlo.5. Meter en la cola todos los vértices adyacentes a vk que no

estén procesados y marcarlos como procesados.

Desarrollemos un ejemplo:En el grafo dirigido de la figura, queremos realizar un recorrido a partir del vértice D.

El seguimiento de la estrategia indicada sería: inicialmente añadir D a la cola, retirar el elemento frente de la cola, es decir D, meter en la cola los vértices adyacentes a D no visitados hasta el momento, etc., etc.

{D}

{D, B}

{D, B, C}

{D, B, C, H}

Año 2008 Página 7


{D, B, C, H, R}

{D, B, C, H, R, A}

{D, B, C, H, R, A, T}

En nuestro ejemplo, el recorrido del grafo en anchura a partir de D es el conjunto de todos los vértices del grafo. En definitiva, todos los vértices del grafo son alcanzables desde el vértice D.

Pero, ¿qué pasa cuando hay algún o algunos vértices que no son alcanzables desde el vértice designado como inicial?

En el caso de querer visitar todos los vértices del grafo, una vez que ha terminado el recorrido a partir de un vértice dado, hay que buscar si queda algún vértice sin ser visitado/procesado, en cuyo caso se vuelve a recorrer a partir de él, y así sucesivamente hasta visitar/procesar todos los vértices del grafo.

Recorrido en Profundidad

El recorrido en profundidad persigue el mismo objetivo que el recorrido en anchura: visitar todos los vértices de un grafo alcanzables desde un vértice dado. La búsqueda en profundidad empieza por un vértice v del grafo vi del grafo G; al cual se marca como visitado. Después se recorre en profundidad cada vértice adyacente a vi no visitado; así hasta que no hayan más vértices no visitados.

La definición recursiva del recorrido en profundidad ya nos indica que debemos utilizar una pila como estructura auxiliar para guardar los vértices adyacentes no visitados a uno dado. De igual forma que en el recorrido en anchura, hacemos uso de una lista de vértices para controlar los ya visitados.

A continuación, desarrollamos el recorrido en profundidad para el mismo grafo que vimos anteriormente.

{D}

{D, C}

{D, C, R}

{D, C, R, H}

{D, C, R, H, T}

Año 2008 Página 8


{D, C, R, H, T, A}

{D, C, R, H, T, A, B}

Al igual que en el recorrido en anchura, si nos queda algún vértice sin ser visitado luego de recorrer en profundidad comenzando en un vértice dado, se debe volver a recorrer comenzando por los que quedaron sin visitar.

Año 2008 Página 9


Algoritmos fundamentales con Grafos

Estudiaremos los algoritmos de Dijkstra, de Floyd y de Prim, y desarrollaremos ejemplos.

Algoritmo de Dijkstra

P roblema de los caminos más cortos con un solo origen

El problema consiste en determinar el costo del camino más corto del origen a todos los demás vértices del grafo, donde la longitud de un camino es la suma de los costos de los arcos del camino. Este se conoce como el problema de los caminos más cortos con un solo origen.

Este algoritmo opera a partir de un conjunto S de vértices cuya distancia más corta desde el origen ya es conocida. En principio, S contiene solo el vértice de origen. En cada paso se agrega algún vértice restante v a S, cuya distancia desde el origen es la más corta posible. Suponiendo que todos los arcos tienen costos no negativos, siempre es posible encontrar un camino más corto entre el origen y v que pasa solo a través de los vértices de S, y que se llama ESPECIAL. En cada paso del algoritmo, se utiliza un arreglo D para registrar la longitud del camino especial más corto a cada vértice. Una vez que S incluye todos los vértices, todos los caminos son ESPECIALES, así que D contendrá la distancia más corta del origen a cada vértice.

Procedimiento DIJKSTRA;S:= {1};n:= cantidad de vértices del grafo;Para i:= 2 a n hacer

D[i]:= Costo[1, i];Para i:= 1 a n-1 hacer

Elegir un vértice w en V-S tal que D[w] sea un mínimo;Agregar w a S;Para cada vértice v en V-S hacerD[v]:= mínimo (D[v], D[w]+Costo[w, v]);

Fin_para;Fin_DIJKSTRA

Ejemplo:

Dado el algoritmo y el grafo de ejemplo, en principio S={1}, D[2]=10, D[3]=inf., D[4]=30 y D[5]=100. En la primer iteración del segundo ciclo Para, w=2 se selecciona como el vértice con el mínimo valor D. Después se hace D[3]= mínimo(inf., 10+50)= 60. D[4] y D[5] no cambian porque el camino para llegar a ellos directamente desde 1 es más corto que pasar por el vértice 2.

La secuencias de valores que toma D luego de cada iteración se muestran en la tabla.

Como anexo se muestra un ejemplo de un algoritmo Dijktra utilizando el TAD Grafo y el TAD Lista.

Año 2008 Página 10

Iteración S W D[1] D[2] D[3] D[4] D[5]

INICIO {1} - 0 10 Inf. 30 1001 {1, 2} 2 0 10 60 30 1002 {1, 2, 4} 4 0 10 50 30 903 {1, 2, 4, 3} 3 0 10 50 30 604 {1, 2, 4, 3, 5} 5 0 10 50 30 60

Asigna valor inicial a D.

Cada iteración deja como resultado un camino mínimo (ESPECIAL).


Algoritmo de Floyd

Problema de los caminos más cortos entre todos los pares de vértices

Una posible solución es aplicar el algoritmo de Dijkstra a cada uno de los vértices del grafo; pero hay otra alternativa que es más rápida y directa, el Algoritmo de Floyd.

Se supone nuevamente que los vértices del grafo están enumerados de 1 a N. El algoritmo de Floyd usa una matriz A de N x N, en la que se calculan las longitudes de los caminos más cortos.

Inicialmente se hace:

A[i, j] = Costo[i, j] , para todo i<>j donde existe un arco i jA[i, j] = 0 , para todo i=jA[i, j] = infinito , para todo i<>j donde no existe un arco i j

Después se hacen N iteraciones en la matriz A.

Al finalizar la k-ésima iteración A[i, j] tendrá por valor la longitud más pequeña de cualquier camino que vaya desde el vértice i hasta el vértice j y que no pase por un vértice con número mayor que k. Esto es, que i y j, los vértices extremos, pueden ser cualquiera, pero todo vértice intermedio debe ser menor o igual que k.

AK-1[i,j]

AK[i,j]= mín

AK-1[i,k]+ AK-1[k,j]

Ejemplo:

Esta es la matriz inicial, copia de la matriz de costos.

Al incorporar el vértice 1 ha cambiado A0[4,2]

ya que A0[4,1]+ A0[1,2] < A0[4,2]

Solo el vértice 1 puede ser intermedio.


0 1 Inf. Inf. Inf.

Inf. 0 Inf. 4 7

A0[i,j] 3 2 0 Inf. 4

6 Inf. Inf. 0 2

Inf. Inf. Inf. 3 0

0 1 Inf. Inf. Inf.

Inf. 0 Inf. 4 7

A1[i,j] 3 2 0 Inf. 4

6 7 Inf. 0 2

Inf. Inf. Inf. 3 00 1 Inf. 5 8

Inf. 0 Inf. 4 7

A2[i,j] 3 2 0 Inf. 4

6 7 Inf. 0 2

Inf. Inf. Inf. 3 0


Al incorporar el vértice 2 ha habido varios cambios.

Por ejemplo A1[1,4]

A1[1,2]+ A1[2,4] < A1[1,4]

Los vértices 1 y 2 pueden ser intermedios.

Al incorporarse el vértice 3 no ha habido cambios, ya que no llega ningún arco a él.

Al incorporar el vértice 4 ha habido varios cambios.

Por ejemplo A3[5,2]

A3[5,4]+ A3[4,2] < A3[5,2]

Cualquier vértice menos el 5 puede ser intermedio.

Al incorporarse el vértice 5 no hay cambios, y ya tenemos los caminos más cortos desde cualquier vértice a otro del grafo.


0 1 Inf. 5 8

Inf. 0 Inf. 4 7

A3[i,j] 3 2 0 Inf. 4

6 7 Inf. 0 2

Inf. Inf. Inf. 3 0

0 1 Inf. 5 7

10 0 Inf. 4 6

A4[i,j] 3 2 0 Inf. 4

6 7 Inf. 0 2

9 10 Inf. 3 0

0 1 Inf. 5 7

10 0 Inf. 4 6

A5[i,j] 3 2 0 Inf. 4

6 7 Inf. 0 2

9 10 Inf. 3 0


Ejemplo de algoritmo Floyd

Utilizando el TAD Grafo y el TAD Lista, pero con manejo directo de Matriz, ya que no desarrollamos el TAD Matriz.

Procedimiento Floyd (G: grafo);Var A: arreglo [1..N] [1..N] de tipo_costo;

i, j, k, n: enteros;V: Lista de vértices;C: tipo_costo;

V:= VÉRTICES (G);n:= LONGITUD (V);Para i:= 1 a n hacer

Para j:= 1 a n hacerSi (i = j) entonces A[i, j]:=0;

SinoSi (C:=RECUPERA_COSTO (G, i, j)) = 0 entonces A[i, j]:= 99999;

Sino A[i, j]:= C;Fin_para;

Fin_para;Para k:= 1 a n hacer

Para i:= 1 a n hacerPara j:= 1 a n hacer

Si (A[i, k]+A[k, j])< A[i, j]) entonces A[i, j]:= A[i, k]+A[k, j];Fin_Floyd



Ejemplo de algoritmo Dijkstra

Utilizando el TAD Grafo y el TAD Lista.

Procedimiento DIJKSTRA (G: grafo, Vo: tipo_vértice);Var

S: Lista de vértices cuya distancia más corta al origen ya se conoce;D: Lista con la longitud del camino especial de cada vértice, de tipo_costo;V: Lista de todos los vértices del grafo;R: Lista de los vértices que faltan encontrar distancia más corta al origen, es decir V-S;i, j, n: entero;w: Tipo_vértice, es el vértice elegido en cada iteración para determinar la distancia más corta al origen;E: Tipo_costo, Distancia del origen a w en cada iteración;B: Tipo_vértice, guarda el vértice tratado en cada iteración para recalcular la longitud del camino;P: entero, posición que ocupa dentro de la lista D el vértice tratado en la iteración;C: Tipo_costo, longitud del camino desde el origen al vértice tratado guardado en la lista D.F: Tipo_costo, longitud del camino desde el origen al vértice tratado pero pasando por el vértice w.

ANULA (S); ANULA (D); ANULA (V); ANULA (R);V:= VÉRTICES (G);R:= V;SUPRIMIR (R, LOCALIZA (R,Vo));INSERTAR (S, Vo, 1);n:= LONGITUD (V);Para i:= 1 a n hacer

INSERTAR (D, RECUPERA_COSTO (G, Vo, i), i);Para i:= 1 a n-1 hacer

w:= ELEGIR_VÉRTICE (G, R, D);INSERTAR (S, w, 1+i);E:= RECUPERA (D, LOCALIZA (V, w));Para j:= 1 a n-i hacer

B:= RECUPERA (R, j);P:= LOCALIZA (V, B);C:= RECUPERA (D, P);F:= E + RECUPERA_COSTO (G, w, B);Si C > F entonces ACTUALIZAR (D, F, P);

Sino ACTUALIZAR (D, C, P);Fin_para;SUPRIMIR (R, LOCALIZA (R, w));

Fin_para;Fin_Dijkstra

Función ELEGIR_VÉRTICE (G: grafo, R: Lista de vértices, D: Lista de Costos): vértice;Var n, i: entero;

M, A: Tipo_vértice;H, K: Tipo_costo;

n:= LONGITUD (R);M:= RECUPERA (R, 1);H:= RECUPERA (D, LOCALIZA (D, M));Para i:= 2 a n hacer

A:= RECUPERA (R, i);K:= RECUPERA (D, LOCALIZA (D, A));Si K < H entonces H:=K;

M:=A;Fin_Si;

Fin_Para;Retorna (M);

Fin_ELEGIR_VERTICE


Asigna valor inicial a D

Función que elige un vértice de la lista R, tal que su longitud del camino especial en D es mínima.

Posición que ocupa w o B en la lista D.


Algoritmo de Prim

Árboles abarcados de coste mínimo

Supongamos que G = (V, A) es un grafo conexo en donde cada arista (u, v) de A tiene un costo asociado, Costo (u, v). Un árbol abarcado para G es un árbol libre que conecta todos los vértices de V, y su costo es la suma de los costos de las aristas del árbol.

Una aplicación típica de los árboles abarcados de coste mínimo tiene lugar en el diseño de redes de comunicación.

Existen dos técnicas para construir árboles abarcados de coste mínimo, la de Prim y la de Kruskal.

Suponemos V = {1, 2, ..., n}. El algoritmo de Prim comienza cuando se asigna a un conjunto U un valor inicial {1}, en el cual “crece” un árbol abarcado, arista por arista. En cada paso localiza la arista más corta (u, v) que conecta U y V – U, y después agrega v, el vértice en V – U, a U. Este paso se repite hasta que U = V.

Una forma sencilla de encontrar la arista de menor costo entre U y V – U en cada paso es por medio de dos arreglos: uno, MAS_CERCANO [i], da el vértice en U que esté más cercano a i en V – U. El otro, MENOR_COSTO[i], da el costo de la arista (i, MAS_CERCANO[i]).


Unidad 5.doc

Documents

Transcript of Unidad 5.doc