4 - Grafos PDF

Algortmica y Complejidad
Tema 4 Algoritmos sobre grafos.
Algortmos sobre grafos
1. Conceptos, Definiciones y Representacin.

2. Conectividad y recorrido.
3. rboles de expansin.
4. Caminos mnimos.

4. Caminos mnimos.
Conceptos, Definiciones y Representacin

El origen de la teora de grafos ...
El problema de los puentes de Knigsberg (1736)

es posible dar un paseo comenzando desde cualquiera de estas
regiones, pasando por todos los puentes, recorriendo slo una vez
cada uno, y regresando al mismo punto de partida?
Resuelto por Euler

l
No hay solucin
Se puede comprobar utilizando fuerza bruta
Demostracin de Euler
Algoritmos sobre grafos

Ejemplos
Redes de transporte (carreteras, rutas areas, ...)

Redes de comunicacin (Internet)
Redes de informacin (WWW)
Redes sociales (Facebook, Twitter, FourSquare, ...)
Dependencias (asignaturas pre-requisito, diagramas de flujo, ...)
Definicin formal de grafo

Par de conjuntos G=(V, E)
V nodos y E aristas
Cada arista es un par (u,v) con u,v V
Si el par est ordenado es un grafo dirigido
Si no est ordenado es un grafo no dirigido

Grado del grafo (grado (G))
Nmero de nodos / vrtices |V|
Nodos adyacentes
Si estn unidos por una arista
Grado de un nodo (grado (u))

Nmero de aristas que inciden en un nodo nmero de nodos
adyacentes
!"#$%! ! = ! |!|!
Handshaking Lemma
!!!
En grafo dirigido: grado de entrada y grado de salida
Camino entre dos nodos (path (u,v))

Secuencia de nodos, tal que dos nodos consecutivos son
adyacentes (uxi, xixi+1, xi+1xi+2, ...., xi+nv)
Es simple cuando no hay nodos repetidos en el camino
Ciclo es un camino simple pero con u = v

Grafo conexo
Cada par de nodos est conectado
por un camino
Grafo no conexo
No existe un camino que una un
nodo con los dems
No existe un camino entre a y e
Bosque
Grafo sin ciclos
rbol libre
Bosque conexo
Con un nodo en el papel de raz

Siempre se cumple que:
a.
b.
c.
d.
! ! !
!
!
!
Si G es conexo, |E| |V|-1
Si G es rbol, |E| = |V|-1
Si G es bosque |E| |V|-1
Describir este grafo (grid)

1.
2.
3.
4.
Dirigido o no dirigido
Conexo?
Bosque?
Grado de los nodos

Representacin de grafos
2
3
Listas de adyacencia
5
G=(V,E)
Las aristas pueden

tener pesos asociados.
Grafos poco densos

|E| << (|V|*(|V|-1))/2
Espacio (|V|+|E|)
Si el grafo es dirigido
list[i].length = |E|
Si el grafo es NO dirigido
list[i].length = 2*|E|
Longitud total de la lista (|E|)

Representacin de grafos
2
3
Matriz de adyacencia
5
G=(V,E)
Las aristas pueden

tener pesos asociados.
Grafos densos
|E| (|V|*(|V|-1))/2
Un solo bit por arista
Espacio (|V|2)
Consultas sobre aristas
10

4. Caminos mnimos.
11
Conectividad y Recorrido
Dado un grafo G=(V,E) y dos nodos s y t
Problemas: Existe un camino para llegar de s a t?
A qu distancia estn?
Concepto de distancia entre dos nodos s y t como (s, t)
Mnimo nmero de aristas entre s y t.
Breadth-First Search (BFS)

Recorrido en amplitud. Dado un nodo s, primero visita todos los
nodos a distancia 1 (L1) de s, luego a distancia 2 (L2), y as
sucesivamente.
Li(s) Conjunto de nodos a distancia i de s
Depth-First Search (DFS)

Recorrido en profundidad. Dado un nodo s, visita el primer nodo
conectado a s y despus el primer nodo conectado al ltimo
visitado
12
Lista de Adyacencia
Breadth-First Search (BFS)

Desde el nodo 0
0
0
2
Resultado
L1
L2
13
Algoritmo BFS
graph : Graph_Type (Max_Vertices => N); -- Un grafo de N nodos
procedure BFS (g: in out Graph_Type; s: Vertex_Type) is
Q
: FIFO;
-- Cola. Inicialmente vacia
v
: Vertex_Type;
w
: Vertex_Type;
begin
Push (Q, s);
Mark_Vertex (g, s, TRUE);
-- Visitado a TRUE
while not Is_Empty (Q) loop
Pop (Q, v);
for i in Successors (g, v)'Range loop
w := Successors (g, v) (i);
if not Marked (g, w) then
Put (v); Put (w); new_line;
Mark_Vertex (g, w, TRUE);
Push (Q, w);
end if;
end loop;
end loop;
end BFS;
-- Nodos adyacentes del nodo v

-- i-esimo nodo adyacente de v
-- Visitado?
-- Visitado a TRUE
14
Complejidad de BFS
Con listas de adyacencia
Un nodo slo puede aparecer una vez en la cola (Q)
Pop (Q, v);
for i in Successors (g, v)'Range loop
w := Successors (g, v) (i);
Put (v); Put (w); new_line;
Mark_Vertex (g, w, TRUE);
Push (Q, w);
end if;
V veces
O(1)
O(V)
O(V+E)
2*E Veces
O(E)
O(1)
end loop;
end loop;
15
Complejidad de BFS
Con matriz de adyacencia en un lugar de lista de
adyacencia
V veces
Pop (Q, v);

for j in MatrizRange(1) loop
if Matriz (v, j) /= 0 then
if not Marked (g, j) then
.......
end if;
end if;
end loop;
O(V2)
V veces
end loop;
16
Lista de Adyacencia
Depth-First Search
(DFS)
Desde el nodo 0
0
0
0
1
3
5
Resultado
3
5
Algoritmo DFS versin recursiva
graph : Graph_Type (Max_Nodos => N);
-- Grafo de N nodos
procedure DFS (g: in out Graph_Type; s: Vertex_Type) is

w: Vertex_Type;
begin
Mark_Vertex (g, s, TRUE);
for i in Successors (g, s)'Range loop
w := Successors (g, s) (i);
DFS (g, w);
end if;
end loop;
-- Poner nodo s como Visitado

-- Para todos los vecinos de s
-- i-esimo vecino
-- Visitado vecino de s?
end DFS;
18
Complejidad algoritmo DFS versin recursiva
Complejidad
procedure DFS (g: in out Graph_Type; s: Natural) is

w: Vertex_Type;
begin
Mark_Vertex (g, s, true);
V llamadas recursivas
for i in Successors (g, s)'Range loop
O(V)
2*E veces
w := Successors (g, s) (i);
O(1)

parent (w) := s;
DFS (g, w);
end if;
O(1)
O(E)
O(V + E)
end loop;
end DFS;
19
Algoritmo DFS Versin No Recursiva
procedure DFS (g: in out Graph_Type; s:
Vertex_Type) is
p: STACK;
-- Pila
u: Vertex_Type;
begin
Push (p, s);
while not Is_Empty (p) loop
Pop (p, u);
if not Marked (g, u) then
Mark_Vertex (g, u, true);
Put ("Visitado :"); Put (u); New_Line;
for i in Successors (g, u)'Range loop
Push (p, Successors (g, u)(i));
end loop;
end if;
end loop;
end DFS;
Complejidad
O(V)
O(2*E)
O(V+E)
O(E)
20
Grafos Dirigidos
Con BFS y DFS comprobamos la existencia de un camino entre
dos nodos s y t
Aunque exista el camino, puede que no exista entre t y s
Un grafo est fuertemente conectado si:
s, t V, existe un camino entre s y t y entre t y s
A
B
A
Fuertemente conectado
NO fuertemente conectado
Algoritmo:
1.BFS (G, s) DFS (G, s)
2.Calcular Grev (Invertiendo el sentido de las artistas)
3.BFS (Grev, s) DFS (Grev, s)
4.Si BFS DFS fallan y no alcanzan todos los nodos, el grafo NO est fuertemente conectado
21
Grafos Dirigidos
Sin ciclos es un DAG (Directed Acyclic Graph)
Los DAG aparecen con bastante frecuencia
Relaciones de precedencia o dependencia
Si se puede establecer un orden entre los nodos, de tal forma que
(u, v) E y u < v (orden), entonces G tiene orden topolgico.
Si G es un DAG, entonces tiene orden topolgico
MD
FP
ED
ALG
ED
SD
SO
Posible precedencia de las

asignaturas de Grado
FP
MD
ALG
POO
C
SO
SD
POO
C
Orden topolgico de las

asignaturas
22
Algoritmo de ordenacin topolgica
R Lista con la ordenacin (resultado)

Complejidad O (n2)
ORDENACION_TOPOLGICA (G):
Encontrar un nodo u / v V, (v, u) E
R {u} R
G.V G.V {u}
if G.V then
ORDENACION_TOPOLGICA (G)
endif
3
6
(3)
R {1, 2, 3}
(4)
(1)
(2)
7
R {1}
(5)
R {1, 2}
6
5
(6)
7
(7)
R {1, 2, 3, 4, 5, 6}
R {1, 2, 3, 4, 5, 6, 7}
R {1, 2, 3, 4, 5}
R {1, 2, 3, 4}
23
1/2
Algoritmo de Ordenacin Topolgica

procedure Ordenacion_Topologica (g: in out Graph_Type) is
n: Vertex_Type;
begin
n := Nodo_Candidato (g);
--- Nodo con Grado de Entrada 0
if n /= NO_HAY_NODO then
Mark_Vertex (graph, n, true);
--- Cuando exista el nodo

--- Marcar nodo como seleccionado
Put (n); new_line;

for j in reverse Successors (g, n)'Range loop
Remove_Edge (g, n, Successors (g, n)(j)); --- Eliminar arcos de salida
end loop;
Ordenacion_Topologica (g);
end if;
end Ordenacion_Topologica;
--- Llamada recursiva
24
2/2
Algoritmo de Ordenacin Topolgica

function Nodo_Candidato (g: Graph_Type) return Integer is
w: Vertex_Type;
begin
for i in Vertices_List (g)'Range loop
w := Vertices_List (g) (i);
--- Recorrer todos los nodos

--- w almacena el i-esimo nodo
if In_Degree (g, w) = 0 and not Marked (g, w) then --- Seleccionar el nodo
return w;
--- con grado de entrada 0
end if;
--- y sin marcar
end loop;
return NO_HAY_NODO;
--- No hay nodo candidato
end Nodo_Candidato;
25
function Nodo_Candidato (g: Graph_Type) return Integer is
w: Vertex_Type;
begin
w := Vertices_List (g) (i);
if In_Degree (g, w) = 0 and not Marked (g, w) then
return w;
end if;
end loop;
return NO_HAY_NODO;
end Nodo_Candidato;
Complejidad
O(V)
procedure Ordenacion_Topologica (g: in out Graph_Type) is

n: Vertex_Type;
V*O(V)
begin
n := Nodo_Candidato (g);
if n /= NO_HAY_NODO then
Mark_Vertex (graph, n, true);
Put (n); new_line;
O(E)
for j in reverse Successors (g, n)'Range loop
Remove_Edge (g, n, Successors (g, n)(j));
end loop;
Ordenacion_Topologica (g);
--- Llamada recursiva
end if;
end Ordenacion_Topologica;
O(V)
O(1)
O(V2)
O(V2)
O(E)
26

4. Caminos mnimos.
27
rboles de Expansin
Cmo conectar todos los nodos con el mnimo coste?
2
11
I
7
14
w(T ) =
w(u, v), T E
(u,v)T
E
w : E
10
H
Aplicaciones
Logstica
Conexionado
v Ciudades,
v Componentes elctricos,
v Personas, etc.
Enrutamiento en redes
Algoritmos de construccin (Voraces)

Genrico
Kruskal
Prim
2
I
4
G
Coste 37
Se puede sustituir (B,C) por (A,H)
con igual coste
28
rboles de Expansin
Propiedades de los arboles de expansin:
Tienen |V|-1 arcos
No tienen ciclos
Pueden no ser nicos
Algoritmo Genrico
MST_GENERICO (G, w): // Minimum Spanning Tree

A # Conjunto de arcos que forman el MST
while A no forme Minimum Spanning Tree do
Encontrar un arco e E, f E, / w(e) w(f) && A {e} sea acclico
A A {e}
E E - {e}
done
return A
Aade un arco cada vez al rbol de expansin (A)
Finaliza cuando todos los nodos estn conectados
El problema es comprobar que no se aaden ciclos
29
rboles de Expansin
Algoritmo de Kruskal
Descripcin
Algoritmo voraz, en cada iteracin aade un arco de peso mnimo
Se parte de un bosque que inicialmente contiene un rbol por cada
vrtice
Los arcos estn ordenados de forma creciente por su peso
Mientras existan arcos para aadir y el bosque inicial no sea un rbol el
algoritmo continua
Cuando aadir un arco provoca un bucle, se desecha y se continua con
el siguiente.
30
rboles de Expansin
Ejemplo (1/2)
1
3
7
3
6
5
4
3
7
4
1
1
5
3
7
9
3
3
9
1
3
3
4
1
5
6
1
6
1
2
3
1
5
4
1
3
7
CICLO! Los nodos

2 y 5 pertenecen al
mismo rbol
31
rboles de Expansin
Ejemplo (2/2)
4
2
3
5
9
3
4
9
3
2
7
9
3
2
7
4
1
3
7
Coste 12
Implementacin
Mediante conjuntos para representar los diferentes arboles
Estructura de datos para manejar conjuntos disjuntos (Union-Find)
Operaciones sobre conjuntos:
Make-Set (u)
Union (u, v)
Find (u)
32
rboles de Expansin
Estructura de datos Union-Find
Find (u) devuelve el conjunto al que pertence el nodo u
Para comprobar si un arco (u,v) genera un ciclo:
if Find (u) = Find (v) then ......
Para combinar dos arboles mediante el arco (u,v):
Union (u, v)
S1
S2
cab
cola
cab
Arcos
cola
Conjunto
(a,b)
{a, b}
(c,d) (d,e)
{c, d, e}
A
C
B
D
33
rboles de Expansin
Estructura de datos Union-Find
Union (b, c)
S1
cab
cola
Arcos
Conjunto
(a,b)
{a, b}
(c,d) (d,e)
{c, d, e}
(a,b) (b,c) (c,d) (d,e) {a, b, c, d, e }
Dos arboles
Un nico rbol
34
rboles de Expansin
Algoritmo de Kruskal (1/2)
procedure kruskal is
g, mst : Graph_Type (Max_Vertices);
Q
: Queue_Type (Max_Edges); -- Cola ordenada de forma asc. por peso
uf
: UnionFind_Type;
u, v
: Vertex_Type;
e
: Edge_Type;
begin
Load_Graph (g, ..);
Clear (mst);
-- Aadir en 'mst' los vertices
v := Vertices_List (g)(i);
Add_Vertex (mst, v);
-- Aadir los nodos al grafo mst
Make_Set (uf, v);
-- Inicializar estructura Union Find
end loop;
Init_Queue (Q, g);
-- Inicializar cola con los arcos (peso)

35
rboles de Expansin
Algoritmo de Kruskal (2/2)
while not Empty (Q) loop

Dequeue (Q, e);
Se puede mejorar?
-- Sacamos un arco con el menor peso
if Find (uf, e.From ()) /= Find (uf, e.To ()) then

Add_Edge (mst, e, Undirected => True);
Union (uf, e.From (), e.To ());
end if;
end loop;
Print_Graph (mst);
end kruskal;
Algoritmos sobre Grafos
36
rboles de Expansin
Algoritmo de Kruskal - Complejidad
begin -- kruskal
Add_Vertex (mst, v);
Make_Set (uf, v);
end loop;
ordenar
Init_Queue (Q, g);
Heap Sort
O(V)
O(E lg E)
|E| |V|2
O(E lg V)
O(E lg V)

Dequeue (Q, e);
if Find (uf, e.From()) /= Find (uf, e.To()) then
..............
Union (uf, e.From(), e.To());
end if;
end loop;
end kruskal
Algoritmos sobre Grafos
para todos los arcos
O(E)
Al ser un grafo conexo

|E| |V| - 1
37
rboles de Expansin
Algoritmo de Prim
Descripcin
Variante del algoritmo genrico

Algoritmo voraz, en cada iteracin aade un nodo
Mantiene un nico rbol (en cambio, Kruskal un bosque)
Mientras no sea Spanning Tree
Escoge el arco de peso mnimo (u, v)
Aade el vrtice u o v al rbol, dependiendo de si forma o no parte del
rbol en construccin.
38
rboles de Expansin
Algoritmo de Prim
Ejemplo (raz el vrtice 6)
4
2
3
3
4
3
1
Cola:
6-7 2
6-2 4
peso
Los nodos 2 y 7 no han

sido visitados todava
3
1
4
1
3
7
saco 6-7
visito 7
saco 6-2
visito 2
Cola:
6-2 4
7-1 6
7-5 9
Cola:
2-3 1
2-5 3
7-1 6
7-5 9

sido visitados todava
1
6
2
3
visito 6
3
1
arco
1
6
1
5
(1/3)

sido visitados
39
rboles de Expansin
Algoritmo de Prim
Ejemplo
4
2
3
(2/3)
3
5
9
3
4
4
1
3
7
saco 2-3
visito 3
saco 3-5
visito 5
saco 5-1
visito 1
Cola:
3-5 1
2-5 3
3-4 5
7-1 6
7-5 9
Cola:
5-1 1
2-5 3
3-4 5
7-1 6
7-5 9
Cola:
2-5 3
1-4 3
3-4 5
7-1 6
7-5 9
El nodo 2 ya ha sido
visitado
Los nodos 2, 3 y 7
ya han sido visitados
9
3
2
7
9
3
2
7
Los nodos 5 y 7 ya
han sido visitados
40
rboles de Expansin
Algoritmo de Prim
Ejemplo
4
(3/3)
2
3
1
5
4
1
3
7
saco 2-5
Cola:
1-4 3
3-4 5
7-1 6
7-5 9
Los nodos 2 y 5 ya
han sido visitados
3
3
6
9
3
1
1
5
1
6
3
3
4
1
3
7
saco 1-4
visito 4
saco 7-1
saco 7-5
Cola:
7-1 6
7-5 9
Cola:
Los nodos 1 y 3 ya
han sido visitados
41
rboles de Expansin
Algoritmo de Prim
El tiempo de ejecucin del algoritmo depende de la
bsqueda del arco de peso mnimo
Para cada vrtice se aaden las informaciones:
key
Para mantener ordenados los nodos
parent
Nodo padre en el rbol de expansin
type Vertex_Type is record
key
INTEGER;
parent: Vertex_Id;
end record;
Q mantiene ordenados los nodos de acuerdo a key

42
rboles de Expansin
Algoritmo de Prim (1/2)
procedure prim is
g
: Graph_Type (Max_Vertices);
v, u
: Vertex_Type;
Q
: Queue_Type; --- Cola ordenada
begin -- prim
Load_Graph (g, ..);
-- Inicializar los campos key y parent
Set_key (g, v, INFINITO);
Set_Parent (g, v, NO_PARENT);
Enqueue (Q, v);
--- Encola el vrtice
end loop;
v := Vertices_List (g)(1); -- raz
Set_Key (g, v, 0);
43
rboles de Expansin
Algoritmo de Prim (2/2)
Dequeue (Q, u);
v := Successors (g, u)(i);
if In_Queue (Q, v) and Weight_Of (g, u, v) < Get_Key (g, v) then
Set_Parent (g, v, u);
Set_Key (g, v, Weight_Of (g, u, v)); --- Puede modificar el orden de
--- los vrtices en Q
end if;
end loop;
end loop;
end prim;
44
rboles de Expansin
Complejidad del Algoritmo de Prim

Las operaciones sobre la estructura Cola (Enqueue,
Dequeue, y In_Queue) tienen un coste O (log V)
-- Inicializar
..
Enqueue (q, v);
end loop;
while not Empty (q) loop
Dequeue (q, u);
v := Successors (g,u)(i);
if In_Queue (q, v) and .........
............
end if;
end loop;
end loop;
O(V log V)
O(V log V)
O(E log V)
O(E log V)
Al ser un grafo conexo
|E| |V| - 1
45

4. Caminos mnimos.
46
Caminos mnimos
El problema: Cul es la forma ms rpida de ir .... ?

Camino mnimo
Tambin
Cul es la ms barata?
Cul es la de menor
distancia recorrida?
1
A
2
B
1
5
C
4
3
F
E
2 caminos mnimos
47
Caminos mnimos
Variantes del problema

BFS permite obtener los caminos mnimos en
grafos no ponderados
Caminos mnimos a un destino desde el resto de
nodos
Caminos mnimos para todos los pares de nodos
Una posible solucin: calcular el camino mnimo para
cada nodo
48
Caminos mnimos
Definiciones
Se parte de un grafo ponderado
G=(V,E) y w: ER
w(p) es el peso del camino p = (v0, v1, ... vk)

k
w( p) = w(vi1, vi )
i=1
(u, v) es el peso del camino mnimo entre u y v

$&
min {w( p) : u !P!
v}
(u, v) = %
&'
Si existe un camino entre u y v

No hay camino
49
Caminos mnimos
Tcnica de la relajacin de arcos
Asignar peso y predecesor a cada vrtice/nodo
Peso al origen (v.key), inicialmente a infinito
Predecesor (v.parent), nodo previo en el camino
Tcnica de Relajamiento
A
d=5
B
d=9
RELAX
A
d=5
if (B.key > A.key + w (A, B)) then

B.key = A.key + w (A,B)
B.parent = A
B
d=7
50
Caminos mnimos
Algoritmo de Bellman-Ford
Obtiene los caminos mnimos desde un vrtice al resto
Admite arcos con peso negativo
Para cada vrtice se aade la informacin:
key
Distancia de la fuente a cada vrtice
Relaja todos los arcos del grafo sin un orden

preestablecido
Lo realiza |V|-1 veces para garantizar el clculo correcto de la
key de cada vrtice
Antes de finalizar debe comprobar que no existe un

bucle negativo dentro de grafo.
51
Caminos mnimos
Algoritmo de Bellman-Ford
Fuente
A
D=
-1
B
D=
S
D=0
C
D=
A
D=3
(S, A) = 3
(S, B) = 2
C
D=2
S
D=0
D
D=
-1
S
D=0
-1
relax
relax
2
B
D=2
-1
D
D=6
(S,C) = 2
(S,D) = 3
A
D=3
2
C
D=2
A
D=3
-1
-1
S
D=0
2
C
D=2
B
D=
-1
D
D=
B
D=2
-1
D
D=3
Relaja (C,D)
52
Caminos mnimos
Algoritmo de Bellman-Ford (Con arcos de peso Negativo)
Problema: No encontrar el camino mnimo en presencia de ciclos
A
D=3
-4
B
D=-1
3
S
D=0
(S,A) = w(S,A) = 3
(S,B) = -1
4
5
6
C
d=5
D
d=11
G
d=-
-3
2
7
3
E
d=-
F
d=-
-6
Cuantas ms vueltas menor peso
Para (S,C) hay infinitos caminos

(s,c), (s,c,d,c) .....
pero slo uno de peso mnimo
(S,C) = w(S,C) = 5
Para (S,E) hay infinitos caminos
(s,e), (s,e,f,e), (s,e,f,e,f,e) ....
NO existe un camino mnimo
(S,E) = -
dem para (S,F) y (S,G)
53
rboles de Expansin
Algoritmo de Bellman-Ford (1/2)
function bellmanford is
g
e:
: Edge_Type;
begin
Load_Graph (g, ..);
Init_Source (g, Vertices_List (g)(1));
for n in 1..Max_Nodos 1 loop
for i in Edges_List (g)Range loop
e := Edges_List (g)(i);
Relax (g, e.From (), e.To ());
end loop;
end loop;
Complejidad
V veces
E veces
O(VE)
O(VE)
E veces
O(E)
for i in Edges_List (g)Range loop
e := Edges_List (g)(i);
if Get_Key (g, e.To() ) > (Get_Key (g, e.From() + Weight_Of (e)) then
return FALSE;
end if;
end loop;
return TRUE;
end bellmanford;
54
rboles de Expansin
Algoritmo de Bellman-Ford (2/2)
procedure Init_Source (g: in out Graph_Type; source: in Vertex_Type) is
g
v:
: Vertex_Type;
begin
for i in Vertices_List (g)Range loop
Set_Key (g, v, INFINITO);
Set_Parent (g, v, NO_PARENT);
end loop;
Set_Key (g, source, 0);
end Init_Source;
procedure Relax (g: in out Graph_Type; from, to: in Vertex_Type) is
begin
if Get_Key (g, to) > (Get_Key (g, from) + Weight_Of (g, from, to)) then
Set_Key (g, to, Get_Key (g, from) + Weight_Of (g, from, to));
Set_Parent (g, to, from);
end if;
end Relax;
55
Caminos mnimos
Algoritmo de Dijkstra
Grafos dirigidos con pesos no negativos
Explorar todos los caminos ms cortos desde la fuente
Estrategia voraz
Para cada nodo se aaden las informaciones:
key
Distancia de la fuente a cada vrtice
parent
Vrtice previo en el camino
Q Cola Min ordenada por Vertex_Type.Key

Ms rpido que el algoritmo de Bellman-Ford
56
Caminos mnimos
Nodos con camino mnimo
Ejemplo:
3
A
d=
S
d=0
(1)
2
2
C
d=
A
d=3
S
d=0
(3)
1
2
C
d=2
A
d=3
S
d=0
(5)
1
2
C
d=2
B
d=
1
3
S
d=0
D
d=
(2)
B
d=
1
(4)
B
d=4
1
D
d=3
C
d=2
A
d=3
(6)
1
2
C
d=2
A
d=3
S
d=0
1
2
S
d=0
D
d=3
A
d=3
1
2
C
d=2
B
d=
1
D
d=
B
d=4
1
D
d=3
B
d=4
1
D
d=3
Existe
camino
alternativo?
57
Caminos mnimos
Nodos con camino mnimo
Ejemplo: (Alternativa)
3
A
d=
S
d=0
(1)
2
2
C
d=
A
d=3
S
d=0
(3)
1
2
C
d=2
A
d=3
S
d=0
(5)
1
2
C
d=2
B
d=
1
3
S
d=0
D
d=
(2)
B
d=
1
(4)
B
d=4
1
D
d=3
C
d=2
A
d=3
(6)
1
2
C
d=2
A
d=3
S
d=0
1
2
S
d=0
D
d=3
A
d=3
1
2
C
d=2
B
d=
1
D
d=
B
d=4
1
D
d=3
B
d=4
1
D
d=3
58
rboles de Expansin
Algoritmo de Dijkstra
procedure dijkstra is
g
Q
: Queue_Type (Max_Vertices);
u,v
: Vertex_Type;
begin
Load_Graph (g, ..);
Init_Source (g, Vertices_List (g)(1));
Init_Queue (Q, g);
Dequeue (Q, u);
Mark_Vertex (g, u, TRUE);
--- Alcanzado el vrtice u
for i in Successors(g, u)Range loop
v := Successors (g, u) (i);
Relax (g, u, v); --- Puede modificar el orden de los vrtices en Q
end loop;
end loop;
end dijkstra;
59
rboles de Expansin
Algoritmo de Dijsktra Complejidad
Utilizando la cola Min con los vrtices ordenados por Key
Coste de la operacin Dequeue: O (log V)
Coste de modificar una Key (Relax) en la cola: O (log V)
begin -- dijkstra
Init_Queue (Q, g);
while not Empty (q) loop
Dequeue (Q, u);
Mark_Vertex (g, u, TRUE);
for i in Successors(g, u)Range loop
v := Successors (g, u) (i);
Relax (g, u, v);
end loop;
end loop;
end dijkstra;
O(V)
V veces
O (log V)
2*E veces
O(log V)
O (V log V)
O (E log V)
O ((V+E) log V)
Si el grafo es
conexo
O (E log V)
Calcular la complejidad si se utiliza un array en lugar de una Cola Min (Q)

60

4 - Grafos PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

4 - Grafos PDF

Uploaded by

Copyright:

Available Formats

Algortmica y Complejidad

Tema 4 Algoritmos sobre grafos.

Algortmos sobre grafos

1. Conceptos, Definiciones y Representacin.

Algortmos sobre grafos

1. Conceptos, Definiciones y Representacin.

Conceptos, Definiciones y Representacin

El problema de los puentes de Knigsberg (1736)

Resuelto por Euler

Algoritmos sobre grafos

Conceptos, Definiciones y Representacin

Redes de transporte (carreteras, rutas areas, ...)

Dependencias (asignaturas pre-requisito, diagramas de flujo, ...)

Definicin formal de grafo

Conceptos, Definiciones y Representacin

Grado de un nodo (grado (u))

En grafo dirigido: grado de entrada y grado de salida

Camino entre dos nodos (path (u,v))

Conceptos, Definiciones y Representacin

Algoritmos sobre grafos

Conceptos, Definiciones y Representacin

Describir este grafo (grid)

Algoritmos sobre grafos

Conceptos, Definiciones y Representacin

Las aristas pueden

Grafos poco densos

Algoritmos sobre grafos

Conceptos, Definiciones y Representacin

Algoritmos sobre grafos

Las aristas pueden

Algortmos sobre grafos

1. Conceptos, Definiciones y Representacin.

Breadth-First Search (BFS)

Depth-First Search (DFS)

Breadth-First Search (BFS)

Algoritmos sobre grafos

Algoritmos sobre grafos

-- Nodos adyacentes del nodo v

Algoritmos sobre grafos

Pop (Q, v);

Algoritmos sobre grafos

procedure DFS (g: in out Graph_Type; s: Vertex_Type) is

-- Poner nodo s como Visitado

Algoritmos sobre grafos

procedure DFS (g: in out Graph_Type; s: Natural) is

for i in Successors (g, s)'Range loop

w := Successors (g, s) (i);

if not Marked (g, w) then

Algoritmos sobre grafos

Algoritmos sobre grafos

Algoritmos sobre grafos

Posible precedencia de las

Algortmos sobre grafos

Orden topolgico de las

R Lista con la ordenacin (resultado)

Algoritmos sobre grafos

Algoritmo de Ordenacin Topolgica

--- Nodo con Grado de Entrada 0

--- Cuando exista el nodo

Put (n); new_line;

Algoritmos sobre grafos

--- Llamada recursiva

Algoritmo de Ordenacin Topolgica