Problema de Coloreo de Grafos (PCG)

Diwsgen López Lozada Jesús Huerta Aguilar Juan Pablo Hernández Flores
Benemérita Universidad autónoma de Benemérita Universidad autónoma de Benemérita Universidad autónoma de
Puebla Puebla Puebla
FCC FCC FCC
202043856 202041509 202068295
diwsgen.lopez@alumno.buap.mx jesus.huertaag@alumno.buap.mx juan.hernandezfl@alumno.buap.mx

Juan Martínez Díaz

Benemérita Universidad autónoma de
Puebla
FCC
202045427
juan.martinezdiad@alumno.buap.mx

RESUMEN discutirán las ventajas y desventajas de cada uno. Además, se

El Problema de Coloreo de Grafos es uno de los problemas más
estudiados en teoría de grafos, y consiste en asignar un color a cada
vértice de un grafo de tal manera que dos vértices adyacentes no
tengan el mismo color. En este trabajo, se discutirán dos algoritmos
de búsqueda en grafos, DFS y BFS, que son fundamentales para el
problema de coloreo de grafos, y se presentarán implementaciones
en Python de estos algoritmos. También se mostrará cómo estos
algoritmos se pueden utilizar para resolver el problema de coloreo
de grafos.
PALABRAS CLAVE
Grafos, Programación, Algoritmos, Problema, Computación
explorarán algunas aplicaciones prácticas de estos algoritmos,
como el análisis de redes sociales y la búsqueda de caminos en un
laberinto.
INTRODUCCIÓN
El Problema de coloreo de grafos es uno de los problemas más
estudiados en teoría de grafos. Consiste en asignar un color a cada
vértice de un grafo de tal manera que dos vértices adyacentes no
tengan el mismo color. Este problema tiene diversas aplicaciones
prácticas en áreas como la planificación de horarios de clases,
asignación de recursos limitados y diseño de redes de
comunicación.

ABSTRACT Para resolver el problema de coloreo de grafos, existen diferentes

algoritmos y técnicas. En este artículo, nos centraremos en dos de
The Graph Coloring Problem is one of the most studied problems
los algoritmos de búsqueda en grafos más fundamentales: DFS
in graph theory, and consists of assigning a color to each vertex of
(Depth-First Search) y BFS (Breadth-First Search), y cómo se
a graph in such a way that two adjacent vertices do not have the
pueden implementar en Python para resolver el problema de
same color. In this paper, we will discuss two graph search
coloreo de grafos.
algorithms, DFS and BFS, which are fundamental for the Graph
Coloring Problem, and present Python implementations of these
algorithms. We will also show how these algorithms can be used to
solve the Graph Coloring Problem.

KEYWORDS
Graphs, Programming, Algorithms, Problem, Computing

OBJETIVO
El objetivo de este trabajo es presentar una introducción al
Problema de Coloreo de Grafos y dos algoritmos de búsqueda en
grafos, DFS y BFS, y mostrar cómo estos algoritmos se pueden
utilizar para resolver el problema de coloreo de grafos. Se
presentarán implementaciones en Python de estos algoritmos, y se
Ilustración 1: Diferencias entre BFS y DFS
DFS es un algoritmo de búsqueda en grafos que funciona
explorando tan lejos como sea posible a lo largo de cada rama antes
de retroceder. Es decir, se trata de un algoritmo de recorrido en
 BUAP, marzo 2023, Puebla, Puebla MEXICO
profundidad que se utiliza para visitar todos los vértices de un
grafo. Por otro lado, BFS es un algoritmo de búsqueda en grafos
que explora primero todos los vértices adyacentes al vértice inicial
antes de avanzar en profundidad. Es decir, es un algoritmo de
recorrido en anchura que se utiliza para visitar todos los vértices de
un grafo.
En este artículo, se presentarán implementaciones de ambos
algoritmos en Python y se explicará cómo se pueden utilizar para
resolver el problema de coloreo de grafos. Se analizará la
complejidad de cada algoritmo y se mostrarán ejemplos prácticos
de su aplicación en diferentes problemas de coloreo de grafos.
En resumen, el problema de coloreo de grafos es un tema
importante en la teoría de grafos y tiene aplicaciones prácticas en
diversas áreas. DFS y BFS son algoritmos fundamentales para
resolver este problema, y su implementación en Python puede
resultar útil en la resolución de problemas de coloreo de grafos en
diferentes situaciones.
PROBLEMA DE LOS CUATRO COLORES
El teorema de los cuatro colores afirma que, para colorear un mapa
geográfico plano sin que dos países colindantes tengan el mismo
color, basta con cuatro tonos diferentes o menos.
Se imponen las siguientes restricciones a los mapas aludidos en el
teorema:
1. Son siempre conexos –es decir, de una pieza– y cada una
de sus regiones también es conexa;
2. Dos territorios distintos de un mapa no pueden tocarse
sólo en un punto, es decir, para ser colindantes deben
compartir frontera en el sentido indicado en la figura 1.
Ilustración 2: Identificación de fronteras
Podría pensarse que un mapa con una gran cantidad regiones,
poseyendo extrañas formas, y colindando de manera singular
necesitaría mayor cantidad de colores que un mapa más sencillo.
Pero, el teorema afirma que no es el caso.
Ilustración 3: Evolución del mapa de coloreado
2
Fernando Zacarias Flores.
PROBLEMA DE COLOREO DE GRAFOS
El problema de coloreo de grafos es uno de los problemas más
conocidos y estudiados en la teoría de grafos. La idea es asignar un
color a cada vértice de un grafo, de tal manera que los vértices
adyacentes tengan colores diferentes. El objetivo es minimizar el
número de colores utilizados para colorear el grafo. Aunque el
problema de coloreo de grafos es NP-completo, se han desarrollado
varios algoritmos que pueden resolver muchos casos del problema
de manera eficiente. Entre estos algoritmos se encuentran el BFS y
el DFS, dos algoritmos que han sido fundamentales en la resolución
de muchos problemas de coloreo de grafos.
El algoritmo BFS (Breadth-First Search) es un algoritmo que se
utiliza para recorrer y buscar elementos en un grafo. El algoritmo
comienza por el nodo inicial y visita todos los nodos adyacentes
antes de pasar a los nodos más distantes. El algoritmo BFS es
utilizado en el problema de coloreo de grafos para determinar el
número cromático de un grafo, que es el número mínimo de colores
que se necesitan para colorear el grafo de manera que ningún
vértice adyacente tenga el mismo color.
El algoritmo DFS (Depth-First Search) es otro algoritmo utilizado
en la teoría de grafos para recorrer y buscar elementos en un grafo.
El algoritmo comienza en un nodo inicial y explora todo el grafo
hasta que no hay más nodos por visitar. El algoritmo DFS se utiliza
en el problema de coloreo de grafos para asignar colores a los
vértices del grafo. El algoritmo asigna un color al vértice actual y
luego recursivamente asigna colores a todos los vértices
adyacentes. Si el algoritmo encuentra un vértice que no se puede
colorear con el color actual, retrocede y prueba con un color
diferente.
Los algoritmos BFS y DFS han sido utilizados para resolver
muchos problemas de coloreo de grafos. El algoritmo BFS es
utilizado para determinar el número cromático de un grafo,
mientras que el algoritmo DFS es utilizado para asignar colores a
los vértices del grafo. Estos algoritmos son muy eficientes y se han
utilizado en muchos campos diferentes, como la programación de
horarios, la asignación de frecuencias en redes de comunicaciones,
la programación de rutas de transporte y la planificación de
ensamblajes en la fabricación.
Aunque el problema de coloreo de grafos es NP-completo, los
algoritmos BFS y DFS han sido fundamentales en la resolución de
muchos casos del problema de manera eficiente. La teoría de grafos
y la informática teórica siguen siendo un campo activo de
investigación y desarrollo de algoritmos para resolver problemas
cada vez más complejos. Los algoritmos BFS y DFS son solo
algunos de los muchos algoritmos que se han desarrollado en este
campo y que continúan siendo utilizados en la actualidad para
resolver problemas de coloreo de grafos y otros problemas
relacionados con la teoría de grafos.
 Análisis y Diseño de Algoritmos BUAP, marzo 2023, Puebla, Puebla MEXICO

return val
def IsEmpty(self):
result = False
if len(self.holder) == 0:
result = True
return result

A continuación, se define la función BFS, que implementa el

Ilustración 4: Coloración de vértices para el grafo Petersen
utilizando tres colores
CODIGO BFS
Este código implementa una búsqueda por amplitud (BFS) en un
grafo dado en Python. También muestra cómo dibujar el grafo
utilizando la biblioteca NetworkX y la biblioteca de visualización
de gráficos matplotlib.
algoritmo BFS en el grafo dado. Esta función toma el grafo, el nodo
de inicio, el nodo de finalización y la cola MyQUEUE como
argumentos. En primer lugar, inicializa un diccionario dist con el
nodo de inicio y su distancia a cero, y luego agrega el nodo de inicio
a una lista temporal temp_path y la agrega a la cola q. Luego,
mientras la cola no esté vacía, la función extrae el primer elemento
de la cola y lo asigna a tmp_path. La función luego obtiene el
último nodo en tmp_path y verifica si es el nodo de finalización.
Si es así, la función imprime VALID_PATH y la ruta temporal. De
lo contrario, la función agrega los nodos adyacentes al último nodo
a la cola si no han sido visitados antes y actualiza sus distancias en
el diccionario dist. La función continúa este proceso hasta que la
cola esté vacía.
path_queue = MyQUEUE() # now we make a queue
def BFS(graph, start, end, q):
dist = {start: 0}
temp_path = [start]
q.enqueue(temp_path)

import networkx as nx while not q.IsEmpty():

import matplotlib.pyplot as plt tmp_path = q.dequeue()
last_node = tmp_path[-1]
print (" ",tmp_path)
En la primera sección del código, se define el grafo de ejemplo if last_node == end:
print ("VALID_PATH:", tmp_path)
como un diccionario con nodos y sus conexiones. Después se for link_node in graph[last_node]:
define la clase MyQUEUE, que es una implementación básica de una if link_node not in dist:
dist[link_node] = dist[last_node] + 1
cola para ser utilizada en el algoritmo BFS. Esta clase tiene tres new_path = tmp_path + [link_node]
métodos: __init__, enqueue, dequeue, e IsEmpty. El q.enqueue(new_path)
método __init__ inicializa la cola, mientras que enqueue return dist
agrega un elemento al final de la cola. El método dequeue saca el
primer elemento de la cola y lo devuelve, mientras que IsEmpty Después de la definición de la función BFS, se llama a la función
verifica si la cola está vacía. BFS con el grafo dado, el nodo de inicio "A", el nodo de
finalización "D" y la cola path_queue. La distancia calculada
# a sample graph
graph = {'A': ['B', 'C', 'E'],
entre el nodo de inicio y el nodo de finalización se almacena en el
'B': ['A', 'C', 'D'], diccionario distances y se imprime en la pantalla.
'C': ['D'],
'D': ['C'],
'E': ['F', 'D'], distances = BFS(graph, "A", "D", path_queue)
'F': ['C']} print("Distances:", distances)

class MyQUEUE: # just an implementation of a queue

def __init__(self):
self.holder = [] Luego, se define la función printGraph, que toma el objeto de
def enqueue(self,val):
self.holder.append(val) grafo, la disposición de los nodos y el diccionario de distancias
def dequeue(self): como argumentos, y dibuja el grafo utilizando la biblioteca
val = None
try: NetworkX y la biblioteca de visualización de gráficos matplotlib.
val = self.holder[0] Esta función primero dibuja los nodos del grafo con diferentes
if len(self.holder) == 1:
self.holder = [] tamaños y colores. Luego, dibuja las conexiones entre los nodos
else: con flechas, y agrega etiquetas de nodos en el grafo que contienen
self.holder = self.holder[1:]
except:
el nombre del nodo y su distancia desde el nodo de inicio.
pass Finalmente, la función muestra el gráfico.

3
 BUAP, marzo 2023, Puebla, Puebla MEXICO Fernando Zacarias Flores.

# Funcion para dibujar el grafo

def printGraph(G, pos, distances):
# positions for all nodes
# nodes
nx.draw_networkx_nodes(G, pos, node_size=500,
node_color='#8FBC8F')

# edges
nx.draw_networkx_edges(G, pos, width=1, arrows=True,
arrowsize=20, arrowstyle='->')

# labels
labels = {node: f"{node}, {distances[node]}" for node
in G.nodes()}
nx.draw_networkx_labels(G, pos, labels, font_size=10,
font_family='cursive')

plt.axis('off')
plt.show()

Por último, se crea un objeto Graph de NetworkX con el

diccionario graph dado y se llama a la función printGraph con
el objeto del grafo, la disposición de los nodos y el diccionario de
distancias calculado anteriormente. Ilustración 6: Grafo final
# Crear un objeto Graph de NetworkX
G = nx.Graph(graph) En resumen, el código encuentra la distancia más corta entre dos
pos = nx.shell_layout(G) nodos en un grafo y lo visualiza en una gráfica.
printGraph(G, pos, distances)

Enlace del código BFS en Google Colab:

EJECUCIÓN: CODIGO BFS
El código implementa el algoritmo BFS (Breadth-First Search) para
encontrar la distancia más corta entre dos nodos en un grafo no
dirigido. El grafo utilizado es un ejemplo simple representado como
un diccionario de listas de adyacencia.
Primero, se define una clase de cola (MyQUEUE) para ser utilizada
en BFS. Luego, la función BFS toma el grafo, el nodo inicial y final,
y una cola como entrada, y devuelve un diccionario de distancias
de nodos desde el nodo inicial. La función también imprime la ruta
desde el nodo inicial hasta el nodo final.
https://colab.research.google.com/drive/1XAF9DPszIDqEYVOgX
P4oGvPL5hDugigz?usp=sharing
CODIGO DFS
networkx es una biblioteca de Python para la creación,
manipulación y visualización de estructuras de redes complejas.
matplotlib.pyplot es una biblioteca para crear gráficos y
trazar visualizaciones.
import networkx as nx
import matplotlib.pyplot as plt
Definir el grafo: el grafo se define como un diccionario llamado
"graph" con las claves como los nodos y los valores como las
listas de los vecinos de cada nodo.

graph = {
'5' : ['3','7'],
'3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : ['8'],
'8' : []
}
Ilustración 5: Ruta del nodo inicial al nodo final
visited = set() # Configurado para realizar un
Después de llamar a la función BFS, el código dibuja el grafo seguimiento de los nodos visitados del gráfico.
utilizando la biblioteca NetworkX. El tamaño y el color de los
nodos se establecen en la función printGraph, y las etiquetas de la función "dfs" es una función de búsqueda en profundidad que
nodo se establecen en función de la distancia de nodo calculada por recorre el grafo y muestra los nodos visitados y sus distancias desde
BFS. el nodo de inicio. La función actualiza también la distancia del
vecino si su distancia desde el nodo actual es mayor. La función
DFS se llama para el grafo definido anteriormente, comenzando en
el nodo '5' y se muestra en la consola.

4
 Análisis y Diseño de Algoritmos BUAP, marzo 2023, Puebla, Puebla MEXICO

for neighbour in graph[source]:

if neighbour not in distance or
def dfs(visited, graph, node, distance): #funcion para
dfs distance[neighbour] > distance[source] + 1:
distance[neighbour] = distance[source] +
if node not in visited:
1 # Actualizar la distancia del vecino
visited.add(node)
path, distance = recursive_dfs(graph,
print (f"Nodo: {node} Distancia:
neighbour, path, distance)
{distance[node]}")
for neighbour in graph[node]: return path, distance
distance[neighbour] = distance[node] + 1 #
Actualizar la distancia del vecino El segundo grafo se define como un diccionario llamado "graph2"
dfs(visited, graph, neighbour, distance)
con las claves como los nodos y los valores como las listas de los
# Codigo vecinos de cada nodo. El diccionario "distances" se define para
print("A continuación se muestra el algoritmo DFS")
start_node='5' tener una distancia de 0 para el nodo de inicio "A" y un valor
distance = {start_node: 0} infinito para los demás nodos.
dfs(visited, graph, start_node, distance)
graph2 = {"A":["B","C", "D"],
La función "printGraph" es una función que toma un objeto de "B":["E"],
"C":["F","G"],
grafo de NetworkX, una posición de nodos y las distancias de los "D":["H"],
nodos del nodo de inicio y dibuja el grafo correspondiente. "E":["I"],
"F":["J"]}
#Funcion para dibujar el grafo distances = {"A":0} # Inicializa la distancia del nodo de
def printGraph(G2, pos, distances=None): origen a 0 y de todos los demás a infinito
# positions for all nodes

# nodes La función "recursive_dfs" se llama para el grafo "graph2",

nx.draw_networkx_nodes(G2, pos,
node_size=500,node_color='#8FBC8F') comenzando en el nodo "A", con una lista de nodos vacía y el
diccionario "distances".
# edges
nx.draw_networkx_edges(G2, pos,
width=1,arrows=True,arrowsize=20,arrowstyle='->') path, distances = recursive_dfs(graph2, "A", [],
distances)
# Mostrar las distancias en los nodos
labels = {node: f"{node},{distances[node]}" for node
in G.nodes()}
La función "printGraph2" es similar a la función "printGraph"
nx.draw_networkx_labels(G, pos, labels, font_size=10, pero para el segundo grafo.
font_family='cursive')

plt.axis('off') #Funcion para dibujar el grafo

plt.show() def printGraph2(G2, pos, distances):
# positions for all nodes
# nodes
Crear un objeto Graph de NetworkX: un objeto de grafo de nx.draw_networkx_nodes(G2, pos,
node_size=500,node_color='#8FBC8F')
NetworkX se crea a partir del diccionario de grafo "graph" y se
llama "G". La posición de los nodos se define mediante la función # edges
nx.draw_networkx_edges(G2, pos,
"shell_layout" de NetworkX. La función "printGraph" width=1,arrows=True,arrowsize=20,arrowstyle='->')
se llama para el objeto de grafo "G", la posición de los nodos "pos"
# Mostrar las distancias en los nodos
y las distancias del nodo de inicio. labels = {node: f"{node},{distances[node]}" for node
in G2.nodes()}
# Crear un objeto Graph de NetworkX nx.draw_networkx_labels(G2, pos, labels,
G = nx.Graph(graph) font_size=10, font_family='cursive')
pos = nx.shell_layout(G)
printGraph(G, pos, distance) plt.axis('off')
plt.show()
# Mostrar el grafo en pantalla
plt.show()

Un objeto de grafo de NetworkX se crea a partir del segundo

La función "recursive_dfs" es una versión recursiva de la
diccionario de grafo "graph2" y se llama "G2", después se define la
función DFS. Toma un grafo, un nodo fuente, una lista de nodos
posición de los nodos.
visitados y un diccionario de distancias de nodos, y devuelve una
lista de nodos visitados y el diccionario de distancias. # Crear un objeto Graph de NetworkX
G2 = nx.Graph(graph2)
pos = nx.shell_layout(G2)
# Aqui inicia el dfs recursivo
def recursive_dfs(graph, source, path=[], distance={}): printGraph2(G2, pos, distances)
if source not in path:
path.append(source)
if source not in graph:
# Nodo hoja, retroceder
return path, distance

5
 BUAP, marzo 2023, Puebla, Puebla MEXICO Fernando Zacarias Flores.

EJECUCIÓN: CODIGO DFS

El código dado implementa dos algoritmos de búsqueda de
profundidad primero (DFS) en dos grafos diferentes utilizando la
biblioteca NetworkX de Python.

Ilustración 7: Distancias de cada nodo con base al nodo inicial

Ilustración 9: Grafo final "graph2"

El primer grafo se define como un diccionario de listas de
adyacencia y se muestra en pantalla con la función Enlace del código DFS en Google Colab:
printGraph(). A continuación, se ejecuta el algoritmo DFS https://colab.research.google.com/drive/1Nl0xw7spN13Ru9EiG_i
rVKGEQZ8ODADG?usp=sharing
desde el nodo '5' y se imprimen los nodos visitados junto con sus
distancias desde el nodo de inicio.

GRAFO POR COLOREAR

El grafo representado en el código es un grafo dirigido no
ponderado que contiene seis nodos etiquetados con las letras A, B,
C, D, E y F.

El grafo se ha implementado en Python utilizando un diccionario,

donde cada clave representa un nodo y su correspondiente valor es
una lista de los nodos adyacentes a los que está conectado por
aristas dirigidas. Por ejemplo, el nodo A está conectado a los nodos
C y D, mientras que el nodo C está conectado a los nodos A, B, E
y F. De manera similar, los nodos B, D, E y F tienen conexiones
con otros nodos del grafo.

Ilustración 8: Grafo final "graph"

El segundo grafo se define como otro diccionario de listas de

adyacencia. Luego, se ejecuta una implementación recursiva de
DFS desde el nodo "A" en el grafo y se imprimen los nodos
visitados junto con sus distancias desde el nodo de inicio. La
función printGraph2() también se utiliza para mostrar el grafo
resultante en pantalla.

Ilustración 10: Grafo inicial por colorear

6
 Análisis y Diseño de Algoritmos
CODIGO COLOREADO DE GRAFO
Importación de bibliotecas: En la primera línea, se importa la
biblioteca de NetworkX, que es una biblioteca de Python para el
análisis de redes complejas. En la segunda línea, se importa la
biblioteca de Matplotlib, que es una biblioteca de Python para
la creación de gráficos y visualización de datos.
import networkx as nx
import matplotlib.pyplot as plt
#from networkx import color
La función recursive_dfs es una implementación de la
búsqueda DFS (Depth-First Search) recursiva en un grafo. Esta
función toma como entrada el grafo y el nodo de inicio, y devuelve
el camino y la distancia recorrida para llegar a cada nodo desde el
nodo de inicio. En cada iteración, se agrega el nodo actual al
camino y se actualiza la distancia del nodo actual a cada uno de sus
vecinos. Si el nodo actual no tiene vecinos, se devuelve el camino
y la distancia actualizados.
def recursive_dfs(graph, source, path=[], distance={}):
if source not in path:
path.append(source)
if source not in graph:
# Nodo hoja, retroceder
return path, distance
for neighbour in graph[source]:
if neighbour not in distance or
distance[neighbour] > distance[source] + 1:
distance[neighbour] = distance[source] +
1 # Actualizar la distancia del vecino
path, distance = recursive_dfs(graph,
neighbour, path, distance)
return path, distance
La función color_nodes es la implementación de un algoritmo
de coloreo de nodos para el grafo. Esta función toma como entrada
el grafo y devuelve un diccionario de colores para cada nodo del
grafo. En cada iteración, se itera a través de todos los nodos del
grafo y se determinan los colores ya utilizados por los vecinos del
nodo actual. Luego, se determinan los colores disponibles y se
selecciona el color que minimiza la suma de colores de sus vecinos,
utilizando una función lambda.
#Funcion para el problema del coloreo
def color_nodes(graph):
# Inicializar el diccionario de colores (alamcenar
colores)
colors = {}
#Iteremos para todos los nodos del grafo
for node in graph:
#Obtenemos los colores usados por los vecinoes
del nodo actual
used_colors = set(colors[neighbour] for neighbour
in graph[node] if neighbour in colors)
#Obtenemos colores disponibles, desde uno hasta
el numero de nodos, y le restamos los colores usados por
los vecinos del nodo actual
available_colors = set(range(1, len(graph)+1)) -
used_colors
'''
Asigamos al nodo actual el color disponible
Luego buscamos en available_colors que minimice
el resultado de la suma
key indica que se debe buscar el minimo valor de
la expresion dada por lambda para cada color c
BUAP, marzo 2023, Puebla, Puebla MEXICO
Contandop con c eque es la cantidad de vecinos
del nodo actual
'''
colors[node] = min(available_colors, key=lambda
c: sum(1 for neighbour in graph[node] if
colors.get(neighbour, 0) == c))
return colors
El grafo utilizado como ejemplo en este código es un grafo no
dirigido con seis nodos (A, B, C, D, E, F) y seis aristas. El grafo se
define como un diccionario de Python, donde cada clave es un nodo
y cada valor es una lista de nodos vecinos.
# Definir el grafo
graph2 = {
'A' : ['C','D'],
'B' : ['C', 'D'],
'C' : ['A','B','E','F'],
'D' : ['A','B','E','F'],
'E' : ['D','C'],
'F' : ['C','D']
}
Se inicializa un diccionario de distancias con una distancia de 0
para el nodo de inicio (en este caso, el nodo A) y una distancia
infinita para todos los demás nodos. Luego, se llama a la función
recursive_dfs para calcular la distancia desde el nodo de
inicio a cada uno de los demás nodos en el grafo.
# Calcular las distancias
distances = {"A":0} # Inicializa la distancia del nodo de
origen a 0 y de todos los demás a infinito
path, distances = recursive_dfs(graph2, "A", [],
distances)
Cálculo de colores: Se llama a la función color_nodes para
calcular los colores para cada nodo del grafo.
# Calcular los colores
colors = color_nodes(graph2)
La función printGraph2 utiliza la biblioteca de NetworkX y la
biblioteca de Matplotlib para dibujar el grafo. La función toma
como entrada el objeto de grafo, la posición de cada nodo, la
distancia de cada nodo al nodo de inicio y el diccionario de colores.
La función dibuja los nodos y las aristas del grafo, y agrega
etiquetas que muestran la distancia y el nodo correspondiente.
#Funcion para dibujar el grafo
def printGraph2(G2, pos, distances, colors):
# positions for all nodes
# nodes
#Definimos los colores con la paleta tab10 para
colores mas brillantes
node_color = plt.cm.tab10([colors[node] for node in
G2.nodes()])
#Dibujamos los nodos
nx.draw_networkx_nodes(G2, pos, node_size=500,
node_color=node_color)
# edges
nx.draw_networkx_edges(G2, pos,
width=1,arrows=True,arrowsize=20,arrowstyle='<->')
# Mostrar las distancias en los nodos
labels = {node: f"{node},{distances[node]}" for node
in G2.nodes()}
nx.draw_networkx_labels(G2, pos, labels,
font_size=10, font_family='cursive')
plt.axis('off')
plt.show()
7
 BUAP, marzo 2023, Puebla, Puebla MEXICO
Se crea un objeto Graph de NetworkX a partir del diccionario
de grafo definido anteriormente. Luego, se llama a la función
printGraph2 para dibujar el grafo con los colores y las distancias
calculados anteriormente.
# Crear un objeto Graph de NetworkX
G2 = nx.Graph(graph2)
pos = nx.shell_layout(G2)
printGraph2(G2, pos, distances, colors)
EJECUCIÓN: CODIGO COLOREADO DE
__________ GRAFO
Al ejecutar el código se definirá y dibujará el grafo graph2, se
calcularán las distancias desde el nodo "A" a todos los demás nodos
utilizando una función de búsqueda en profundidad
(recursive_dfs), y se colorearán los nodos utilizando una
función de coloreo (color_nodes). Luego se llamará a la
función printGraph2 para dibujar el grafo con los nodos coloreados
según el algoritmo de coloreo utilizado.
Ilustración 11: Grafo final coloreado
En resumen, se generará y se mostrará un grafo con nodos
coloreados utilizando un algoritmo de coloreo.
Enlace del código de coloreado en Google Colab:
https://colab.research.google.com/drive/1USfkbhDkIgTa0Tlv85K
pLrWh2P6cvYs5?usp=sharing
Fernando Zacarias Flores.
CONCLUSIONES
En conclusión, el problema de coloreo de grafos es un problema
interesante y desafiante en la teoría de grafos, con aplicaciones
prácticas en el mundo real. Tanto el algoritmo de búsqueda en
profundidad (DFS) como el algoritmo de búsqueda en amplitud
(BFS) son importantes en la solución de este problema y en el
análisis de grafos en general. En Python, hay varias bibliotecas
útiles, como NetworkX y Matplotlib, que permiten la visualización
de grafos y la implementación de algoritmos para resolver el
problema de coloreo de grafos, como se muestra en el código
anterior. Además, la recursión es una herramienta poderosa en la
implementación de DFS, como se puede ver en el segundo ejemplo
de código. En resumen, el problema de coloreo de grafos, junto con
DFS y BFS, son conceptos clave en la teoría de grafos y su
aplicación en el mundo real, y Python ofrece herramientas útiles
para su implementación y visualización.
AGRADECIMIENTOS
Nos gustaría expresar nuestro agradecimiento al profesor Fernando
Zacarías Flores de la Benemérita Universidad Autónoma de Puebla
por impartir este interesante tema. Apreciamos su dedicación y
paciencia para guiarnos a través de los conceptos y ejemplos
prácticos, lo que nos permitió comprender mejor los algoritmos y
sus aplicaciones en la resolución de problemas de grafos. Estamos
agradecidos por su valioso tiempo y experiencia compartida con
nosotros.
REFERENCIAS
DECSAI, Departamento de Ciencias de la Computación e I.A. (s. f.).
Algoritmos greedy sobre grafos. Recuperado 27 de febrero de 2023, de
https://elvex.ugr.es/decsai/algorithms/slides/problems/Greedy%20Graph%
20Algorithms.pdf
Average, J. [@average_joe_mcc]. (9 de diciembre, 2021). DFS vs BFS
baby #math #mathtok #mathematics #cs #stemtok #compsci
#computerscience [Video]. TikTok.
https://www.tiktok.com/@average_joe_mcc/video/7039788372361022726
?_r=1&_t=8aTyrSFKVd7
Pablo. (s. f.). Capitulo 3 COLOREO DE GRAFOS. Recuperado 24 de
febrero de 2023, de
https://www.fceia.unr.edu.ar/~ptorres/Grafos2016/Clase%20Coloreo%201.
pdf