golang数据结构之递归解决迷宫问题

简单来说：递归就是函数/方法自己调用自己，只是每次传入不同的变量。

递归可以解决各种数学问题：n皇后问题、阶乘问题、汉诺塔、迷宫问题、球和篮子问题等等；

maze.go

package maze

import (
    "fmt"
)

func SetWay(myMap *[][]int, i int, j int) bool {
    //分析什么情况下就找到通路
    if myMap[][] ==  {
        return true
    } else {
        //如果是可以探测的
        if myMap[i][j] ==  {
            //假设是通的
            myMap[i][j] =
            //依据下右上左进行探测
            if SetWay(myMap, i+, j) {
                return true
            } else if SetWay(myMap, i, j+) {
                return true
            } else if SetWay(myMap, i-, j) {
                return true
            } else if SetWay(myMap, i, j-) {
                return true
            } else {
                //死路
                myMap[i][j] =
                return false
            }
        } else {
            //否则不能探测
            return false
        }
    }
}

func Maze() {
    //0：代表没有走过的路
    //1：代表墙
    //2：代表是一个通路
    //3：代表走过，但是不通
    var myMap [][]int
    for i := ; i < ; i++ {
        myMap[][i] =
        myMap[][i] =
    }
    for i := ; i < ; i++ {
        myMap[i][] =
        myMap[i][] =
    }
    myMap[][] =
    myMap[][] =
    myMap[][] =
    myMap[][] =
    myMap[][] =
    myMap[][] =
    for i := ; i < ; i++ {
        fmt.Println(myMap[i])
    }

    SetWay(&myMap, , )
    fmt.Println("探测完毕后的地图：")
    for i := ; i < ; i++ {
        fmt.Println(myMap[i])
    }
}

main.go

package main

import (
    "go_code/data_structure/maze"
)

func main() {

    maze.Maze()
}

运行结果：

f:\goproject\src\go_code\data_structure>go run main.go
[1 1 1 1 1 1 1]
[1 0 0 0 0 0 1]
[1 0 0 0 0 0 1]
[1 1 1 0 0 0 1]
[1 0 0 0 0 0 1]
[1 0 1 1 1 1 1]
[1 0 0 0 0 0 1]
[1 1 1 1 1 1 1]
探测完毕后的地图：
[1 1 1 1 1 1 1]
[1 2 3 3 3 3 1]
[1 2 2 2 3 3 1]
[1 1 1 2 3 3 1]
[1 2 2 2 3 3 1]
[1 2 1 1 1 1 1]
[1 2 2 2 2 2 1]
[1 1 1 1 1 1 1]