feat: implememented dijkstra algorithm

.gitignore

@@ -20,3 +20,5 @@
 # Go workspace file
 go.work
 /Session.vim
+/maze.png
+/maze_sol.png

io/writer/image_test.go

@@ -1,71 +1,122 @@
 package writer
 
 import (
+	"bytes"
+	"image/color"
+	"io"
+	"maze-solver/maze"
+	"os"
 	"testing"
+
+	"github.com/mazznoer/colorgrad"
+)
+
+const (
+	OUT_DIR      = "./out"
+	EXPECTED_DIR = "../../assets/solved"
 )
 
 func TestImageWriter(t *testing.T) {
-	// pathGradient, err := colorgrad.NewGradient().Colors(color.White).Build()
+	if _, err := os.Stat(OUT_DIR); os.IsNotExist(err) {
-	// if err != nil {
+		os.Mkdir(OUT_DIR, 0700)
-	// 	panic(err)
+	}
-	// }
+
-	//
+	tests := []struct {
-	// tests := []struct {
+		name                  string
-	// 	name                  string
+		filename              string
-	// 	filename              string
+		m                     *maze.SolvedMaze
-	// 	m                     *maze.SolvedMaze
+		CellWidth, cellHeight int
-	// 	CellWidth, cellHeight int
+		pathColor, wallColor  color.Color
-	// 	pathColor, wallColor  color.Color
+		gradient              colorgrad.Gradient
-	// 	gradient              colorgrad.Gradient
+	}{
-	// }{
+		{
-	// 	{
+			"Trivial",
-	// 		"Trivial",
+			"trivial.png",
-	// 		"../../out/trivial_sol.png",
+			trivial(),
-	// 		trivial(),
+			20, 20,
-	// 		40, 40,
+			color.White, color.Black,
-	// 		color.White, color.Black,
+			colorgrad.Warm(),
-	// 		colorgrad.Warm(),
+		},
-	// 	},
+		{
-	// 	{
+			"Trivial Bigger",
-	// 		"Bigger",
+			"trivial-bigger.png",
-	// 		"../../out/bigger_sol.png",
+			bigger(),
-	// 		bigger(),
+			20, 20,
-	// 		40, 40,
+			color.White, color.Black,
-	// 		color.White, color.Black,
+			colorgrad.Warm(),
-	// 		colorgrad.Warm(),
+		},
-	// 	},
+		{
-	// 	{
+			"Trivial Bigger Staggered",
-	// 		"Bigger Staggered",
+			"trivial-bigger-staggered.png",
-	// 		"../../out/bigger_staggered_sol.png",
+			bigger_staggered(),
-	// 		bigger_staggered(),
+			20, 20,
-	// 		40, 40,
+			color.White, color.Black,
-	// 		color.White, color.Black,
+			colorgrad.Warm(),
-	// 		pathGradient,
+		},
-	// 	},
+		{
-	// 	{
+			"Normal",
-	// 		"Normal",
+			"normal.png",
-	// 		"../../out/normal_sol.png",
+			normal(),
-	// 		normal(),
+			20, 20,
-	// 		40, 40,
+			color.White, color.Black,
-	// 		color.White, color.Black,
+			colorgrad.Warm(),
-	// 		colorgrad.Warm(),
+		},
-	// 	},
+	}
-	// }
+
-	//
+	for _, test := range tests {
-	// for _, test := range tests {
+		writer := ImageWriter{
-	// 	writer := ImageWriter{
+			Filename:         OUT_DIR + "/" + test.filename,
-	// 		Filename:         test.filename,
+			Maze:             test.m,
-	// 		Maze:             test.m,
+			CellWidth:        test.CellWidth,
-	// 		CellWidth:        test.CellWidth,
+			CellHeight:       test.cellHeight,
-	// 		CellHeight:       test.cellHeight,
+			WallColor:        test.wallColor,
-	// 		WallColor:        test.wallColor,
+			PathColor:        test.pathColor,
-	// 		PathColor:        test.pathColor,
+			SolutionGradient: test.gradient,
-	// 		SolutionGradient: test.gradient,
+		}
-	// 	}
+
-	//
+		err := writer.Write()
-	// 	err := writer.Write()
+		if err != nil {
-	// 	if err != nil {
+			t.Fatalf("%s: couldn't write solution, got following error\n%v", test.name, err)
-	// 		t.Fatalf("%s: couldn't write solution, got following error\n%v", test.name, err)
+		}
-	// 	}
+
-	// }
+		assertEqualFile(t, EXPECTED_DIR+"/"+test.filename, OUT_DIR+"/"+test.filename, test.name)
+		os.Remove(writer.Filename)
+	}
+	os.Remove(OUT_DIR)
+}
+
+const chunkSize = 64000
+
+func assertEqualFile(t *testing.T, file1, file2, name string) {
+	f1, err := os.Open(file1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f1.Close()
+
+	f2, err := os.Open(file2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f2.Close()
+
+	for {
+		b1 := make([]byte, chunkSize)
+		_, err1 := f1.Read(b1)
+
+		b2 := make([]byte, chunkSize)
+		_, err2 := f2.Read(b2)
+
+		if err1 != nil || err2 != nil {
+			if err1 == io.EOF && err2 == io.EOF {
+				return
+			} else if err1 == io.EOF || err2 == io.EOF {
+				t.Fatalf("%s: files are not equal. Got %q, wanted %q", name, file1, file2)
+			}
+		}
+
+		if !bytes.Equal(b1, b2) {
+			t.Fatalf("%s: files are not equal. Got %q, wanted %q", name, file1, file2)
+		}
+	}
 }

io/writer/strings_test.go

@@ -1,7 +1,6 @@
 package writer
 
 import (
-	"fmt"
 	"maze-solver/maze"
 	"maze-solver/utils"
 	"testing"
@@ -69,7 +68,6 @@ func TestStringsWriter(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		fmt.Printf("----------- %s -----------\n", test.name)
 		writer := StringsWriter{
 			PathChar:     test.pathChar,
 			WallChar:     test.wallChar,

main.go

@@ -131,12 +131,12 @@ func parse_arguments() (*reader.ReaderFactory, *writer.WriterFactory, *solver.So
 
 	cellSizeIn := argparser.Int("", "cell-size-in", &argparse.Options{
 		Help:    "Size of a cell (in pixels) for input file of image type",
-		Default: 20,
+		Default: 3,
 	})
 
 	cellSizeOut := argparser.Int("", "cell-size-out", &argparse.Options{
 		Help:    "Size of a cell (in pixels) for output file of image type",
-		Default: 20,
+		Default: 3,
 	})
 
 	solverFactory.Type = argparser.Selector("a", "algo", solver.TYPES, &argparse.Options{

maze/maze.go

@@ -30,6 +30,7 @@ type Node struct {
 	Coords      Coordinates
 	Up, Down    *Node
 	Left, Right *Node
+	Visited     bool `default:"false"`
 }
 
 func NewNode(coords Coordinates) *Node {

solver/bfs.go

@@ -1,9 +1,117 @@
 package solver
 
-import "maze-solver/maze"
+import (
+	"errors"
+	"fmt"
+	"maze-solver/maze"
+	"maze-solver/utils"
+	"strings"
+)
 
-type Bfs struct{}
+type BFSSolver struct {
-
+	queue *Queue
-func (*Bfs) Solve(maze *maze.Maze) *maze.SolvedMaze {
+}
-	return nil
+
+type Queue struct {
+	head, tail *Element
+}
+
+type Element struct {
+	prev, next *Element
+	value      []*maze.Node
+}
+
+func (q *Queue) enqueue(v []*maze.Node) {
+	prev_last := q.tail
+	new_elem := &Element{
+		prev:  prev_last,
+		next:  nil,
+		value: v,
+	}
+	if prev_last != nil {
+		prev_last.next = new_elem
+	}
+
+	q.tail = new_elem
+
+	if q.head == nil {
+		q.head = new_elem
+	}
+}
+
+func (q *Queue) dequeue() ([]*maze.Node, error) {
+	if q.head == nil {
+		return nil, errors.New("Can't dequeue and empty queue")
+	}
+	ret := q.head.value
+	q.head = q.head.next
+	if q.head != nil {
+		q.head.prev = nil
+	} else {
+		q.tail = nil
+	}
+
+	return ret, nil
+}
+
+func (q Queue) String() string {
+	var ret strings.Builder
+	i := 0
+	for history := q.head; history != nil; history = history.next {
+		ret.WriteString(fmt.Sprintf("%v: %v\n", i, history_str(history.value)))
+		i++
+	}
+	return ret.String()
+}
+
+func history_str(history []*maze.Node) string {
+	var ret strings.Builder
+	for _, node := range history {
+		ret.WriteString(fmt.Sprintf("%v ", node.Coords))
+	}
+	return ret.String()
+}
+
+func (s *BFSSolver) Solve(m *maze.Maze) *maze.SolvedMaze {
+	defer utils.Timer("BFS algorithm", 2)()
+
+	current, end := m.Nodes[0], m.Nodes[len(m.Nodes)-1]
+	s.queue = &Queue{
+		head: nil,
+		tail: nil,
+	}
+
+	current_history := make([]*maze.Node, 0, len(m.Nodes))
+	current_history = append(current_history, current)
+
+	var err error
+	for current != end {
+		current.Visited = true
+
+		s.addIfNotVisited(current.Down, current_history)
+		s.addIfNotVisited(current.Left, current_history)
+		s.addIfNotVisited(current.Right, current_history)
+		s.addIfNotVisited(current.Up, current_history)
+
+		current_history, err = s.queue.dequeue()
+		if err != nil {
+			panic(err)
+		}
+		current = current_history[len(current_history)-1]
+	}
+
+	return &maze.SolvedMaze{
+		Maze:     m,
+		Solution: current_history,
+	}
+}
+
+func (s *BFSSolver) addIfNotVisited(node *maze.Node, current_history []*maze.Node) {
+	if !visited(node) {
+		new_history := make([]*maze.Node, len(current_history)+1)
+		copy(new_history, current_history)
+		new_history[len(current_history)] = node
+
+		s.queue.enqueue(new_history)
+	}
 }

solver/dfs.go

@@ -1,35 +1,24 @@
 package solver
 
 import (
-	"log"
 	"maze-solver/maze"
 	"maze-solver/utils"
 )
 
-type DFSSolver struct {
+type DFSSolver struct{}
-	visited map[*maze.Node]bool
-}
 
 func (s *DFSSolver) Solve(m *maze.Maze) *maze.SolvedMaze {
-	defer utils.Timer("Turn left algorithm", 2)()
+	defer utils.Timer("DFS algorithm", 2)()
-
-	log.Println("Starting dfs")
-	log.Printf("m.Nodes: %v\n", len(m.Nodes))
 
 	current, end := m.Nodes[0], m.Nodes[len(m.Nodes)-1]
-	s.visited = make(map[*maze.Node]bool, len(m.Nodes))
-
-	for _, node := range m.Nodes {
-		s.visited[node] = false
-	}
 
 	stack := make([]*maze.Node, 0, len(m.Nodes))
 	stack = append(stack, current)
 
 	for current != end {
-		s.visited[current] = true
+		current.Visited = true
 
-		left_visited, right_visited, up_visited, down_visited := s.wasVisited(current.Left), s.wasVisited(current.Right), s.wasVisited(current.Up), s.wasVisited(current.Down)
+		left_visited, right_visited, up_visited, down_visited := visited(current.Left), visited(current.Right), visited(current.Up), visited(current.Down)
 
 		if left_visited && right_visited && up_visited && down_visited {
 			// dead end or no more visited nodes
@@ -57,11 +46,3 @@ func (s *DFSSolver) Solve(m *maze.Maze) *maze.SolvedMaze {
 	}
 	return ret
 }
-
-func (s *DFSSolver) wasVisited(node *maze.Node) bool {
-	if node == nil {
-		return true
-	}
-	visited, _ := s.visited[node]
-	return visited
-}

solver/dijkstra.go

@@ -0,0 +1,85 @@
+package solver
+
+import (
+	"maze-solver/maze"
+	"maze-solver/utils"
+	"slices"
+	"sort"
+)
+
+type DijkstraSolver struct {
+	dist_from_start map[*maze.Node]int
+	parent          map[*maze.Node]*maze.Node
+	stack           sorted_stack
+}
+
+type sorted_stack []*maze.Node
+
+func (s *DijkstraSolver) Solve(m *maze.Maze) *maze.SolvedMaze {
+	defer utils.Timer("Dijkstra algorithm", 2)()
+	s.dist_from_start = make(map[*maze.Node]int, len(m.Nodes))
+	s.parent = make(map[*maze.Node]*maze.Node, len(m.Nodes))
+
+	for _, node := range m.Nodes {
+		s.dist_from_start[node] = 0
+	}
+
+	current, end := m.Nodes[0], m.Nodes[len(m.Nodes)-1]
+
+	for current != end {
+		current.Visited = true
+
+		for _, child := range []*maze.Node{current.Left, current.Right, current.Up, current.Down} {
+			if child != nil {
+				dist := s.dist_from_start[current] + int(current.Coords.Distance(child.Coords))
+				if !child.Visited {
+					s.parent[child] = current
+					s.dist_from_start[child] = dist
+					s.stack.insert(child, &s.dist_from_start)
+				} else if s.dist_from_start[child] > dist {
+					s.parent[child] = current
+					s.dist_from_start[child] = dist
+					sort.Slice(s.stack, func(i, j int) bool {
+						return s.dist_from_start[s.stack[i]] < s.dist_from_start[s.stack[j]]
+					})
+				}
+			}
+		}
+		current = s.stack.pop()
+	}
+
+	solution := make([]*maze.Node, 0, len(m.Nodes))
+	for current != m.Nodes[0] {
+		solution = append(solution, current)
+		current = s.parent[current]
+	}
+	solution = append(solution, m.Nodes[0])
+
+	for i, j := 0, len(solution)-1; i < j; i, j = i+1, j-1 {
+		solution[i], solution[j] = solution[j], solution[i]
+	}
+
+	return &maze.SolvedMaze{
+		Maze:     m,
+		Solution: solution,
+	}
+}
+
+func (s *sorted_stack) insert(node *maze.Node, dists *map[*maze.Node]int) {
+	var dummy *maze.Node
+	*s = append(*s, dummy) // extend the slice
+
+	i, _ := slices.BinarySearchFunc(*s, node, func(e, t *maze.Node) int {
+		return (*dists)[t] - (*dists)[e]
+	})
+
+	copy((*s)[i+1:], (*s)[i:]) // make room
+	(*s)[i] = node
+}
+
+func (s *sorted_stack) pop() *maze.Node {
+	last_i := len(*s) - 1
+	ret := (*s)[last_i]
+	*s = (*s)[:last_i]
+	return ret
+}

solver/solver.go

@@ -14,17 +14,29 @@ type SolverFactory struct {
 }
 
 const (
-	_TURN_LEFT = "turn-left"
+	_DFS      = "dfs"
+	_BFS      = "bfs"
+	_Dijkstra = "dijkstra"
 )
 
 var TYPES = []string{
-	_TURN_LEFT,
+	_DFS,
+	_BFS,
+	_Dijkstra,
 }
 
 func (f *SolverFactory) Get() Solver {
 	switch *f.Type {
-	case _TURN_LEFT:
+	case _DFS:
 		return &DFSSolver{}
+	case _BFS:
+		return &BFSSolver{}
+	case _Dijkstra:
+		return &DijkstraSolver{}
 	}
 	panic(fmt.Sprintf("Unrecognized solver type %q", *f.Type))
 }
+
+func visited(node *maze.Node) bool {
+	return node == nil || node.Visited
+}