【go语言】实现广度优先搜索

给定一个二维数组，0表示可走的点，1表示不可走的点，找出一条最短的路线

6 5
0 1 0 0 0
0 0 0 1 0
0 1 0 1 0
1 1 1 0 0
0 1 0 0 1
0 1 0 0 0

思路

1. 第一个节点开始，找到能走的点，放到队列
2. 从队列中取出一个，将找下一步的节点，按照逆时针的顺序找，队列里面的点，按照顺序找
3. 直到最后一个点 （结束）
4. 如果需要找到这条路线，则需要倒过来走，从最后的一步，然后一步一步走到第一步

go 语言要点

1. 用循环创建二维 slice， 不是一次make的
2. 使用 slice 来实现队列
3. 用 Fscanf 读取文件
4. 对 point 的抽象

package main

import (
	"fmt"
	"os"
)

func readMaze(filename string) [][]int {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	var row, col int
	fmt.Fscanf(file, "%d %d", &row, &col)

	maze := make([][]int, row)
	for i := range maze {
		maze[i] = make([]int, col)
		for j := range maze[i] {
			fmt.Fscanf(file, "%d", &maze[i][j])
		}
	}
	return maze
}

// 遍历[][]int
func printMaze(maze [][]int) {
	for _, row := range maze {
		for _, val := range row {
			fmt.Printf("%3d", val)
		}
		fmt.Println()
	}
}

type point struct {
	i, j int
}

// 定义四个方向
var dirs = [4]point{
	{-1, 0}, {0, -1}, {1, 0}, {0, 1}}

// 可以用*， 这里采用值类型，放回一个新的point
func (p point) add(r point) point {
	return point{p.i + r.i, p.j + r.j}
}

// 看下一个节点的值是什么，并关注下否越界
// bool: 是否越界
func (p point) at(grid [][]int) (int, bool) {
	if p.i < 0 || p.i >= len(grid) || p.j < 0 || p.j >= len(grid[p.i]) {
		return 0, false
	}
	return grid[p.i][p.j], true
}

func walk(maze [][]int, start, end point) [][]int {
	// 步数
	steps := make([][]int, len(maze))
	for i := range steps {
		// go 中默认初始化为0
		steps[i] = make([]int, len(maze[i]))
	}

	que := []point{start}

	// 队列不空才走下去
	for len(que) > 0 {
		cur := que[0]
		que = que[1:]

		// 等于终点
		if cur == end {
			break
		}

		for _, dir := range dirs {

			// 新发现的节点
			next := cur.add(dir)
			/**
			1. 探索下一个位置要能走
			2. 下一个位置以前没走过
			3. 不能是原点
			*/
			val, ok := next.at(maze)
			// 说明越界 或者 撞墙
			if !ok || val == 1 {
				continue
			}
			// 已经走过
			val, ok = next.at(steps)
			if !ok || val != 0 {
				continue
			}
			
			// 回到原点
			if next == start {
				continue
			}

			curSteps, _ := cur.at(steps)
			steps[next.i][next.j] = curSteps + 1

			que = append(que, next)
		}
	}
	return steps
}

func main() {
	//fmt.Println(os.Getwd())
	maze := readMaze("xxxxxx/xxx.txt")

	//printMaze(maze)
	steps := walk(maze, point{0, 0}, point{len(maze) - 1, len(maze[0]) - 1})

	fmt.Println("+++++++++++++++++++++++++++++++++++++++++++++++++++")
	printMaze(steps)
}