最短路径图计算

 采用矩阵原理,使用矩阵记录两点之间的距离,通过动态规范算法计算出两点之间的最短距离与最短路线,计算出所有点之间的最短距离, 时间复杂度为n的3次方

运行结果可以得出所有点中任何两点之间的最短距离 

 

直接上java代码

 

import java.util.LinkedList;

/**
 * 点数据结构
 */
public class Point {
    private Double value;//距离值
    private LinkedList<String> route;//最短路径

    public Point() {
    }

    public Point(Double value, String startPoint,String endPoint) {
        LinkedList<String> route = new LinkedList<>();
        route.addFirst(startPoint);
        route.addLast(endPoint);
        this.value = value;
        this.route = route;
    }

    public Point(Double value, LinkedList<String> routeFirst, LinkedList<String> routeLast) {
        LinkedList<String> strings = new LinkedList<>();
        strings.addAll(routeFirst);
        boolean status = false;//是否已经过滤出第一个重复节点
        for (String name : routeLast) {
            if (status) {
                strings.addLast(name);
            } else {
                status = true;
            }
        }

        this.value = value;
        this.route = strings;
    }


    public Double getValue() {
        return value;
    }

    public LinkedList<String> getRoute() {
        return route;
    }


    /**
     * 显示路线与最短距离
     * @return
     */
    @Override
    public String toString() {
        StringBuilder sbf = new StringBuilder("[");
        int index = 0;
        for (String name : route) {
            sbf.append(name);
            index++;
            if (index < route.size()) {
                sbf.append("->");
            } else {
                sbf.append("]");
            }
        }
        sbf.append("=").append(value);
        return sbf.toString();
    }
}

 

import java.util.*;

/**
 * 矩阵计算数据结构
 */
public class Matrix {
    private Set<String> areaSet;//地理位置列表
    private List<Point> points;//所有路线
    private Map<String, Map<String, Point>> minPoints;//最短路线图

    public Matrix() {
        areaSet = new HashSet<>();
        points = new ArrayList<>();
    }

    /**
     * 添加点信息
     *
     * @param startPoint
     * @param endPoint
     * @param distance
     */
    public void addRoute(String startPoint, String endPoint, Double distance) {
        areaSet.add(startPoint);
        areaSet.add(endPoint);
        Point point = new Point(distance, startPoint, endPoint);//创建点数据
        points.add(point);
    }

    /**
     * 初始化矩阵,并计算最短路径
     */
    public Map<String, Map<String, Point>> exec() {
        int max = this.areaSet.size();//矩阵的维度
        String[] areaArray = new String[max];
        this.areaSet.toArray(areaArray);
        Map<String, Integer> index = new HashMap<>();
        Map<Integer, String> indexSort = new HashMap<>();
        for (int i = 0, j = areaArray.length; i < j; i++) {
            index.put(areaArray[i], i);
            indexSort.put(i, areaArray[i]);
        }

        this.minPoints = new HashMap<>(max);

        //构造二维数组
        Point[][] points = new Point[max][max];
        for (Point point : this.points) {
            String x = point.getRoute().getFirst();
            String y = point.getRoute().getLast();
            points[index.get(x)][index.get(y)] = point;
        }

        for (int pointer = 0; pointer < max; pointer++) {
            for (int x = 0; x < max; x++) {
                if (x == pointer) continue;
                for (int y = 0; y < max; y++) {
                    if (x == y || y == pointer) continue;
                    if (points[x][pointer] == null) continue;
                    if (points[pointer][y] == null) continue;
                    if (points[x][y] == null) {//
                        Point onePoint = points[x][pointer];
                        Point twoPoint = points[pointer][y];
                        double value = onePoint.getValue() + twoPoint.getValue();
                        Point point = new Point(value, onePoint.getRoute(), twoPoint.getRoute());
                        points[x][y] = point;//构造路线
                    } else if (points[x][pointer].getValue() + points[pointer][y].getValue() < points[x][y].getValue()) {//更新
                        Point onePoint = points[x][pointer];
                        Point twoPoint = points[pointer][y];
                        double value = onePoint.getValue() + twoPoint.getValue();
                        Point point = new Point(value, onePoint.getRoute(), twoPoint.getRoute());
                        points[x][y] = point;//覆盖路线
                    } else {
                        //丢弃
                    }
                }
            }
        }
        //记录结果
        for (int x = 0; x < max; x++) {
            Map<String, Point> pointMap = new HashMap<>();
            for (int y = 0; y < max; y++) {
                if (x == y) {
                    Point point = new Point(0D, indexSort.get(y), indexSort.get(y));
                    pointMap.put(indexSort.get(y), point);
                } else {
                    pointMap.put(indexSort.get(y), points[x][y]);
                }
            }
            this.minPoints.put(indexSort.get(x), pointMap);
        }
        return this.minPoints;
    }


    /**
     * 测试入口
     *
     * @param args
     */
    public static void main(String[] args) {
        Matrix matrix = new Matrix();
        matrix.addRoute("a", "b", 2D);
        matrix.addRoute("a", "c", 1D);
        matrix.addRoute("b", "e", 3D);
        matrix.addRoute("c", "d", 3D);
        matrix.addRoute("c", "f", 4D);
        matrix.addRoute("d", "e", 6D);
        matrix.addRoute("d", "e", 6D);
        matrix.addRoute("f", "e", 2D);
        matrix.addRoute("c", "f", 4D);
        matrix.addRoute("e", "g", 5D);
        matrix.addRoute("f", "g", 16D);
        matrix.addRoute("g", "h", 4D);
        matrix.addRoute("g", "i", 7D);
        matrix.addRoute("h", "i", 5D);
        Map<String, Map<String, Point>> exec = matrix.exec();//得出最近路线与距离值
        System.out.println("所有路线图为: "+exec);
        System.out.println("指定路线图为: "+exec.get("a").get("i"));//a到i的最小距离路线图

    }

}

 

运行结果