1. #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//valores definidos para verificar los nodos en busqueda
#define NO_VISITADO 0 //define que cualquier nodo no visitado este en 0
#define VISITADO 1 //define que cualquier nodo visitado este en 1
//valores definidos para los colores
#define SIN_COLOR 1 //valor asignado a los nodos antes de la busqueda en anchura
#define COLOR_1 1
#define COLOR_2 2
//valor definido de maximo de caracteres para el archiuvo
#define MAX_ARCHIVO 40 //define el tamaño maximo para el archivo
#define SINDEF -1
#define SIN_OCUPAR 0 //define a cada valor del arreglo que no este ocupado
#define SIN_ARISTA 0.0 //definido para la matriz que pone en 0.0 donde no hay
aristas entre nodos
#define ROOT -1
void bfs(int nodo, double** aristas_pesos, int nodos_max) { //nodos_max toma sus
valores de nodos previamente obtenidos al abrir el archivo .dat
int* rear = (int*)malloc(sizeof(int)*nodos_max);
int* color = (int*)malloc(sizeof(int)*nodos_max);
int* padre = (int*)malloc(sizeof(int)*nodos_max);
int* visitado = (int*)malloc(sizeof(int)*nodos_max);
int inicio, final, valor_actual_nodo, i = 0, j; //inicio variable de apoyo al
iniciar rear, final variable para marcar cuando lleguemos al final de rear
int conunter_conflic_color = 0;
do{
visitado[i] = NO_VISITADO;
rear[i] = SIN_OCUPAR;
padre[i] = ROOT;
color[i] = SIN_COLOR;
i++;
}while(i < nodos_max);
do {
inicio = 0;
rear[inicio] = nodo;//se asigna nodo que es del que partimos al inicio de la
cola
padre[nodo] = ROOT;
color[nodo] = COLOR_1;//se le asigna el color 1 al espacio del arreglo color
perteneciente a nodo inicial
final = 1;//final es el siguiente en la cola
do {
valor_actual_nodo = rear[inicio++];//asignamos el valor de la cola inicio al
valor del nodo actual
visitado[valor_actual_nodo] = VISITADO;//asignamos al arreglo de visitado el
primer nodo y se marca como visitado
if (color[valor_actual_nodo] == SIN_COLOR) {
if (color[padre[valor_actual_nodo]] == COLOR_1) {
color[valor_actual_nodo] = COLOR_2;
} else {
color[valor_actual_nodo] = COLOR_1;
}
}

2. printf("Visitando a nodo %d (color %d).n",valor_actual_nodo + 1,
color[valor_actual_nodo]);
for (i = 0; i < nodos_max; i++) {
if (aristas_pesos[valor_actual_nodo][i] > SIN_ARISTA) { // SIN_ARISTA
definido como 0.0 ya que si no hay cambio no hay peso y por lo tanto no hay arista
if (visitado[i] == NO_VISITADO) {
for (j = inicio; j < final; j++) {
if (rear[j] == i) {
break;
}
}
if (j == final) {
// no se ha visitado
rear[final++] = i;
padre[i] = valor_actual_nodo;
}
} else {
if (color[valor_actual_nodo] == color[i]) {
printf("Hay dos nodos con el mismo color que son vecinos.n");
conunter_conflic_color++;
break;
}//final de if conflicto de colores
}//final de else
}//fin de if condicion para saber si es vecino
} //fin de for i < que el maximo numero de nodos del grafo
} while (inicio < final);
if (conunter_conflic_color > 0) {
break;
}
} while (1);
if (conunter_conflic_color > 0) {
printf("No es un grafo que se pueda colorear con 2 colores:n");
for(i = 0;i < nodos_max;i++){
printf("[%d]t", color[i]);
}
printf("n");
} else {
printf("El grafo se puede colorear con 2 colores:n");
for (i = 0; i < nodos_max; i++) {
printf("[%d]t", color[i]);
}
printf("n");
}
//liberar memoria asignada
free(visitado);
free(rear);
free(padre);
free(color);
return;
}
void imprime(double** matriz, int dim) {
int x, y;
for (x = 0; x < dim; x++) {//x contador inicial que despliega los valores de
filas de la matriz

3. for (y = 0; y < dim; y++) {//y contador inicial que despliega las columnas de
la matriz
printf("%1.2lft ", matriz[x][y]);
}
printf("n");
}
return;
}
int main(int busqueda, char** anchura) {
int nodos = SINDEF; // numero de nodos
int aristas = SINDEF; // numero de aristas
int i, j, cont;
double p;
char c;
double** pesos = NULL; // matriz de pesos de aristas
char* archivo = NULL; // nombre de archivo de entrada
FILE* acceso = NULL; // puntero de acceso al archivo
int inicio = SINDEF; // nodo de inicio para busquedas/recorridos
archivo = (char*)malloc(sizeof(char)*MAX_ARCHIVO);
assert(archivo != NULL);
// lectura del grafo
printf("Dame el archivo del grafo: ");
scanf("%s", archivo);
printf("Abriendo archivo <%s>...n", archivo);
// abrir para lectura al archivo definido
acceso = fopen(archivo, "r"); // "r" = lectura
assert(acceso != NULL);
free(archivo); // liberar memoria que ya no se requiere
fscanf(acceso, "%c %dn", &c, &nodos);
fscanf(acceso, "%c %dn", &c, &aristas);
// reservar una matriz
pesos = (double**)malloc(sizeof(double*)*nodos);
for (i = 0; i < nodos; i++) {
pesos[i] = (double*)malloc(sizeof(double)*nodos);
for (j = 0; j < nodos; j++) {
pesos[i][j] = 0.0; // no hay aristas (todavia)
}
}
printf("Leyendo un grafo de %d nodos y %d aristas...n",
nodos, aristas);
// leer los pesos
cont = 0;
do {
fscanf(acceso, "%c ", &c);
if (c == 'a') {
fscanf(acceso, "%d %d %lfn", &i, &j, &p); // una arista nueva
pesos[i-1][j-1] = pesos[j-1][i-1] = p; // guardamos el peso en nuestra matriz
cont++;
}

4. } while(c != 'f');
assert(aristas == cont);
// cerramos archivo
fclose(acceso);
imprime(pesos, nodos);
// recorridos
printf("Define el nodo de inicio: ");
scanf("%d", &inicio);
//llamamos a la busqueda en anchura
bfs(inicio - 1, pesos, nodos); /* aqui damos los valores de ainicio que es
nuestro (nodo -1) debido que en el arreglo empieza en 0
pesos es nuestra matriz de adyacencia que
guarda los valores de las aristas
nodos es el numero total de nodos que tiene el
grafo*/
for (i = 0; i < nodos; i++) {
free(pesos[i]);
}
free(pesos);
return 3;
}