用廣度優先算法求解迷宮的最短路徑（go語言）

用廣度優先算法求解迷宮的最短路徑

迷宮如下：0代表可以通過的路徑，1代表牆

---

思路

• 你可以想象你就在迷宮中，你每走的一步的是未知的，例如你走第二步的時候，如果周圍都沒有牆，你的路徑就是這樣：

        1
1      0      1
        1

• 下一步就是這樣：

              2
        2    1     2
   2    1    0     1     2
        2    1     2
              2

• 走到3步：

所以我們要用一個隊列保存上次已經探索的位置，並用相同大小的矩陣記錄步數。

---

假如我們在探索迷宮

• 第一步：

• 第二步：

• 第三步：

• 第四步：

最后生成如下解法：

---

解決方案

我們用1代表牆，0代表可以通過的路徑
初始化迷宮路徑如下，保存到文件中，具體怎么讀取解析下面有對應的代碼：

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

注意:路徑是相對gopath的路徑，這個矩陣最后有個換行符（記得加上）

---

代碼如下，基本上都有注釋，多看兩遍應該就懂了

package main

import (
	"fmt"
	"os"
)
/*
	author:hiram
 */

/* 從文件中讀取二維數組 */
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
}

/* 記錄位置 */
type point struct {
	i, j int
}

/* 上 左 下 右 */
var dirs = [4]point{{-1, 0}, {0, -1}, {1, 0}, {0, 1}}

/* 通過相加移動位置*/
func (p point) add(r point) point {
	return point{p.i + r.i, p.j + r.j}
}

/* 判斷這個點是否在二維數組中，如果在返回該節點 */
func (p point) at(grid [][]int) (int, bool) {
	if p.i < 0 || p.i >= len(grid) { //查看左右是否越界
		return 0, false
	}

	if 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 {
		steps[i] = make([]int, len(maze[i]))
	}

	Q := []point{start}

	for len(Q) > 0 {
		cur := Q[0]
		Q = Q[1:]

		if cur == end {
			break
		}

		for _, dir := range dirs {
			next := cur.add(dir)

			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 //記錄步數在二維數組中

			Q = append(Q, next) //將該節點添加進隊尾
		}
	}

	return steps
}

func main() {
	maze := readMaze("src/maze/maze.in")

	if len(maze) < 1 || len(maze[0]) < 1 {
		fmt.Println("輸入錯誤")
		return
	}
	printTwoDimensionalArray(maze)
	fmt.Println()
	
	steps := walk(maze, point{0, 0}, point{len(maze) - 1, len(maze[0]) - 1})

	printTwoDimensionalArray(steps)

	if len(steps) < 1 || len(steps[0]) < 1 || steps[len(steps)-1][len(steps[len(maze)-1])-1] == 0 {
		fmt.Println("不能抵達終點")
		return
	}

	stepPointArr := getStepPointArray(steps)

	fmt.Println()
	fmt.Println(stepPointArr)
}

/* 從結果集里面獲取走出迷宮的最短路徑 */
func getStepPointArray(iss [][]int) []point {
	var stepPointArr []point
	var p point

	var i, j = len(iss)-1, len(iss[len(iss)-1])-1
	p = point{i, j}
	var flag = true
	for flag {
		flag = false
		stepPointArr = append(stepPointArr, p)
		value, ok := p.at(iss)
		if !ok || value == 0 {
			break
		}
		for _, dir := range dirs {
			next := p.add(dir)
			val, isExist := next.at(iss)
			if isExist && val >= 0 && val == value-1 {
				p = next
				flag = true
				break
			}
		}
	}

	return stepPointArr
}

/* 打印二維數組*/
func printTwoDimensionalArray(iss [][]int) {
	for _, row := range iss {
		for _, val := range row {
			fmt.Printf("%3d", val)
		}
		fmt.Println()
	}
}

運行結果