#include <vector>
#include <functional>
#include <stack>
#include <array>
#include <iostream>
#include <limits>
#include <unordered_set>
#include <cmath>
#include <chrono>
/**
* @brief Implementation of A* pathfinding algorithm.
* @see https://w...content-available-to-author-only...s.org/a-search-algorithm/
*/
class ASPFWrapper {
public:
enum class Heuristic : unsigned char {
kManhattan, // Best for 4-directional
kDiagonal, // Best for 8-directional
kEuclidean, // Works for any directions
};
enum class MovementType : bool {
k4Directional,
k8Directional,
};
enum class Status : unsigned char {
kInvalidSrc,
kInvalidDest,
kBlockedSrc,
kBlockedDest,
kCoincidents,
kSuccess,
kFailure,
};
template <typename T = int>
struct Cell {
T x, y;
inline bool operator==(Cell const& other) const { return x == other.x && y == other.y; }
inline Cell operator+(Cell const& other) const { return { x + other.x, y + other.y }; }
friend inline std::ostream& operator<<(std::ostream& os, Cell const& self) { return os << '(' << self.x << ", " << self.y << ')'; }
template <Heuristic H>
typename std::enable_if_t<H == Heuristic::kManhattan, double>
static getH(Cell const& lhs, Cell const& rhs);
template <Heuristic H>
typename std::enable_if_t<H == Heuristic::kDiagonal, double>
static getH(Cell const& lhs, Cell const& rhs);
template <Heuristic H>
typename std::enable_if_t<H == Heuristic::kEuclidean, double>
static getH(Cell const& lhs, Cell const& rhs);
struct Data {
Cell parent;
double g, h, f = std::numeric_limits<double>::max();
};
};
struct Result {
const Status status;
const std::stack<Cell<>> path;
Result(Status status, std::stack<Cell<>> path = {}) : status(status), path(path) {}
};
template <Heuristic H, MovementType M>
class ASPF {
public:
inline ASPF(std::vector<std::vector<int>> const& grid);
~ASPF() = default;
void setBegin(Cell<std::size_t> const& begin);
void setEnd(Cell<std::size_t> const& end);
Result search(Cell<> const& src, Cell<> const& dest);
private:
bool isValid(Cell<> const& cell) const;
bool isUnblocked(Cell<> const& cell) const;
bool isUnblocked(Cell<> const& parent, Cell<> const& successor) const;
std::stack<Cell<>> getPath(std::vector<std::vector<Cell<>::Data>> const& cellData, Cell<> const& dest) const;
static inline constexpr auto getDirections() {
if constexpr(M == MovementType::k4Directional) {
return std::array<Cell<>, 4>{{
{ 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 },
}};
} else {
return std::array<Cell<>, 8>{{
{ 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 },
{ 1, 1 }, { 1, -1 }, { -1, 1 }, { -1, -1 },
}};
}
}
std::vector<std::vector<int>> const& mGrid;
Cell<std::size_t> mBegin, mEnd;
static inline constexpr auto mDirections = getDirections();
};
template <Heuristic H = Heuristic::kManhattan, MovementType M = MovementType::k4Directional, typename... Args>
static inline ASPF<H, M> instantiate(Args&&... args) {
return ASPF<H, M>(std::forward<Args>(args)...);
}
};
template <typename T>
template <ASPFWrapper::Heuristic H>
typename std::enable_if_t<H == ASPFWrapper::Heuristic::kManhattan, double>
ASPFWrapper::Cell<T>::getH(Cell const& cell, Cell const& dest) {
return std::abs(cell.x - dest.x) + std::abs(cell.y - dest.y);
}
template <typename T>
template <ASPFWrapper::Heuristic H>
typename std::enable_if_t<H == ASPFWrapper::Heuristic::kDiagonal, double>
ASPFWrapper::Cell<T>::getH(Cell const& cell, Cell const& dest) {
static constexpr double kNodeLength = 1;
static constexpr double kNodeDiagonalDistance = std::sqrt(2);
auto dx = std::abs(cell.x - dest.x);
auto dy = std::abs(cell.y - dest.y);
return kNodeLength * (dx + dy) + (kNodeDiagonalDistance - kNodeLength * 2) * std::min(dx, dy);
}
template <typename T>
template <ASPFWrapper::Heuristic H>
typename std::enable_if_t<H == ASPFWrapper::Heuristic::kEuclidean, double>
ASPFWrapper::Cell<T>::getH(Cell const& cell, Cell const& dest) {
return std::sqrt(std::pow(cell.x - dest.x, 2) + std::pow(cell.y - dest.y, 2));
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
ASPFWrapper::ASPF<H, M>::ASPF(std::vector<std::vector<int>> const& grid) : mGrid(grid) {
setBegin({ 0, 0 });
setEnd({ 0, 0 });
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
bool ASPFWrapper::ASPF<H, M>::isValid(Cell<> const& cell) const {
return static_cast<int>(mBegin.x) <= cell.x <= static_cast<int>(mEnd.x) && static_cast<int>(mBegin.y) <= cell.y <= static_cast<int>(mEnd.y);
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
bool ASPFWrapper::ASPF<H, M>::isUnblocked(Cell<> const& cell) const {
return mGrid.at(cell.y).at(cell.x) != 0;
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
bool ASPFWrapper::ASPF<H, M>::isUnblocked(Cell<> const& cell, Cell<> const& successor) const {
return mGrid.at(successor.y).at(successor.x) != 0;
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
std::stack<ASPFWrapper::Cell<>> ASPFWrapper::ASPF<H, M>::getPath(std::vector<std::vector<Cell<>::Data>> const& cellData, Cell<> const& dest) const {
std::stack<Cell<>> path;
auto curr = dest;
while (!(cellData.at(curr.y - mBegin.y).at(curr.x - mBegin.x).parent == curr)) {
path.push(curr);
curr = cellData.at(curr.y - mBegin.y).at(curr.x - mBegin.x).parent;
}
path.push(curr);
return path;
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
void ASPFWrapper::ASPF<H, M>::setBegin(Cell<std::size_t> const& begin) {
mBegin = {
std::max((std::size_t)(0), begin.x),
std::max((std::size_t)(0), begin.y),
};
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
void ASPFWrapper::ASPF<H, M>::setEnd(Cell<std::size_t> const& end) {
mEnd = {
std::min(mGrid.front().size() - 1, end.x),
std::min(mGrid.size() - 1, end.y),
};
}
template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
ASPFWrapper::Result ASPFWrapper::ASPF<H, M>::search(Cell<> const& src, Cell<> const& dest) {
if (mGrid.empty()) return Result(Status::kFailure);
if (!isValid(src)) return Result(Status::kInvalidSrc);
if (!isValid(dest)) return Result(Status::kInvalidDest);
if (!isUnblocked(src)) return Result(Status::kBlockedSrc);
if (!isUnblocked(dest)) return Result(Status::kBlockedDest);
if (src == dest) return Result(Status::kCoincidents);
// Note that index-based operations on two following lists require substracting `mBegin` to match `mGrid`
// Initialize closed list
std::vector<std::vector<bool>> closedList(mEnd.y - mBegin.y + 1, std::vector<bool>(mEnd.x - mBegin.x + 1, false)); // `false` means not visited (and vice versa)
// Initialize cell data list
std::vector<std::vector<Cell<>::Data>> cellDataList(mEnd.y - mBegin.y + 1, std::vector<Cell<>::Data>(mEnd.x - mBegin.x + 1, Cell<>::Data{}));
// Initialize starting node parameters
auto& srcData = cellDataList[src.y - mBegin.y][src.x - mBegin.x];
srcData.f = 0;
srcData.parent = src;
// Initialize open list
std::stack<Cell<>> openList; // For operations at O(1) time complexity
openList.push(src); // Place the starting cell on the open list
double g, h, f;
while (!openList.empty()) {
g = h = f = 0;
auto parent = openList.top();
openList.pop(); // Remove cell from open list
closedList[parent.y - mBegin.y][parent.x - mBegin.x] = true; // Add cell to closed list
// Generate all successors
for (const auto& direction : mDirections) {
auto successor = parent + direction;
if (!isValid(successor)) continue;
// If successor is destination, search is considered successful
if (successor == dest) {
cellDataList[successor.y - mBegin.y][successor.x - mBegin.x].parent = parent;
return Result(Status::kSuccess, getPath(cellDataList, dest));
}
// Ignore if successor is already on the closed list or is blocked
if (!closedList.at(successor.y - mBegin.y).at(successor.x - mBegin.x) && isUnblocked(successor)) {
g = cellDataList[parent.y - mBegin.y][parent.x - mBegin.x].g + std::sqrt(std::pow(direction.x, 2) + std::pow(direction.y, 2));
h = Cell<>::getH<H>(successor, dest);
f = g + h;
auto& successorData = cellDataList[successor.y - mBegin.y][successor.x - mBegin.x];
// Add successor to the open list if successor is not on the open list or provides a better path
if (successorData.f == std::numeric_limits<double>::max() || successorData.f > f) {
openList.push(successor);
// Update successor data
successorData.f = f;
successorData.g = g;
successorData.h = h;
successorData.parent = parent;
}
}
}
}
// Search is considered unsuccessful if the open list is emptied before destination cell is found
return Result(Status::kFailure);
}
/* * * * * * */
int main(void) {
std::vector<std::vector<int>> vec = {
{{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
{{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
{{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
{{ 0, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 0, 4171, 4171, 4171, 0, 0, }},
{{ 0, 4171, 4171, 4171, 0, 0, 4171, 4171, 4171, 0, 4171, 0, 0, 0, 0, }},
{{ 0, 4171, 4171, 4171, 0, 0, 4171, 4171, 4171, 0, 4171, 0, 0, 0, 0, }},
{{ 0, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 4171, 0, 4171, 4171, 0, 0, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, }},
{{ 0, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, 4171, 4171, 4171, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 0, 0, 0, 4171, 4171, 4171, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 0, 0, 0, 4171, 0, 0, 0, }},
{{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, }},
{{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
};
// input is not inverted
ASPFWrapper::Cell<> src = { 12, 4 };
ASPFWrapper::Cell<> dest = { 5, 15 };
auto obj = ASPFWrapper::instantiate(vec);
obj.setBegin({ 1, 1 });
obj.setEnd({ vec.front().size() - 2, vec.size() - 2 });
auto start = std::chrono::high_resolution_clock::now();
auto res = obj.search(src, dest);
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << "Execution time: " << duration.count() << " ms" << std::endl;
std::cout << "Status: " << static_cast<int>(res.status) << std::endl;
auto path = res.path;
while (path.size() > 1) {
std::cout << "(" << path.top().x << ", " << path.top().y << ") -> ";
path.pop();
}
std::cout << path.top() << std::endl;
return 0;
}
#include <vector>
#include <functional>
#include <stack>
#include <array>
#include <iostream>
#include <limits>
#include <unordered_set>
#include <cmath>

#include <chrono>


/**
 * @brief Implementation of A* pathfinding algorithm.
 * @see https://w...content-available-to-author-only...s.org/a-search-algorithm/
*/
class ASPFWrapper {
    public:
        enum class Heuristic : unsigned char {
            kManhattan,   // Best for 4-directional
            kDiagonal,   // Best for 8-directional
            kEuclidean,   // Works for any directions
        };

        enum class MovementType : bool {
            k4Directional,
            k8Directional,
        };

        enum class Status : unsigned char {
            kInvalidSrc,
            kInvalidDest,
            kBlockedSrc,
            kBlockedDest,
            kCoincidents,

            kSuccess,
            kFailure,
        };

        template <typename T = int>
        struct Cell {
            T x, y;

            inline bool operator==(Cell const& other) const { return x == other.x && y == other.y; }
            inline Cell operator+(Cell const& other) const { return { x + other.x, y + other.y }; }
            friend inline std::ostream& operator<<(std::ostream& os, Cell const& self) { return os << '(' << self.x << ", " << self.y << ')'; }

            template <Heuristic H>
            typename std::enable_if_t<H == Heuristic::kManhattan, double>
            static getH(Cell const& lhs, Cell const& rhs);

            template <Heuristic H>
            typename std::enable_if_t<H == Heuristic::kDiagonal, double>
            static getH(Cell const& lhs, Cell const& rhs);

            template <Heuristic H>
            typename std::enable_if_t<H == Heuristic::kEuclidean, double>
            static getH(Cell const& lhs, Cell const& rhs);

            struct Data {
                Cell parent;
                double g, h, f = std::numeric_limits<double>::max();
            };
        };

        struct Result {
            const Status status;
            const std::stack<Cell<>> path;

            Result(Status status, std::stack<Cell<>> path = {}) : status(status), path(path) {}
        };

        template <Heuristic H, MovementType M>
        class ASPF {
            public:
                inline ASPF(std::vector<std::vector<int>> const& grid);
                ~ASPF() = default;

                void setBegin(Cell<std::size_t> const& begin);
                void setEnd(Cell<std::size_t> const& end);

                Result search(Cell<> const& src, Cell<> const& dest);

            private:
                bool isValid(Cell<> const& cell) const;
                bool isUnblocked(Cell<> const& cell) const;
                bool isUnblocked(Cell<> const& parent, Cell<> const& successor) const;

                std::stack<Cell<>> getPath(std::vector<std::vector<Cell<>::Data>> const& cellData, Cell<> const& dest) const;

                static inline constexpr auto getDirections() {
                    if constexpr(M == MovementType::k4Directional) {
                        return std::array<Cell<>, 4>{{
                            { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 },
                        }};
                    } else {
                        return std::array<Cell<>, 8>{{
                            { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 },
                            { 1, 1 }, { 1, -1 }, { -1, 1 }, { -1, -1 },
                        }};
                    }
                }

                std::vector<std::vector<int>> const& mGrid;
                Cell<std::size_t> mBegin, mEnd;

                static inline constexpr auto mDirections = getDirections();
        };

        template <Heuristic H = Heuristic::kManhattan, MovementType M = MovementType::k4Directional, typename... Args>
        static inline ASPF<H, M> instantiate(Args&&... args) {
            return ASPF<H, M>(std::forward<Args>(args)...);
        }
};


template <typename T>
template <ASPFWrapper::Heuristic H>
typename std::enable_if_t<H == ASPFWrapper::Heuristic::kManhattan, double>
ASPFWrapper::Cell<T>::getH(Cell const& cell, Cell const& dest) {
    return std::abs(cell.x - dest.x) + std::abs(cell.y - dest.y);
}

template <typename T>
template <ASPFWrapper::Heuristic H>
typename std::enable_if_t<H == ASPFWrapper::Heuristic::kDiagonal, double>
ASPFWrapper::Cell<T>::getH(Cell const& cell, Cell const& dest) {
    static constexpr double kNodeLength = 1;
    static constexpr double kNodeDiagonalDistance = std::sqrt(2);

    auto dx = std::abs(cell.x - dest.x);
    auto dy = std::abs(cell.y - dest.y);
    return kNodeLength * (dx + dy) + (kNodeDiagonalDistance - kNodeLength * 2) * std::min(dx, dy);
}

template <typename T>
template <ASPFWrapper::Heuristic H>
typename std::enable_if_t<H == ASPFWrapper::Heuristic::kEuclidean, double>
ASPFWrapper::Cell<T>::getH(Cell const& cell, Cell const& dest) {
    return std::sqrt(std::pow(cell.x - dest.x, 2) + std::pow(cell.y - dest.y, 2));
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
ASPFWrapper::ASPF<H, M>::ASPF(std::vector<std::vector<int>> const& grid) : mGrid(grid) {
    setBegin({ 0, 0 });
    setEnd({ 0, 0 });
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
bool ASPFWrapper::ASPF<H, M>::isValid(Cell<> const& cell) const {
    return static_cast<int>(mBegin.x) <= cell.x <= static_cast<int>(mEnd.x) && static_cast<int>(mBegin.y) <= cell.y <= static_cast<int>(mEnd.y);
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
bool ASPFWrapper::ASPF<H, M>::isUnblocked(Cell<> const& cell) const {
    return mGrid.at(cell.y).at(cell.x) != 0;
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
bool ASPFWrapper::ASPF<H, M>::isUnblocked(Cell<> const& cell, Cell<> const& successor) const {
    return mGrid.at(successor.y).at(successor.x) != 0;
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
std::stack<ASPFWrapper::Cell<>> ASPFWrapper::ASPF<H, M>::getPath(std::vector<std::vector<Cell<>::Data>> const& cellData, Cell<> const& dest) const {
    std::stack<Cell<>> path;
    auto curr = dest;

    while (!(cellData.at(curr.y - mBegin.y).at(curr.x - mBegin.x).parent == curr)) {
        path.push(curr);
        curr = cellData.at(curr.y - mBegin.y).at(curr.x - mBegin.x).parent;
    }

    path.push(curr);
    return path;
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
void ASPFWrapper::ASPF<H, M>::setBegin(Cell<std::size_t> const& begin) {
    mBegin = {
        std::max((std::size_t)(0), begin.x),
        std::max((std::size_t)(0), begin.y),
    };
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
void ASPFWrapper::ASPF<H, M>::setEnd(Cell<std::size_t> const& end) {
    mEnd = {
        std::min(mGrid.front().size() - 1, end.x),
        std::min(mGrid.size() - 1, end.y),
    };
}

template <ASPFWrapper::Heuristic H, ASPFWrapper::MovementType M>
ASPFWrapper::Result ASPFWrapper::ASPF<H, M>::search(Cell<> const& src, Cell<> const& dest) {
    if (mGrid.empty()) return Result(Status::kFailure);
    
    if (!isValid(src)) return Result(Status::kInvalidSrc);
    if (!isValid(dest)) return Result(Status::kInvalidDest);
    if (!isUnblocked(src)) return Result(Status::kBlockedSrc);
    if (!isUnblocked(dest)) return Result(Status::kBlockedDest);
    if (src == dest) return Result(Status::kCoincidents);

    // Note that index-based operations on two following lists require substracting `mBegin` to match `mGrid`
    // Initialize closed list
    std::vector<std::vector<bool>> closedList(mEnd.y - mBegin.y + 1, std::vector<bool>(mEnd.x - mBegin.x + 1, false));   // `false` means not visited (and vice versa)

    // Initialize cell data list
    std::vector<std::vector<Cell<>::Data>> cellDataList(mEnd.y - mBegin.y + 1, std::vector<Cell<>::Data>(mEnd.x - mBegin.x + 1, Cell<>::Data{}));
    
    // Initialize starting node parameters
    auto& srcData = cellDataList[src.y - mBegin.y][src.x - mBegin.x];
    srcData.f = 0;
    srcData.parent = src;

    // Initialize open list
    std::stack<Cell<>> openList;   // For operations at O(1) time complexity
    openList.push(src);   // Place the starting cell on the open list

    double g, h, f;

    while (!openList.empty()) {
        g = h = f = 0;

        auto parent = openList.top();
        openList.pop();   // Remove cell from open list
        closedList[parent.y - mBegin.y][parent.x - mBegin.x] = true;   // Add cell to closed list

        // Generate all successors
        for (const auto& direction : mDirections) {
            auto successor = parent + direction;
            if (!isValid(successor)) continue;

            // If successor is destination, search is considered successful
            if (successor == dest) {
                cellDataList[successor.y - mBegin.y][successor.x - mBegin.x].parent = parent;
                return Result(Status::kSuccess, getPath(cellDataList, dest));
            }

            // Ignore if successor is already on the closed list or is blocked
            if (!closedList.at(successor.y - mBegin.y).at(successor.x - mBegin.x) && isUnblocked(successor)) {
                g = cellDataList[parent.y - mBegin.y][parent.x - mBegin.x].g + std::sqrt(std::pow(direction.x, 2) + std::pow(direction.y, 2));
                h = Cell<>::getH<H>(successor, dest);
                f = g + h;

                auto& successorData = cellDataList[successor.y - mBegin.y][successor.x - mBegin.x];

                // Add successor to the open list if successor is not on the open list or provides a better path
                if (successorData.f == std::numeric_limits<double>::max() || successorData.f > f) {
                    openList.push(successor);

                    // Update successor data
                    successorData.f = f;
                    successorData.g = g;
                    successorData.h = h;
                    successorData.parent = parent;
                }
            }
        }
    }

    // Search is considered unsuccessful if the open list is emptied before destination cell is found
    return Result(Status::kFailure);
}


/* * * * * * */
int main(void) {
    std::vector<std::vector<int>> vec = {
        {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
        {{ 0, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 0, 4171, 4171, 4171, 0, 0, }},
        {{ 0, 4171, 4171, 4171, 0, 0, 4171, 4171, 4171, 0, 4171, 0, 0, 0, 0, }},
        {{ 0, 4171, 4171, 4171, 0, 0, 4171, 4171, 4171, 0, 4171, 0, 0, 0, 0, }},
        {{ 0, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 4171, 0, 4171, 4171, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, }},
        {{ 0, 4171, 4171, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, 4171, 4171, 4171, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 0, 0, 0, 4171, 4171, 4171, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 0, 0, 0, 4171, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 4171, 4171, 0, 4171, 4171, 4171, 4171, 4171, 0, 0, 0, }},
        {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }},
    };

    // input is not inverted
    ASPFWrapper::Cell<> src = { 12, 4 };
    ASPFWrapper::Cell<> dest = { 5, 15 };

    auto obj = ASPFWrapper::instantiate(vec);
    obj.setBegin({ 1, 1 });
    obj.setEnd({ vec.front().size() - 2, vec.size() - 2 });

    auto start = std::chrono::high_resolution_clock::now();

    auto res = obj.search(src, dest);

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    std::cout << "Execution time: " << duration.count() << " ms" << std::endl;
    std::cout << "Status: " << static_cast<int>(res.status) << std::endl;

    auto path = res.path;
    while (path.size() > 1) {
        std::cout << "(" << path.top().x << ", " << path.top().y << ") -> ";
        path.pop();
    }
    std::cout << path.top() << std::endl;

    return 0;
}