arayts/dist/src/algorithm/astar.js

让 TypeScript 开发如丝般顺滑。ArayTS 提供了一套高效、优雅的算法工具集，包含常用的数据结构与算法实现，帮助开发者轻松构建可靠的应用程序。

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AStar = void 0;
/**
 * A*寻路算法
 */
var AStar = /** @class */ (function () {
    function AStar() {
    }
    AStar.manhattan = function (x1, y1, x2, y2) {
        return Math.abs(x1 - x2) + Math.abs(y1 - y2);
    };
    AStar.findPath = function (grid, start, end) {
        var rows = grid.length;
        var cols = grid[0].length;
        var openSet = new Set();
        var closedSet = new Set();
        var cameFrom = new Map();
        var gScore = new Map();
        var fScore = new Map();
        var startKey = "".concat(start[0], ",").concat(start[1]);
        openSet.add(startKey);
        gScore.set(startKey, 0);
        fScore.set(startKey, this.manhattan(start[0], start[1], end[0], end[1]));
        var _loop_1 = function () {
            var current = '';
            var minF = Infinity;
            // 使用Array.from()将Set转换为数组以进行迭代
            Array.from(openSet).forEach(function (pos) {
                var f = fScore.get(pos) || Infinity;
                if (f < minF) {
                    minF = f;
                    current = pos;
                }
            });
            if (current === "".concat(end[0], ",").concat(end[1])) {
                var path = [];
                var curr = current;
                while (curr) {
                    var _a = curr.split(',').map(Number), x_1 = _a[0], y_1 = _a[1];
                    path.unshift([x_1, y_1]);
                    curr = cameFrom.get(curr) || '';
                }
                return { value: path };
            }
            openSet.delete(current);
            closedSet.add(current);
            var _b = current.split(',').map(Number), x = _b[0], y = _b[1];
            var neighbors = [
                [x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]
            ];
            for (var _i = 0, neighbors_1 = neighbors; _i < neighbors_1.length; _i++) {
                var _c = neighbors_1[_i], nx = _c[0], ny = _c[1];
                if (nx < 0 || nx >= rows || ny < 0 || ny >= cols ||
                    grid[nx][ny] || closedSet.has("".concat(nx, ",").concat(ny))) {
                    continue;
                }
                var tentativeG = (gScore.get(current) || 0) + 1;
                var neighborKey = "".concat(nx, ",").concat(ny);
                if (!openSet.has(neighborKey)) {
                    openSet.add(neighborKey);
                }
                else if (tentativeG >= (gScore.get(neighborKey) || Infinity)) {
                    continue;
                }
                cameFrom.set(neighborKey, current);
                gScore.set(neighborKey, tentativeG);
                fScore.set(neighborKey, tentativeG + this_1.manhattan(nx, ny, end[0], end[1]));
            }
        };
        var this_1 = this;
        while (openSet.size > 0) {
            var state_1 = _loop_1();
            if (typeof state_1 === "object")
                return state_1.value;
        }
        return [];
    };
    return AStar;
}());
exports.AStar = AStar;