C# 迷宫求解

C# 迷宫求解可以通过深度优先搜索（DFS）或广度优先搜索（BFS）来实现。下面是一个基于DFS算法的C#代码示例，可以帮助你理解迷宫求解的实现过程：

using System;
using System.Collections.Generic;

class MazeSolver
{
    private int[,] maze; // 迷宫地图
    private bool[,] visited; // 记录是否访问过
    private int row, col; // 迷宫的行和列
    private int startRow, startCol; // 起点的位置
    private int endRow, endCol; // 终点的位置

    public MazeSolver(int[,] maze, int startRow, int startCol, int endRow, int endCol)
    {
        this.maze = maze;
        row = maze.GetLength(0);
        col = maze.GetLength(1);
        this.startRow = startRow;
        this.startCol = startCol;
        this.endRow = endRow;
        this.endCol = endCol;
        visited = new bool[row, col];
    }

    public bool Solve()
    {
        return DFS(startRow, startCol);
    }

    private bool DFS(int r, int c)
    {
        if (r == endRow && c == endCol)
        {
            return true; // 到达终点，返回true
        }

        visited[r, c] = true; // 标记为已访问

        // 按顺序尝试向上、右、下、左四个方向走
        int[] dr = { -1, 0, 1, 0 };
        int[] dc = { 0, 1, 0, -1 };
        for (int i = 0; i < 4; i++)
        {
            int nr = r + dr[i];
            int nc = c + dc[i];

            // 检查是否越界，是否可走，是否已访问过
            if (nr < 0 || nr >= row || nc < 0 || nc >= col)
            {
                continue;
            }
            if (maze[nr, nc] == 1 || visited[nr, nc])
            {
                continue;
            }

            // 递归尝试下一步
            if (DFS(nr, nc))
            {
                return true; // 找到一条可行路径，返回true
            }
        }

        return false; // 四个方向都尝试过了，无解，返回false
    }
}

class Program
{
    static void Main(string[] args)
    {
        int[,] maze = {
            { 0, 0, 1, 0, 0 },
            { 0, 0, 1, 0, 0 },
            { 0, 0, 0, 0, 1 },
            { 0, 1, 1, 0, 0 },
            { 0, 0, 0, 1, 0 }
        };
        int startRow = 0, startCol = 0;
        int endRow = 4, endCol = 4;

        MazeSolver solver = new MazeSolver(maze, startRow, startCol, endRow, endCol);
        if (solver.Solve())
        {
            Console.WriteLine("迷宫有解！");
        }
        else
        {
            Console.WriteLine("迷宫无解！");
        }
    }
}

上述代码中，我们使用DFS算法从起点开始搜索，按顺序尝试向上、右、下、左四个方向走，直到到达终点或四个方向都无法继续走。如果找到一条可行路径，返回true；否则返回false。