ESTRUCTURAS DISCRETAS II

ALUMNA: Paula Del Carpio Bernedo

GRUPO: 01
SEMESTRE: III

LABORATORIO 09
ACTIVIDADES
1. Implementar en Python el siguiente cdigo correspondiente al modelo de
redes implementado a continuacin:
class FlowNetwork(object):
def __init__(self):
self.adj = {}
self.flow = {}

def add_vertex(self, vertex):

self.adj[vertex] = []

def get_edges(self, v):

return self.adj[v]

def add_edge(self, u, v, w=0):

if u == v:
raise ValueError("u == v")
edge = Edge(u,v,w)
redge = Edge(v,u,0)
edge.redge = redge
redge.redge = edge
self.adj[u].append(edge)
self.adj[v].append(redge)
self.flow[edge] = 0
self.flow[redge] = 0

def find_path(self, source, sink, path):

if source == sink:
return path
for edge in self.get_edges(source):
residual = edge.capacity - self.flow[edge]
if residual > 0 and edge not in path:
result = self.find_path( edge.sink, sink, path + [edge])
if result != None:
return result

def max_flow(self, source, sink):

path = self.find_path(source, sink, [])
while path != None:
residuals = [edge.capacity - self.flow[edge] for edge in path]
flow = min(residuals)
for edge in path:
self.flow[edge] += flow
self.flow[edge.redge] -= flow
path = self.find_path(source, sink, [])
return sum(self.flow[edge] for edge in self.get_edges(source))
g = FlowNetwork()
[g.add_vertex(v) for v in "sopqrt"]
g.add_edge('s','o',3)
g.add_edge('s','p',3)
g.add_edge('o','p',2)
g.add_edge('o','q',3)
g.add_edge('p','r',2)
g.add_edge('r','t',3)
g.add_edge('q','r',4)
g.add_edge('q','t',2)
print (g.max_flow('s','t'))

2. Probarlo cambiando los datos y obteniendo el flujo mximo de los nuevos

modelos de redes

g = FlowNetwork()
[g.add_vertex(v) for v in "ABCDEF"]
g.add_edge('A','B',1)
g.add_edge('A','E',6)
g.add_edge('B','C',3)
g.add_edge('C','D',1)
g.add_edge('D','F',5)
g.add_edge('E','F',2)
print (g.max_flow('A','F'))

g = FlowNetwork()
[g.add_vertex(v) for v in "ABCDEF"]
g.add_edge('A','B',5)
g.add_edge('A','C',5)

g.add_edge('A','D',5)
g.add_edge('B','E',10)
g.add_edge('C','E',6)
g.add_edge('D','E',5)
g.add_edge('E','F',12)
print (g.max_flow('A','F'))

g = FlowNetwork()
[g.add_vertex(v) for v in "ABCDE"]
g.add_edge('A','B',12)
g.add_edge('A','D',87)
g.add_edge('B','E',11)
g.add_edge('C','A',19)
g.add_edge('D','C',10)
g.add_edge('D','B',23)
g.add_edge('E','D',43)
print (g.max_flow('A','E'))

EJERCICIOS

1. Entender el cdigo, hacerle un seguimiento y probarlo con los

siguientes modelos de redes:

g = FlowNetwork()
[g.add_vertex(v) for v in "0ABCDEF"]
g.add_edge('0','A',8)
g.add_edge('0','B',7)
g.add_edge('0','C',4)
g.add_edge('A','D',3)
g.add_edge('A','B',1)
g.add_edge('B','D',4)
g.add_edge('B','C',2)
g.add_edge('B','E',5)
g.add_edge('C','E',4)
g.add_edge('D','F',9)
g.add_edge('E','D',1)
g.add_edge('E','F',6)
print (g.max_flow('0','F'))

g = FlowNetwork()
[g.add_vertex(v) for v in "sabcdt"]
g.add_edge('s','a',5)
g.add_edge('s','c',4)
g.add_edge('a','b',2)
g.add_edge('b','t',4)
g.add_edge('c','a',1)
g.add_edge('c','b',4)
g.add_edge('c','d',3)
g.add_edge('d','b',3)
g.add_edge('d','t',2)
print (g.max_flow('s','t'))

g = FlowNetwork()
[g.add_vertex(v) for v in "sabcdeft"]
g.add_edge('s','a',5)
g.add_edge('s','c',7)
g.add_edge('a','b',3)
g.add_edge('a','d',2)
g.add_edge('b','e',3)
g.add_edge('b','f',2)
g.add_edge('c','b',3)

g.add_edge('c','e',3)
g.add_edge('c','d',3)
g.add_edge('d','b',5)
g.add_edge('d','f',4)
g.add_edge('e','t',6)
g.add_edge('f','t',7)
print (g.max_flow('s','t'))

g = FlowNetwork()
[g.add_vertex(v) for v in "ABCDEF"]
g.add_edge('A','B',2)
g.add_edge('A','D',3)
g.add_edge('A','C',2)
g.add_edge('B','C',4)
g.add_edge('B','D',3)
g.add_edge('C','E',2)
g.add_edge('D','C',5)
g.add_edge('D','E',1)
g.add_edge('D','F',4)
g.add_edge('E','C',1)
g.add_edge('E','F',2)
print (g.max_flow('A','F'))

g = FlowNetwork()
[g.add_vertex(v) for v in "1234567"]
g.add_edge('1','2',7)
g.add_edge('1','3',4)
g.add_edge('1','4',8)
g.add_edge('2','4',7)
g.add_edge('2','5',2)
g.add_edge('3','5',9)
g.add_edge('3','6',5)
g.add_edge('4','5',9)
g.add_edge('5','6',8)
g.add_edge('5','7',6)
g.add_edge('6','7',8)
print (g.max_flow('1','7'))

g = FlowNetwork()
[g.add_vertex(v) for v in "0ABCDEF"]
g.add_edge('0','A',8)
g.add_edge('0','B',7)
g.add_edge('0','C',4)
g.add_edge('A','B',1)
g.add_edge('A','D',3)
g.add_edge('B','C',2)
g.add_edge('B','D',4)
g.add_edge('B','E',5)
g.add_edge('C','E',4)
g.add_edge('D','F',9)
g.add_edge('E','D',1)
g.add_edge('E','F',6)
print (g.max_flow('0','F'))

2. Intentar implementar otro Algoritmo de Flujo mximo en Python

diferente al visto en esta clase. Compararlo y describir sus ventajas y
desventajas con respecto al visto en clases.
def FlujoMaximo(fuente,sumidero):
s=fuente
t=sumidero
f=0
while(True):
x=depth_first(s,INT_MAX)
if x==0:
break
f=f+x
return f

def depth_first(G, r):

def visit(G, V, E):
padre = dict([])
Vp = {V}
w=V
while True:
if G[w]!=None:
V = G[w][0]
n=0
while V in Vp and n<len(G[w]):
V = G[w][n]
n=n+1
if n==len(G[w]) and V in Vp:
V = padre[w]
else:
padre[V] = w
Vp = Vp | {V}

T[V] = [w]
T[w] = T[w] + [V]
if len(Vp)==len(G):
return
w=V
T = {r: []}
visit(G, r, T)
return T

La diferencia de este algoritmo con el implementado en clase es la

eficiencia de cada uno de ellos, por la utilizacin y/o reutilizacin del
cdigo, la manera de abstraer e implementar el grafo y el uso de
diferentes mtodos para hallar el flujo mximo de estos.
VENTAJAS:
-

Este algoritmo para encontrar el flujo mximo no necesita la

implementacin de clases.
Usa una bsqueda a profundidad que lo vuelve ms eficiente.
Su implementacin no es tan compleja porque solo se usan
funciones.

DESVENTAJAS:
-

Su tiempo de ejecucin es algo ineficiente porque podra llegar a

tener un orden de n cuadrtico o cubico.
Usa varias funciones, en las que el enlazado puede tener errores
en algunos casos.

CUESTIONARIO
1. Cmo son los algoritmos de Flujo Mximo en los Modelos de redes?
Estos algoritmos buscan el flujo mximo de un grafo ponderado dirigido
recorriendo todo el grafo, nodo por nodo, y comparando las aristas,
asignndoles valores nulos al principio y despus de comparar todas las
aristas y sus pesos de nodo a nodo, se asigna el flujo que le
corresponde, imprimiendo al final el total de comparaciones que hizo,
siendo el flujo mximo de la red.

2. Cuntas implementaciones has encontrado del algoritmo de flujo

mximo en python? Describe sus diferencias
Se encontr un algoritmo que utilizaba una bsqueda a profundidad para
recorrer los nodos y saber cual tiene un mnimo peso, y otro que
implementaba y usaba una bsqueda a lo ancho, el uso de estos
mtodos es eficiente y ahorra muchos recursos en el momento de hallar
el flujo mximo.
A diferencia de otro algoritmo el cual utilizaba la iteratividad para poder
recorrer todo el grafo representando la red de flujos, este algoritmo si es
eficaz, pero no se ahorra tantos recursos como el tiempo ya que requera
de un tiempo de ejecucin cubico, el cual no es eficiente.
3. Cul es tu opinin sobre la importancia del algoritmo de Flujo
mximo?
La implementacin y el conocimiento de este algoritmo es muy
importante y de mucha utilidad, porque se puede usar para diversos
problemas y situaciones en las que se requiere saber el flujo mximo de
alguna red, como en una ciudad, cuanto es el mximo de tiempo que se
requiere de un punto a otro, o la distancia mxima que se recorrera de
un punto a otro, y as como para alguna carretera, el algoritmo de flujo
mximo se puede utilizar para otros problemas semejantes.