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
[email protected] [email protected] [email protected]

Juan Martínez Díaz

Benemérita Universidad autónoma de
Puebla
FCC
202045427
[email protected]

RESUMEN presentarán implementaciones en Python de estos algoritmos, y se

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

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

The Graph Coloring Problem is one of the most studied problems algoritmos y técnicas. En este artículo, nos centraremos en dos de
in graph theory, and consists of assigning a color to each vertex of los algoritmos de búsqueda en grafos más fundamentales: DFS
a graph in such a way that two adjacent vertices do not have the (Depth-First Search) y BFS (Breadth-First Search), y cómo se
same color. In this paper, we will discuss two graph search pueden implementar en Python para resolver el problema de
algorithms, DFS and BFS, which are fundamental for the Graph coloreo de grafos.
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 Ilustración 1: Diferencias entre BFS y DFS
grafos, DFS y BFS, y mostrar cómo estos algoritmos se pueden
utilizar para resolver el problema de coloreo de grafos. Se
 BUAP, marzo 2023, Puebla, Puebla MEXICO Fernando Zacarias Flores.

DFS es un algoritmo de búsqueda en grafos que funciona Los algoritmos BFS y DFS han sido utilizados para resolver
explorando tan lejos como sea posible a lo largo de cada rama antes muchos problemas de coloreo de grafos. El algoritmo BFS es
de retroceder. Es decir, se trata de un algoritmo de recorrido en utilizado para determinar el número cromático de un grafo,
profundidad que se utiliza para visitar todos los vértices de un mientras que el algoritmo DFS es utilizado para asignar colores a
grafo. Por otro lado, BFS es un algoritmo de búsqueda en grafos los vértices del grafo. Estos algoritmos son muy eficientes y se han
que explora primero todos los vértices adyacentes al vértice inicial utilizado en muchos campos diferentes, como la programación de
antes de avanzar en profundidad. Es decir, es un algoritmo de horarios, la asignación de frecuencias en redes de comunicaciones,
recorrido en anchura que se utiliza para visitar todos los vértices de la programación de rutas de transporte y la planificación de
un grafo. ensamblajes en la fabricación.

En este artículo, se presentarán implementaciones de ambos Aunque el problema de coloreo de grafos es NP-completo, los
algoritmos en Python y se explicará cómo se pueden utilizar para algoritmos BFS y DFS han sido fundamentales en la resolución de
resolver el problema de coloreo de grafos. Se analizará la muchos casos del problema de manera eficiente. La teoría de grafos
complejidad de cada algoritmo y se mostrarán ejemplos prácticos y la informática teórica siguen siendo un campo activo de
de su aplicación en diferentes problemas de coloreo de grafos. investigación y desarrollo de algoritmos para resolver problemas
cada vez más complejos. Los algoritmos BFS y DFS son solo
En resumen, el problema de coloreo de grafos es un tema algunos de los muchos algoritmos que se han desarrollado en este
importante en la teoría de grafos y tiene aplicaciones prácticas en campo y que continúan siendo utilizados en la actualidad para
diversas áreas. DFS y BFS son algoritmos fundamentales para resolver problemas de coloreo de grafos y otros problemas
resolver este problema, y su implementación en Python puede relacionados con la teoría de grafos.
resultar útil en la resolución de problemas de coloreo de grafos en
diferentes situaciones.

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 Ilustración 2: Coloración de vértices para el grafo Petersen
utiliza para recorrer y buscar elementos en un grafo. El algoritmo utilizando tres colores
comienza por el nodo inicial y visita todos los nodos adyacentes
antes de pasar a los nodos más distantes. El algoritmo BFS es CODIGO BFS
utilizado en el problema de coloreo de grafos para determinar el Este código implementa una búsqueda por amplitud (BFS) en un
número cromático de un grafo, que es el número mínimo de colores grafo dado en Python. También muestra cómo dibujar el grafo
que se necesitan para colorear el grafo de manera que ningún utilizando la biblioteca NetworkX y la biblioteca de visualización
vértice adyacente tenga el mismo color. de gráficos matplotlib.

El algoritmo DFS (Depth-First Search) es otro algoritmo utilizado import networkx as nx

en la teoría de grafos para recorrer y buscar elementos en un grafo. import matplotlib.pyplot as plt

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 la primera sección del código, se define el grafo de ejemplo
en el problema de coloreo de grafos para asignar colores a los como un diccionario con nodos y sus conexiones. Después se
vértices del grafo. El algoritmo asigna un color al vértice actual y define la clase MyQUEUE, que es una implementación básica de una
luego recursivamente asigna colores a todos los vértices cola para ser utilizada en el algoritmo BFS. Esta clase tiene tres
adyacentes. Si el algoritmo encuentra un vértice que no se puede métodos: __init__, enqueue, dequeue, e IsEmpty. El
colorear con el color actual, retrocede y prueba con un color método __init__ inicializa la cola, mientras que enqueue
diferente. agrega un elemento al final de la cola. El método dequeue saca el

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

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 entre el nodo de inicio y el nodo de finalización se almacena en el
graph = {'A': ['B', 'C', 'E'],
'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: tamaños y colores. Luego, dibuja las conexiones entre los nodos
self.holder = []
else: con flechas, y agrega etiquetas de nodos en el grafo que contienen
self.holder = self.holder[1:] el nombre del nodo y su distancia desde el nodo de inicio.
except:
pass Finalmente, la función muestra el gráfico.

return val # Funcion para dibujar el grafo

def IsEmpty(self): def printGraph(G, pos, distances):
result = False # positions for all nodes
if len(self.holder) == 0: # nodes
result = True nx.draw_networkx_nodes(G, pos, node_size=500,
return result node_color='#8FBC8F')

# edges
A continuación, se define la función BFS, que implementa el nx.draw_networkx_edges(G, pos, width=1, arrows=True,
algoritmo BFS en el grafo dado. Esta función toma el grafo, el nodo arrowsize=20, arrowstyle='->')

de inicio, el nodo de finalización y la cola MyQUEUE como # labels

argumentos. En primer lugar, inicializa un diccionario dist con el labels = {node: f"{node}, {distances[node]}" for node
in G.nodes()}
nodo de inicio y su distancia a cero, y luego agrega el nodo de inicio nx.draw_networkx_labels(G, pos, labels, font_size=10,
a una lista temporal temp_path y la agrega a la cola q. Luego, font_family='cursive')

mientras la cola no esté vacía, la función extrae el primer elemento plt.axis('off')

de la cola y lo asigna a tmp_path. La función luego obtiene el plt.show()

ú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 Por último, se crea un objeto Graph de NetworkX con el
lo contrario, la función agrega los nodos adyacentes al último nodo diccionario graph dado y se llama a la función printGraph con
a la cola si no han sido visitados antes y actualiza sus distancias en el objeto del grafo, la disposición de los nodos y el diccionario de
el diccionario dist. La función continúa este proceso hasta que la distancias calculado anteriormente.
cola esté vacía. # Crear un objeto Graph de NetworkX
G = nx.Graph(graph)
path_queue = MyQUEUE() # now we make a queue pos = nx.shell_layout(G)

def BFS(graph, start, end, q): printGraph(G, pos, distances)

dist = {start: 0}
temp_path = [start]
q.enqueue(temp_path)

while not q.IsEmpty():

tmp_path = q.dequeue() EJECUCIÓN: CODIGO BFS
last_node = tmp_path[-1]
print (" ",tmp_path) El código implementa el algoritmo BFS (Breadth-First Search) para
if last_node == end: encontrar la distancia más corta entre dos nodos en un grafo no
print ("VALID_PATH:", tmp_path)
for link_node in graph[last_node]: dirigido. El grafo utilizado es un ejemplo simple representado como
if link_node not in dist: un diccionario de listas de adyacencia.
dist[link_node] = dist[last_node] + 1
new_path = tmp_path + [link_node]
q.enqueue(new_path) Primero, se define una clase de cola (MyQUEUE) para ser utilizada
return dist 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

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

de nodos desde el nodo inicial. La función también imprime la ruta graph = {

'5' : ['3','7'],
desde el nodo inicial hasta el nodo final. '3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : ['8'],
'8' : []
}

visited = set() # Configurado para realizar un

seguimiento de los nodos visitados del gráfico.

la función "dfs" es una función de búsqueda en profundidad que

Ilustración 3: Ruta del nodo inicial al nodo final recorre el grafo y muestra los nodos visitados y sus distancias desde
el nodo de inicio. La función actualiza también la distancia del
Después de llamar a la función BFS, el código dibuja el grafo vecino si su distancia desde el nodo actual es mayor. La función
utilizando la biblioteca NetworkX. El tamaño y el color de los DFS se llama para el grafo definido anteriormente, comenzando en
nodos se establecen en la función printGraph, y las etiquetas de el nodo '5' y se muestra en la consola.
nodo se establecen en función de la distancia de nodo calculada por
def dfs(visited, graph, node, distance): #funcion para
BFS. dfs
if node not in visited:
visited.add(node)
print (f"Nodo: {node} Distancia:
{distance[node]}")
for neighbour in graph[node]:
distance[neighbour] = distance[node] + 1 #
Actualizar la distancia del vecino
dfs(visited, graph, neighbour, distance)

# Codigo
print("A continuación se muestra el algoritmo DFS")
start_node='5'
distance = {start_node: 0}
dfs(visited, graph, start_node, distance)

La función "printGraph" es una función que toma un objeto de

grafo de NetworkX, una posición de nodos y las distancias de los
nodos del nodo de inicio y dibuja el grafo correspondiente.

#Funcion para dibujar el grafo

def printGraph(G2, pos, distances=None):
# positions for all nodes

# nodes
Ilustración 4: Grafo final nx.draw_networkx_nodes(G2, pos,
node_size=500,node_color='#8FBC8F')

En resumen, el código encuentra la distancia más corta entre dos # edges

nx.draw_networkx_edges(G2, pos,
nodos en un grafo y lo visualiza en una gráfica. width=1,arrows=True,arrowsize=20,arrowstyle='->')

# Mostrar las distancias en los nodos

labels = {node: f"{node},{distances[node]}" for node
in G.nodes()}
nx.draw_networkx_labels(G, pos, labels, font_size=10,
CODIGO DFS font_family='cursive')
networkx es una biblioteca de Python para la creación,
plt.axis('off')
manipulación y visualización de estructuras de redes complejas. plt.show()
matplotlib.pyplot es una biblioteca para crear gráficos y
trazar visualizaciones. Crear un objeto Graph de NetworkX: un objeto de grafo de
NetworkX se crea a partir del diccionario de grafo "graph" y se
import networkx as nx llama "G". La posición de los nodos se define mediante la función
import matplotlib.pyplot as plt
"shell_layout" de NetworkX. La función "printGraph"
Definir el grafo: el grafo se define como un diccionario llamado se llama para el objeto de grafo "G", la posición de los nodos "pos"
"graph" con las claves como los nodos y los valores como las y las distancias del nodo de inicio.
listas de los vecinos de cada nodo.
# Crear un objeto Graph de NetworkX
G = nx.Graph(graph)

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

pos = nx.shell_layout(G) plt.axis('off')

printGraph(G, pos, distance) 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 # Crear un objeto Graph de NetworkX
lista de nodos visitados y el diccionario de distancias. G2 = nx.Graph(graph2)
pos = nx.shell_layout(G2)
# Aqui inicia el dfs recursivo printGraph2(G2, pos, distances)
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 EJECUCIÓN: CODIGO DFS
for neighbour in graph[source]:
if neighbour not in distance or El código dado implementa dos algoritmos de búsqueda de
distance[neighbour] > distance[source] + 1: profundidad primero (DFS) en dos grafos diferentes utilizando la
distance[neighbour] = distance[source] +
1 # Actualizar la distancia del vecino biblioteca NetworkX de Python.
path, distance = recursive_dfs(graph,
neighbour, path, distance)
return path, distance

El segundo grafo se define como un diccionario llamado "graph2"

con las claves como los nodos y los valores como las listas de los
vecinos de cada nodo. El diccionario "distances" se define para
tener una distancia de 0 para el nodo de inicio "A" y un valor
infinito para los demás nodos.

graph2 = {"A":["B","C", "D"],

"B":["E"],
"C":["F","G"], Ilustración 5: Distancias de cada nodo con base al nodo inicial
"D":["H"],
"E":["I"],
"F":["J"]}
El primer grafo se define como un diccionario de listas de
adyacencia y se muestra en pantalla con la función
distances = {"A":0} # Inicializa la distancia del nodo de printGraph(). A continuación, se ejecuta el algoritmo DFS
origen a 0 y de todos los demás a infinito
desde el nodo '5' y se imprimen los nodos visitados junto con sus
La función "recursive_dfs" se llama para el grafo "graph2", distancias desde el nodo de inicio.
comenzando en el nodo "A", con una lista de nodos vacía y el
diccionario "distances".

path, distances = recursive_dfs(graph2, "A", [],

distances)

La función "printGraph2" es similar a la función "printGraph"

pero para el segundo grafo.

#Funcion para dibujar el grafo

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

# 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, Ilustración 6: Grafo final "graph"
font_size=10, font_family='cursive')

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

El segundo grafo se define como otro diccionario de listas de return path, distance
for neighbour in graph[source]:
adyacencia. Luego, se ejecuta una implementación recursiva de if neighbour not in distance or
DFS desde el nodo "A" en el grafo y se imprimen los nodos distance[neighbour] > distance[source] + 1:
distance[neighbour] = distance[source] +
visitados junto con sus distancias desde el nodo de inicio. La 1 # Actualizar la distancia del vecino
función printGraph2() también se utiliza para mostrar el grafo path, distance = recursive_dfs(graph,
neighbour, path, distance)
resultante en pantalla. 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
Ilustración 7: Grafo final "graph2" el numero de nodos, y le restamos los colores usados por
los vecinos del nodo actual
available_colors = set(range(1, len(graph)+1)) -
En resumen, el código utiliza la biblioteca NetworkX para crear y used_colors
visualizar grafos, y también implementa dos algoritmos DFS para '''
Asigamos al nodo actual el color disponible
recorrer y encontrar distancias en los grafos. 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
Contandop con c eque es la cantidad de vecinos
del nodo actual
CODIGO COLOREADO DE GRAFO '''
colors[node] = min(available_colors, key=lambda
Importación de bibliotecas: En la primera línea, se importa la c: sum(1 for neighbour in graph[node] if
biblioteca de NetworkX, que es una biblioteca de Python para el colors.get(neighbour, 0) == c))
return colors
análisis de redes complejas. En la segunda línea, se importa la
biblioteca de Matplotlib, que es una biblioteca de Python para
El grafo utilizado como ejemplo en este código es un grafo no
la creación de gráficos y visualización de datos.
dirigido con seis nodos (A, B, C, D, E, F) y seis aristas. El grafo se
import networkx as nx
define como un diccionario de Python, donde cada clave es un nodo
import matplotlib.pyplot as plt y cada valor es una lista de nodos vecinos.
#from networkx import color
# Definir el grafo
La función recursive_dfs es una implementación de la graph2 = {
'A' : ['C','D'],
búsqueda DFS (Depth-First Search) recursiva en un grafo. Esta 'B' : ['C', 'D'],
función toma como entrada el grafo y el nodo de inicio, y devuelve 'C' : ['A','B','E','F'],
'D' : ['A','B','E','F'],
el camino y la distancia recorrida para llegar a cada nodo desde el 'E' : ['D','C'],
nodo de inicio. En cada iteración, se agrega el nodo actual al 'F' : ['C','D']
}
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
Se inicializa un diccionario de distancias con una distancia de 0
y la distancia actualizados.
para el nodo de inicio (en este caso, el nodo A) y una distancia
def recursive_dfs(graph, source, path=[], distance={}): infinita para todos los demás nodos. Luego, se llama a la función
if source not in path: recursive_dfs para calcular la distancia desde el nodo de
path.append(source)
if source not in graph: inicio a cada uno de los demás nodos en el grafo.
# Nodo hoja, retroceder

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

# 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): Ilustración 8: Grafo final coloreado
# positions for all nodes
# nodes
#Definimos los colores con la paleta tab10 para En resumen, se generará y se mostrará un grafo con nodos
colores mas brillantes coloreados utilizando un algoritmo de coloreo.
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 CONCLUSIONES
nx.draw_networkx_edges(G2, pos,
width=1,arrows=True,arrowsize=20,arrowstyle='<->') En conclusión, el problema de coloreo de grafos es un problema
interesante y desafiante en la teoría de grafos, con aplicaciones
# Mostrar las distancias en los nodos
labels = {node: f"{node},{distances[node]}" for node prácticas en el mundo real. Tanto el algoritmo de búsqueda en
in G2.nodes()} profundidad (DFS) como el algoritmo de búsqueda en amplitud
nx.draw_networkx_labels(G2, pos, labels,
font_size=10, font_family='cursive') (BFS) son importantes en la solución de este problema y en el
análisis de grafos en general. En Python, hay varias bibliotecas
plt.axis('off')
plt.show()
útiles, como NetworkX y Matplotlib, que permiten la visualización
de grafos y la implementación de algoritmos para resolver el
Se crea un objeto Graph de NetworkX a partir del diccionario problema de coloreo de grafos, como se muestra en el código
de grafo definido anteriormente. Luego, se llama a la función anterior. Además, la recursión es una herramienta poderosa en la
printGraph2 para dibujar el grafo con los colores y las distancias implementación de DFS, como se puede ver en el segundo ejemplo
calculados anteriormente. 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
# Crear un objeto Graph de NetworkX aplicación en el mundo real, y Python ofrece herramientas útiles
G2 = nx.Graph(graph2)
pos = nx.shell_layout(G2) para su implementación y visualización.
printGraph2(G2, pos, distances, colors)

AGRADECIMIENTOS
EJECUCIÓN: CODIGO COLOREADO DE Nos gustaría expresar nuestro agradecimiento al profesor Fernando
__________ GRAFO Zacarías Flores de la Benemérita Universidad Autónoma de Puebla
Al ejecutar el código se definirá y dibujará el grafo graph2, se por impartir este interesante tema. Apreciamos su dedicación y
calcularán las distancias desde el nodo "A" a todos los demás nodos paciencia para guiarnos a través de los conceptos y ejemplos
utilizando una función de búsqueda en profundidad prácticos, lo que nos permitió comprender mejor los algoritmos y
(recursive_dfs), y se colorearán los nodos utilizando una sus aplicaciones en la resolución de problemas de grafos. Estamos
función de coloreo (color_nodes). Luego se llamará a la agradecidos por su valioso tiempo y experiencia compartida con
función printGraph2 para dibujar el grafo con los nodos coloreados nosotros.
según el algoritmo de coloreo utilizado.

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

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