说明:

  1. 因为没有学习Go语言的GUI开发-GTK,因此我们在后台完成迷宫问题.
  2. 小球得到的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关
  3. 再得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径是不是有变化
  4. 思考:如何求出最短路径？

image.png

代码

  1. // 迷宫
  3. package main
  5. import "fmt"
  7. // 老鼠找路
  8. func SetWay(mazeMap *[8][7]int, i int, j int) bool {
  9.     var flag bool = false
  10.     if mazeMap[6][5] == 2 {
  11.         // 终点
  12.         flag = true
  13.     } else {
  14.         if mazeMap[i][j] == 0 {
  15.             // 标记可以走
  16.             mazeMap[i][j] = 2
  18.             // 这个点可以探测, 上下左右四个方向 实际走的路线是 "W"形状
  19.             /* if SetWay(mazeMap, i-1, j) { // 上
  20.                 flag = true
  21.             } else if SetWay(mazeMap, i+1, j) { // 下
  22.                 flag = true
  23.             } else if SetWay(mazeMap, i, j-1) { // 左
  24.                 flag = true
  25.             } else if SetWay(mazeMap, i, j+1) { // 右
  26.                 flag = true
  27.             } else {
  28.                 mazeMap[i][j] = 3
  29.                 flag = false
  30.             } */
  32.             // 更换 "下右上左" 的策略
  33.             if SetWay(mazeMap, i+1, j) { // 下
  34.                 flag = true
  35.             } else if SetWay(mazeMap, i, j+1) { // 右
  36.                 flag = true
  37.             } else if SetWay(mazeMap, i+1, j) { // 上
  38.                 flag = true
  39.             } else if SetWay(mazeMap, i, j-1) { // 左
  40.                 flag = true
  41.             } else {
  42.                 mazeMap[i][j] = 3
  43.                 flag = false
  44.             }
  46.         } else if mazeMap[i][j] == 1 {
  47.             // 这个点是墙，不能探测
  48.             flag = false
  49.         }
  50.     }
  51.     return flag
  52. }
  54. func main() {
  55.     // 创建二维数组 地图迷宫
  56.     /*
  57.        1. 如果元素为 1 代表墙
  58.        2.           0 代表没有走过的点
  59.        3.           2 代表可以行走
  60.        4.           3 代表走过的路，但是没有走通
  61.     */
  63.     var mazeMap [8][7]int // 8 行 7 列
  65.     // 初始化地图上的墙
  66.     // 上下的墙
  67.     for i := 0; i < 7; i++ {
  68.         mazeMap[0][i] = 1
  69.         mazeMap[7][i] = 1
  70.     }
  71.     // 左右的墙
  72.     for i := 0; i < 8; i++ {
  73.         mazeMap[i][0] = 1
  74.         mazeMap[i][6] = 1
  75.     }
  77.     // 设置墙
  78.     mazeMap[3][1] = 1
  79.     mazeMap[3][2] = 1
  80.     // mazeMap[1][2] = 1
  81.     // mazeMap[2][2] = 1
  83.     // 输出查看
  84.     for i := 0; i < 8; i++ {
  85.         for j := 0; j < 7; j++ {
  86.             fmt.Print(mazeMap[i][j], " ")
  87.         }
  88.         fmt.Println()
  89.     }
  90.     /*
  91.         1 1 1 1 1 1 1
  92.         1 0 0 0 0 0 1
  93.         1 0 0 0 0 0 1
  94.         1 0 0 0 0 0 1
  95.         1 0 0 0 0 0 1
  96.         1 0 0 0 0 0 1
  97.         1 0 0 0 0 0 1
  98.         1 1 1 1 1 1 1
  99.     */
  101.     // 测试
  102.     fmt.Println("探测")
  103.     SetWay(&mazeMap, 1, 1)
  105.     // 输出查看
  106.     for i := 0; i < 8; i++ {
  107.         for j := 0; j < 7; j++ {
  108.             fmt.Print(mazeMap[i][j], " ")
  109.         }
  110.         fmt.Println()
  111.     }
  112. }
  114. /*
  115. // 没有设置任何墙， 上下左右的策略
  116. 1 1 1 1 1 1 1
  117. 1 2 2 2 2 2 1
  118. 1 2 2 2 2 2 1
  119. 1 2 2 2 2 2 1
  120. 1 2 2 2 2 2 1
  121. 1 2 2 2 2 2 1
  122. 1 1 1 1 1 1 1
  124. // 设置两个墙， 上下左右的策略
  125. 1 1 1 1 1 1 1
  126. 1 2 2 2 2 2 1
  127. 1 2 2 2 2 2 1
  128. 1 1 1 2 2 2 1
  129. 1 3 3 2 2 2 1
  130. 1 3 3 2 2 2 1
  131. 1 3 3 2 2 2 1
  132. 1 1 1 1 1 1 1
  134. // 设置两个墙，下右上左的策略
  135. 1 1 1 1 1 1 1
  136. 1 2 0 0 0 0 1
  137. 1 2 2 2 0 0 1
  138. 1 1 1 2 0 0 1
  139. 1 0 0 2 0 0 1
  140. 1 0 0 2 0 0 1
  141. 1 0 0 2 2 2 1
  142. 1 1 1 1 1 1 1
  144. // 设置墙堵死
  145. 1 1 1 1 1 1 1
  146. 1 3 1 0 0 0 1
  147. 1 3 1 0 0 0 1
  148. 1 1 1 0 0 0 1
  149. 1 0 0 0 0 0 1
  150. 1 0 0 0 0 0 1
  151. 1 0 0 0 0 0 1
  152. 1 1 1 1 1 1 1
  153. */