使用佛洛伊德算法計算點對的最短路徑

源碼

方法

// 生成距離矩陣和路線矩陣
function getAllPointsDistanceMatrix() {
    // 生成初始矩陣
    distanceMatrix = initialMatrix();
    //  // 生成父點矩陣
    parentMatrix = initialPMatrix(distanceMatrix);
    //  // 生成距離矩陣
    floyd_warshall(distanceMatrix, parentMatrix);
}

function initialMatrix() {
    var result = new Array(inflectionPoint.length);
    for(let i = 0; i < result.length; i++) {
        result[i] = new Array(inflectionPoint.length);
        for(let j = 0; j < result[i].length; j++) {
            result[i][j] = MAX_NUM;
        }
    }
    for(let i = 0; i < inflectionPoint.length; i++) {
        var p1 = inflectionPoint[i];
        var count = inflectionPoint[i].nearPoint.length;
        for(let j = 0; j < count; j++) {
            var p2 = inflectionPoint[inflectionPoint[i].nearPoint[j] - 1];
            var temp = Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
            temp = temp.toFixed(2);
            result[i][inflectionPoint[i].nearPoint[j] - 1] = temp;
        }
        result[i][i] = 0;
    }
    return result;
}

function initialPMatrix(matrix) {
    var result = new Array(matrix.length);
    for(let i = 0; i < result.length; ++i) {
        result[i] = new Array(matrix.length);
        for(let j = 0; j < result[i].length; ++j) {
            if(i == j) {
                result[i][j] = 0;
            } else {
                if(matrix[i][j] != MAX_NUM) {
                    result[i][j] = i;
                } else {
                    result[i][j] = -1;
                }
            }
        }
    }
    return result;
}

function floyd_warshall(matrix, parent) {
    for(let k = 0; k < matrix.length; ++k) {
        var newMatrix = create2DArray(matrix);
        var newParent = create2DArray(matrix);
        for(let i = 0; i < matrix.length; ++i) {
            for(let j = 0; j < matrix.length; ++j) {
                if(matrix[i][k] * 1 + matrix[k][j] * 1 < matrix[i][j]) {
                    newMatrix[i][j] = matrix[i][k] * 1 + matrix[k][j] * 1;
                    newParent[i][j] = parent[k][j];
                } else {
                    newMatrix[i][j] = matrix[i][j];
                    newParent[i][j] = parent[i][j];
                }
            }
        }
        matrix = newMatrix;
        for(let m = 0; m < parent.length; ++m) {
            for(let n = 0; n < parent.length; ++n) { 
                parent[m][n] = newParent[m][n];
            }
        }
    }
    distanceMatrix = change2DArray(matrix);
    parentMatrix = parent;
}

// 將2D數組中的值修改爲小數點後兩位的數
function change2DArray(matrix) {
    for(let i = 0; i < matrix.length; i++) {
        for(let j = 0; j < matrix[i].length; j++) {
            matrix[i][j] *= 1;
            matrix[i][j] = matrix[i][j].toFixed(2);
            matrix[i][j] *= 1;
        }
    }
    return matrix;
}

// js中創建2D數組
function create2DArray(matrix) {
    var result = new Array(matrix.length);
    for(let i = 0; i < result.length; i++) {
        result[i] = new Array(matrix.length);
    }
    return result;
}

模擬數據

inflectionPoint = [{
    "id": 1,
    "x": "36",
    "y": "22.8",
    "nearPoint": ["2", "5"]
}, {
    "id": 2,
    "x": "36",
    "y": "176.8",
    "nearPoint": ["1", "3", "6"]
}, {
    "id": 3,
    "x": "36",
    "y": "328.8",
    "nearPoint": ["2", "7", "4"]
}, {
    "id": 4,
    "x": "36",
    "y": "474.8",
    "nearPoint": ["3", "10"]
}, {
    "id": 5,
    "x": "999",
    "y": "22.8",
    "nearPoint": ["1"]
}, {
    "id": 6,
    "x": "612",
    "y": "176.8",
    "nearPoint": ["2"]
}, {
    "id": 7,
    "x": "652",
    "y": "328.8",
    "nearPoint": ["3", "8"]
}, {
    "id": 8,
    "x": "831",
    "y": "281.80",
    "nearPoint": ["7", "9"]
}, {
    "id": 9,
    "x": "999",
    "y": "280.80",
    "nearPoint": ["8"]
}, {
    "id": 10,
    "x": "999",
    "y": "477.80",
    "nearPoint": ["4"]
}];