first commit

horse_travel/main.go

@@ -0,0 +1,149 @@
+// 声明包为 main，表示这是一个可执行程序
+package main
+
+import (
+	"fmt"  // 导入 fmt 包，用于格式化输入输出
+	"time" // 导入 time 包，用于计算程序运行时间
+)
+
+// 定义常量 N，代表棋盘的大小为 8x8
+const N = 8
+
+var (
+	// dx 和 dy 数组定义了马在棋盘上可以移动的8个方向的 x 和 y 坐标变化
+	// 例如，(dx[0], dy[0]) = (2, 1) 表示马可以从 (x, y) 移动到 (x+2, y+1)
+	dx = []int{2, 1, -1, -2, -2, -1, 1, 2}
+	dy = []int{1, 2, 2, 1, -1, -2, -2, -1}
+	// stepCount 用于记录算法关键步骤的执行次数，主要用于性能分析
+	stepCount int64
+)
+
+// isValid 函数检查给定坐标 (x, y) 是否在棋盘内，并且该位置尚未被访问过
+// board[x][y] == -1 表示该位置未被访问
+func isValid(x, y int, board [][]int) bool {
+	stepCount++ // 每次检查都增加关键步骤计数
+	return x >= 0 && x < N && y >= 0 && y < N && board[x][y] == -1
+}
+
+// getDegree 函数计算从 (x, y) 位置出发，有多少个可行的下一步（即“出度”
+// 这是 Warnsdorff 规则的核心，用于优化路径选择
+func getDegree(x, y int, board [][]int) int {
+	count := 0
+	// 遍历8个可能的移动方向
+	for i := 0; i < 8; i++ {
+		// 如果移动后的位置是有效的，则计数器加一
+		if isValid(x+dx[i], y+dy[i], board) {
+			count++
+		}
+	}
+	return count
+}
+
+// solveKnightTour 是解决马踏棋盘问题的主要递归函数
+// x, y: 当前马的位置
+// moveCount: 当前是第几步
+// board: 棋盘状态
+func solveKnightTour(x, y, moveCount int, board [][]int) bool {
+	// 将当前位置标记为第 moveCount 步
+	board[x][y] = moveCount
+
+	// 如果已经走满了 N*N-1 步（步数从0开始），说明已经找到了一个完整的路径
+	if moveCount == N*N-1 {
+		return true // 返回 true 表示成功
+	}
+
+	// 定义一个结构体 Move，用于存储下一步的位置和该位置的“出度”
+	type Move struct {
+		x, y, degree int
+	}
+	// 创建一个切片，用于存储所有可能的下一步
+	moves := make([]Move, 0, 8)
+
+	// 遍历8个方向，找出所有有效的下一步
+	for i := 0; i < 8; i++ {
+		nx, ny := x+dx[i], y+dy[i]
+		if isValid(nx, ny, board) {
+			// 如果是有效的一步，计算该点的“出度”并存入 moves 切片
+			degree := getDegree(nx, ny, board)
+			moves = append(moves, Move{nx, ny, degree})
+		}
+	}
+
+	// 使用选择排序对所有可能的下一步进行排序，按照“出度”从小到大排序
+	// 这是 Warnsdorff 规则的应用：优先选择“出度”最少的点，这样可以减少后面出现“死路”的可能性
+	for i := 0; i < len(moves); i++ {
+		for j := i + 1; j < len(moves); j++ {
+			if moves[j].degree < moves[i].degree {
+				moves[i], moves[j] = moves[j], moves[i]
+			}
+		}
+	}
+
+	// 按照排序后的顺序，依次尝试每一个可能的下一步
+	for _, move := range moves {
+		// 递归调用 solveKnightTour，进入下一步
+		if solveKnightTour(move.x, move.y, moveCount+1, board) {
+			return true // 如果递归返回 true，说明找到了解，直接返回 true
+		}
+	}
+
+	// 如果所有可能的下一步都无法导致一个成功的解，则进行“回溯”
+	// 将当前位置重置为未访问状态 (-1)，并返回 false
+	board[x][y] = -1
+	return false
+}
+
+// printBoard 函数用于打印最终的棋盘路径
+func printBoard(board [][]int) {
+	fmt.Println("\n马踏棋盘路径:")
+	for i := range N {
+		for j := range N {
+			// 使用 %3d 格式化输出，使棋盘对齐
+			fmt.Printf("%3d", board[i][j])
+		}
+		fmt.Println() // 每行结束后换行
+	}
+}
+
+// main 函数是程序的入口
+func main() {
+	var startX, startY int
+	// 提示用户输入起始位置
+	fmt.Print("请输入起始位置 (x y, 范围0-7): ")
+	// 读取用户输入的坐标
+	fmt.Scanf("%d %d", &startX, &startY)
+
+	// 检查输入的坐标是否在有效范围内
+	if startX < 0 || startX >= N || startY < 0 || startY >= N {
+		fmt.Println("输入位置无效!")
+		return // 如果无效，程序退出
+	}
+
+	// 初始化棋盘，创建一个 N*N 的二维切片
+	board := make([][]int, N)
+	for i := range board {
+		board[i] = make([]int, N)
+		// 将棋盘所有位置初始化为 -1，表示都未被访问
+		for j := range board[i] {
+			board[i][j] = -1
+		}
+	}
+
+	// 重置关键步骤计数器
+	stepCount = 0
+	// 记录算法开始时间
+	start := time.Now()
+
+	// 调用 solveKnightTour 函数开始求解
+	if solveKnightTour(startX, startY, 0, board) {
+		// 如果求解成功
+		elapsed := time.Since(start) // 计算总耗时
+		printBoard(board)            // 打印棋盘
+		fmt.Printf("\n求解成功!\n")
+		fmt.Printf("运行时间: %v\n", elapsed)
+		fmt.Printf("关键步骤执行次数: %d\n", stepCount)
+	} else {
+		// 如果求解失败
+		fmt.Println("无解!")
+	}
+}