graph coloring algororithm can now color sudoku. Added a worst-case puzzle which solves in 0.4s, still need to implement a function to free the graph, leaks like a sieve.

Author: imphasing

graph.c

@@ -6,35 +6,20 @@ struct graph *create_graph()
 {
 	struct graph *created = malloc(sizeof(struct graph));
 	created->vertices = NULL;
-	created->vertex_count = 0;
+	created->vertex_index = 1;
 
 	return created;
 }
 
-struct vertex *add_single_value_vertex(struct graph *graph, int value)
+struct vertex *add_vertex(struct graph *graph, int num_possible, int value)
 {
 	struct vertex *next = malloc(sizeof(struct vertex));
-	next->possibilities = malloc(sizeof(int));
-	*next->possibilities = value;
-	next->num_possible = 1;
+	next->index = graph->vertex_index++;
+	next->current_value = value;
+	next->num_possible = num_possible;
 	next->edges = NULL;
 	next->next = graph->vertices;
 	graph->vertices = next;
-	graph->vertex_count++;
-
-	return next;
-}
-
-struct vertex *add_multiple_value_vertex(struct graph *graph, int *possible_values, int count)
-{
-	struct vertex *next = malloc(sizeof(struct vertex));
-
-	next->possibilities = possible_values;
-	next->num_possible = count;
-	next->edges = NULL;
-	next->next = graph->vertices;
-	graph->vertices = next;
-	graph->vertex_count++;
 
 	return next;
 }
@@ -47,41 +32,20 @@ void add_edge(struct vertex *vertex1, struct vertex *vertex2)
 	vertex1->edges = next;
 }
 
-// create a new array of colors
-int *make_colors(int count)
-{
-	int *possible_values = malloc(sizeof(int) * count);
-
-	int c = 1;
-	for (c = 1; c <= count; c++)
-		possible_values[c - 1] = c;
-	
-	return possible_values;
-}
-
 void print_graph(struct graph *graph)
 {
 	int edge_count = 0;
 	struct vertex *last_vertex = graph->vertices;
 
 	while (last_vertex != NULL) {
-		printf("Vertex [");
-		int i = 0;
-		for (i = 0; i < last_vertex->num_possible; i++)
-			printf("%d, ", last_vertex->possibilities[i]);
-		printf("] connects to vertices: ");
-
+		printf("Vertex %d[%d] connects to vertices: ", last_vertex->index, last_vertex->current_value);
 		struct edge *last_edge = last_vertex->edges;
 
 		while (last_edge != NULL) {
 			if (last_edge->connects_to != NULL) {
 				edge_count++;
-
-				int j = 0;
-				printf("[");
-				for (j = 0; j < last_edge->connects_to->num_possible; j++)
-					printf("%d, ", last_edge->connects_to->possibilities[j]);
-				printf("], ");
+				printf("%d[%d], ", last_edge->connects_to->index,
+					last_edge->connects_to->current_value);
 			}
 
 			last_edge = last_edge->next;
@@ -95,3 +59,30 @@ void print_graph(struct graph *graph)
 	printf("Total edge count: %d\n", edge_count);
 }
 
+
+void print_sudoku(struct graph *graph, int size)
+{
+	int *output = malloc(sizeof(int) * (size * size));
+
+	struct vertex *last_vertex = graph->vertices;
+
+	int index = 0;
+	while (last_vertex != NULL) {
+		output[index] = last_vertex->current_value;
+		
+		last_vertex = last_vertex->next;
+		index++;
+	}
+
+	index--;
+	for (; index >= 0; index--)
+		printf("%d", output[index]);
+
+	printf("\n");
+}
+
+
+
+	
+	
+

graph.h

@@ -2,12 +2,13 @@
 
 struct graph {
 	struct vertex *vertices;
-	int vertex_count;
+	int vertex_index;
 };
 
 struct vertex {
-	int *possibilities;
+	int current_value;
 	int num_possible;
+	int index;
 
 	struct edge *edges;
 	struct vertex *next;
@@ -21,11 +22,10 @@ struct edge {
 
 
 struct graph *create_graph();
-struct vertex *add_single_value_vertex(struct graph *graph, int value);
-struct vertex *add_multiple_value_vertex(struct graph *graph, int *possible_values, int count);
+struct vertex *add_vertex(struct graph *graph, int num_possible, int value);
 void add_edge(struct vertex *vertex1, struct vertex *vertex2);
-int *make_colors(int count);
 void print_graph(struct graph *graph);
+void print_sudoku(struct graph *graph, int size);
 
-bool color_graph(struct vertex *vertex);
+bool color_graph(struct vertex *vertex, int num_colors);
 bool graph_colored(struct graph *graph);

graph_color.c

@@ -3,11 +3,22 @@
 #include <stdio.h>
 #include "graph.h"
 
+// check if an array contains a value
+bool array_contains(int *array, int count, int value)
+{
+	int i = 0;
+	for (i = 0; i < count; i++)
+		if (array[i] == value)
+			return true;
+	
+	return false;
+}
+
 
 // determine is a vertex is constrained to only a single given color
 bool vertex_must_be(struct vertex *vertex, int color)
 {
-	if (vertex->num_possible == 1 && vertex->possibilities[0] == color)
+	if (vertex->num_possible == 1 && vertex->current_value == color)
 		return true;
 
 	return false;
@@ -36,80 +47,57 @@ bool edges_disallow_color(struct vertex *vertex, int color)
 }
 
 
-// Pick a color for a vertex to try next
-int choose_color(struct vertex *vertex)
-{
-	if (vertex->num_possible == 1)
-		return 0;
-	else {
-		int chosen_index;
-		for (chosen_index = 0; chosen_index < vertex->num_possible; chosen_index++) {
-			if (edges_disallow_color(vertex, vertex->possibilities[chosen_index]))
-				continue;
-			else
-				return chosen_index;
-		}
-	}
-
-	return -1;
-}
-
-int *remove_possibility(int *possibilities, int count, int color)
+// See if a color is valid for a cell, not contained in any neighbors and not been removed
+int is_valid_color(struct vertex *vertex, int *removed, int removed_count, int color)
 {
-	int *new_possible = malloc(sizeof(int) * (count - 1));
+	if (vertex->num_possible == 1 && vertex->current_value == color)
+		return true;
+	else
+		if (!array_contains(removed, removed_count, color))
+			return !edges_disallow_color(vertex, color);
 
-	int i, j;
-	for (j = 0, i = 0; i < count; i++) {
-		if (possibilities[i] == color)
-			continue;
-
-		new_possible[j] = possibilities[i];
-		j++;
-	}
-
-	return new_possible;
+	return false;
 }
 
 
-bool color_graph(struct vertex *vertex)
+// Recursive backtracking algorithm
+bool color_graph(struct vertex *vertex, int num_colors)
 {
 	if (vertex == NULL)
 		return true;
 
-	while (vertex->num_possible > 1) {
-		int *saved_possible = vertex->possibilities;
-		int saved_num = vertex->num_possible;
+	int removed_index = 0;
+	int removed_colors[num_colors];
+	
+	int original_value = vertex->current_value;
+	int original_num = vertex->num_possible;
 
-		int next_candidate = choose_color(vertex);
 
-		if (next_candidate == -1)
-			return false;
+	if (original_num == 1)
+		return color_graph(vertex->next, num_colors);	
 
-		int *next_color = malloc(sizeof(int));
-		*next_color = saved_possible[next_candidate];
+	int i = 0;
+	for (i = 1; i <= original_num; i++) {
+		if (!is_valid_color(vertex, removed_colors, removed_index, i))
+			continue;
 
-		vertex->possibilities = next_color;
+		vertex->current_value = i;
 		vertex->num_possible = 1;
 
-		bool success = color_graph(vertex->next);
+		bool success = color_graph(vertex->next, num_colors);
 
 		if (success == false) {
-			int *new_possible = remove_possibility(
-				saved_possible, 
-				saved_num,
-				*next_color);
-
-			vertex->possibilities = new_possible;
-			vertex->num_possible = saved_num - 1;
+			removed_colors[removed_index] = i;
+			removed_index++;
+			vertex->num_possible = original_num;
+			vertex->current_value = original_value;
+		}
+		else {
+			return true;
 		}
-		else
-			break;
 	}
 
-	if (edges_disallow_color(vertex, vertex->possibilities[0]))
-		return false;
-	else
-		return color_graph(vertex->next);
+	return false;
 }
 
 
@@ -127,4 +115,3 @@ bool graph_colored(struct graph *graph)
 	return true;
 }
 
-

sample_puzzle renamed to sample_easy

@@ -0,0 +1 @@
+000000000000003085001020000000507000004000100090000000500000073002010000000040009

sample_worst

@@ -105,11 +105,11 @@ struct graph *load_initial()
 	for (i = 0; i < num_boxes; i++) { 
 		// add all 9 color possibilities if we get a 0, which is an unfilled cell
 		if (buffer[i] == '0') {
-			vertices[i] = add_multiple_value_vertex(graph, make_colors(9), 9);
+			vertices[i] = add_vertex(graph, 9, 0);
 		}
 		else {
 			// add a single possibility if we get a pre-filled cell
-			vertices[i] = add_single_value_vertex(graph, buffer[i] - '0');
+			vertices[i] = add_vertex(graph, 1, buffer[i] - '0');
 		}
 	}
 
@@ -123,44 +123,16 @@ struct graph *load_initial()
 
 int main(int argc, char **argv)
 {
-	struct graph *graph = create_graph();
-
-	struct vertex *vertex1 = add_multiple_value_vertex(graph, make_colors(4), 4);
-	struct vertex *vertex2 = add_multiple_value_vertex(graph, make_colors(4), 4);
-	struct vertex *vertex3 = add_multiple_value_vertex(graph, make_colors(4), 4);
-	struct vertex *vertex4 = add_multiple_value_vertex(graph, make_colors(4), 4);
-
-	struct vertex *vertex5 = add_multiple_value_vertex(graph, make_colors(4), 4);
-
-	add_edge(vertex1, vertex2);
-	add_edge(vertex1, vertex3);
-	add_edge(vertex1, vertex4);
-
-	add_edge(vertex2, vertex1);
-	add_edge(vertex2, vertex3);
-	add_edge(vertex2, vertex4);
-
-	add_edge(vertex3, vertex1);
-	add_edge(vertex3, vertex2);
-	add_edge(vertex3, vertex4);
-
-	add_edge(vertex4, vertex1);
-	add_edge(vertex4, vertex2);
-	add_edge(vertex4, vertex3);
-
-	add_edge(vertex3, vertex5);
-	add_edge(vertex5, vertex3);
-
-	print_graph(graph);
+	struct graph *graph = load_initial();
 
-	color_graph(graph->vertices);
+	color_graph(graph->vertices, 9);
 
 	if (graph_colored(graph))
 		printf("Graph is colored.\n");
 	else
 		printf("Graph is not colored.\n");
 
-	print_graph(graph);
+	print_sudoku(graph, 9);
 
 	return 0;
 }