检查该位置是否是迷宫中的有效单元格

Question

我正在尝试制作迷宫。墙壁由“#”组成，我想使用“.”从左上角到右下角创建一条路径。我已经走到这一步了，但是当我运行现在我得到了一个分段错误并且没有任何反应。有人知道我做错了什么吗？我认为我的问题在于我的递归函数。做我的客人来编辑它！提前致谢！ :D

#include <iostream>
#include <vector>
#include <stack>
#include <sstream>
#include <time.h>

#define North 0
#define East 1
#define South 2
#define West 3

class Maze {
    private:
        int mazeHeight;
        int mazeWidth;
        int seedValue;
        std::vector <std::vector <char>> Maze;
    public:
        void checkuserInput(int Input1, int Input2);
        void mazeConstructor(int x, int y, int z, std::vector <std::vector <char>> vect);
        std::vector <std::vector <char>> initializeMaze();
};

class Path {
    private:
        std::vector <std::vector <char>> Grid;
        bool visited;
        int Height;
        int Width;
    public:
        void pathConstructor(std::vector <std::vector <char>> Maze, int mazeHeight, int mazeWidth);
        bool checkValid(int yPos, int xPos);
        void findPath(int yPos, int xPos);
        void printMaze();
};

// Check if user input is valid
void checkUserInput(int Input1, int Input2) {
    int Height;
    int Width;
    if (!(Input1 >> Height)) {
        throw std::runtime_error ("Invalid input");
    }
    if (!(Input2 >> Height)) {
        throw std::runtime_error ("Invalid input");
    }
} 
//Make the variables accesible
void Maze::mazeConstructor(int x, int y, int z, std::vector <std::vector <char>> vect) {
    mazeHeight = x;
    mazeWidth = y;
    seedValue = z;
    Maze = vect;
}
// Initialize the outer walls with '#'
std::vector <std::vector <char>> Maze::initializeMaze() {
    for (int i = 0; i < mazeWidth; i++) {
        for (int j = 0; j < mazeHeight; j++) {
            Maze[i][j] = '#';
        }
    }
    return Maze;
}
// Make the variables accessible
void Path::pathConstructor(std::vector <std::vector <char>> Maze, int mazeHeight, int mazeWidth) {
    Grid = Maze;
    Height = mazeHeight;
    Width = mazeWidth;
}

bool Path::checkValid(int yPos, int xPos) {
  if(xPos >= Width || xPos < 0) {
      return false;
  } 
  if(yPos >= Height || yPos < 0) {
      return false;
  }
  if (Grid[xPos][yPos] == '#') {
     return false;
  }
  return true;
} 

// Find a path using recursion
void Path::findPath(int yPos, int xPos) {
    if (yPos == Height || xPos == Width) {
        printMaze();
    }
    else {
        Grid[yPos][xPos] = '.';
        int randomNumber = rand() % 3; 
        switch (randomNumber) {
            case South:
                if (checkValid(yPos, xPos)) {
                findPath(yPos + 1, xPos);
                }
                else {
                    findPath(yPos, xPos);
                }
            case East:
                if (checkValid(yPos, xPos)) {
                findPath(yPos, xPos + 1);
                }
                else {
                    findPath(yPos, xPos);
                }
            case North:
                if (checkValid(yPos, xPos)) {
                findPath(yPos - 1, xPos); 
                }
                else {
                    findPath(yPos, xPos);
                }
            case West:
                if (checkValid(yPos, xPos)) {
                findPath(yPos, xPos - 1); 
                }
                else {
                    findPath(yPos, xPos);
                } 
        }   
    }
} 

// Output the maze
void Path::printMaze() {
    for (int i = 0; i < Grid.size(); i++) {
        for (int j = 0; j < Grid[0].size(); j++) {
            std::cout << Grid[i][j];
        }
        std::cout << std::endl;
    }
}

// Get command line arguments 
int main(int argc, char* argv[]) {
    Maze maze;
    Path Path;
    srand (time(0));
    int Height;
    int Width;
    int seedValue;
    Height = atoi(argv[2]);
    Width = atoi(argv[2]);
    try {
        checkUserInput(Height, Width);
    }
    catch(std::runtime_error& e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }
    if (argc > 3) {
        seedValue = atoi(argv[3]);
    } else {
        seedValue = rand();
    }
    std::vector <std::vector <char>> Maze (Height * 3 + 1, std::vector <char> (Width * 5 + 1, ' '));
    maze.mazeConstructor(Height, Width, seedValue, Maze);
    Path.pathConstructor(maze.initializeMaze(), Height, Width);
    Path.printMaze();
    Path.findPath(1, 1);
}```

Answer 1

方块无效

它的 x,y 位置在迷宫外。
它的 x,y 位置是一块砖

bool Path::checkValid(int yPos, int xPos) {
  if(xPos >= mazeWidth || xPos < 0){
      return false;
  } 

  if(yPos >= mazeHeight || yPos < 0){
      return false;
  }

  if(Maze[xPos][yPos] == '#'){
     return false;
  }
  return true;
}

Answer 2

如果我理解正确，你只需要检查这个位置是否在迷宫的边界内，并且它是一个有效的“单元格”。

要检查单元格的有效性，只需将您正在存储的字符与您正在使用的空字符进行比较。

要检查位置是否在迷宫内，您需要做的就是确保y值和x值分别在[0, mazeHeight)和[0, mazeWidth)范围内。一个简单的伪代码函数可能是这样的：

function checkValid(yPos, xPos)
    // Check that yPos is valid
    if yPos < 0 or yPos >= mazeHeight
        return false

    // Check that xPos is valid
    if xPos < 0 or xPos >= mazeWidth
        return false

    // At this point, you know the location is inside the maze
    // so just check it's an empty square
    return Maze[yPos][xPos] == ' ' // Assuming ' ' is empty

希望这对您有所帮助！

======================编辑======================

关于您的代码的几点补充：

在您的 findPath 函数中，当有 4 种可能的结果（0、1、2、3）时，您正在使用 rand() % 3。 rand() % 3 会将 换行到 3，所以你会得到这样的结果：[0, 1, 2, 0, 1, 2, 0, ...] if rand () 生成 [1, 2, 3, 4, ....]

仔细阅读您的代码，我相信 checkUserInput 是问题所在。您正在比较（想要比较）输入与宽度和高度——这不是代码在做什么：

// Check if user input is valid
void checkUserInput(int Input1, int Input2) {
    int Height; // Create a variable called height -- no initial value
    int Width; // Create a variable called width-- no initial value
    if (!(Input1 >> Height)) { // ???? -- See below
        throw std::runtime_error ("Invalid input");
    }
    if (!(Input2 >> Height)) { // Again, see below
        throw std::runtime_error ("Invalid input");
    }
}

要检查该值，您使用的是以下条件：!(Input1 >> Height)。我相信你想要做的是Input1 <= Height。运算符 >> 不是大于运算，它是按位左移，结果是将数字减半。（此外，一般来说，您应该只使用小于或等于 (<=) 而不是反转大于

的输出

然而，段错误的原因是未初始化的变量。 C++ 在您的程序中为它们创建了一小块内存，但尚未用有意义的东西填充 space。您需要使用 = 运算符将变量设置为某些内容（对其进行初始化）。

你如何选择解决这个问题取决于你，但我建议只使用 class

中的 mazeHeight 和 mazeWidth 成员变量

检查该位置是否是迷宫中的有效单元格

Check if the position is a valid cell in a maze

c++

maze