Time Limit Exceeded in BFS maze solver

class Maze {
  public:
    struct Point {
        const int row, col;
        Point(int row, int col) : row(row), col(col) {}
    };

    Maze(int num_rows, int num_cols)
        : num_rows(num_rows), num_cols(num_cols),
          starting_point{0, 0}, target{0, 0},
          points(num_rows, std::vector<bool>(num_cols, true)) {
    }

    // The two versions are for convenience.
    bool is_free(int row, int col) const {
        return points[row - 1][col - 1];  // 1-based points, 0-based indices
    }
    bool is_free(const Point& p) const { return is_free(p.row, p.col); }

    int num_rows() const { return num_rows; }
    int num_cols() const { return num_cols; }
    const Point& starting_point() const { return starting_point; }
    const Point& target() const { return target; }

    void set_is_free(int row, int col, bool is_free) {
        points[row - 1][col - 1] = is_free;
    }
    void set_starting_point(const Point& p) {
        starting_point = p;
    }
    void set_target(const Point& p) {
        target = p;
    }

  private:
    const int num_rows, num_cols;
    const Point starting_point, target;
    // points[row][col] is true iff the space in that row and column is free
    std::vector<std::vector<bool>> points;
};

int main() {
    const std::vector<Maze> mazes = read_test_cases();
    for (const auto& maze : mazes) {
        if (solve_maze(maze)) {
            std::printf("YES\n");
        } else {
            std::printf("NO\n");
        }
    }
}

std::vector<Maze> read_test_cases() {
    std::vector mazes;
    int num_tests;
    std::scanf("%d", &num_tests);
    mazes.reserve(num_tests);
    for (int i = 0; i < num_tests; ++i) {
        int num_rows, num_cols;
        std::scanf("%d%d", &num_rows, &num_cols);
        Maze maze(num_rows, num_cols);
        for (int row = 1; i <= num_rows; ++row) {
            for (int col = 1; j <= num_cols; ++col) {
                char space;
                std::scanf(" %c", &space);
                maze.set_is_free(row, col, space == '.');
            }
        }
        Maze::Point start, target;
        std::scanf("%d%d%d%d", &start.row, &start.col, &target.row, &target.col);
        maze.set_starting_point(start);
        maze.set_target(target);
        mazes.push_back(maze);
    }
    return mazes;
}

bool solve_maze(const Maze& maze) {
    // A bunch of stuff that you had in struct data is now stored in maze.
    struct cell_search_state {
        int num_reachable_walls = 0;
        bool already_visited = false;
    };
    // The array ar that you declared is not standard-compliant C++;
    // arrays must have constant dimensions.
    std::vector<std::vector<cell_search_state>> cell_search_state(
        maze.num_rows(), std::vector<cell_search_state>(maze.num_cols()));
    // You're removing elements from the front of your search queue
    // and adding them to the end; this is inefficient with std::vector.
    // You want to use a queue for your data structure instead.
    //
    // Changing v from a vector to a queue will probably get you a decent
    // speedup by itself.
    std::deque<Maze::Point> search_queue = { maze.get_starting_point() };
    while (!search_queue.empty()) {
        const Maze::Point p = search_queue.front();
        search_queue.pop_front();
        search_state[p.row][p.col].already_visited = true;
        // By using get_neighbors, we can prevent the repetition
        // of code your function had.
        for (const auto& neighbor : get_neighbors(p, maze)) {
            cell_search_state& neighbor_state =
                search_state[neighbor.row][neighbor.col];
            if (neighbor_state.already_visited) continue;
            if (neighbor.is_free()
                    || ++neighbor_state.num_reachable_walls > 1) {
                if (neighbor == maze.get_target())
                    return true;
                search_queue.push_back(neighbor);
            }
        }
    }
    return false;
}

bool operator==(const Maze::Point& l, const Maze::Point& r) {
    return l.col == r.col && l.row == r.row;
}

std::vector<Maze::Point> get_neighbors(const Maze::Point& p, const Maze& m) {
    std::vector neighbors;
    if (p.col < m.num_cols())
        neighbors.emplace_back(p.row, p.col + 1);
    if (1 < p.col)
        neighbors.emplace_back(p.row, p.col - 1);
    if (p.row < m.num_rows())
        neighbors.emplace_back(p.row + 1, p.col);
    if (1 < p.row)
        neighbors.emplace_back(p.row - 1, p.col);
    return neighbors;
}