• dijkstra算法


    根据实际情况,overload一下构造方法即可。

    package com.util;
    
    import java.util.ArrayList;
    import java.util.Hashtable;
    import java.util.List;
    
    /**
     * dijkstra算法,求最短路径
     */
    public class DijkstraUtil {
    
        private RoutePlanner planner = new RoutePlanner();
        private Graph g = new Graph();
    
        public DijkstraUtil() {
            List<Node> list = new ArrayList<Node>();
            Node aNode = new Node("A");
            list.add(aNode);
            // A -> B
            Edge aEdge1 = new Edge();
            aEdge1.setStartNodeID(aNode.getId());
            aEdge1.setEndNodeID("B");
            aEdge1.setWeight(10);
            aNode.getEdgeList().add(aEdge1);
            // A -> C
            Edge aEdge2 = new Edge();
            aEdge2.setStartNodeID(aNode.getId());
            aEdge2.setEndNodeID("C");
            aEdge2.setWeight(20);
            aNode.getEdgeList().add(aEdge2);
            // A -> E
            Edge aEdge3 = new Edge();
            aEdge3.setStartNodeID(aNode.getId());
            aEdge3.setEndNodeID("E");
            aEdge3.setWeight(30);
            aNode.getEdgeList().add(aEdge3);
    
            // ***************** B Node *******************
            Node bNode = new Node("B");
            list.add(bNode);
            // B -> C
            Edge bEdge1 = new Edge();
            bEdge1.setStartNodeID(bNode.getId());
            bEdge1.setEndNodeID("C");
            bEdge1.setWeight(5);
            bNode.getEdgeList().add(bEdge1);
            // B -> E
            Edge bEdge2 = new Edge();
            bEdge2.setStartNodeID(bNode.getId());
            bEdge2.setEndNodeID("E");
            bEdge2.setWeight(10);
            bNode.getEdgeList().add(bEdge2);
    
            // ***************** C Node *******************
            Node cNode = new Node("C");
            list.add(cNode);
            // C -> D
            Edge cEdge1 = new Edge();
            cEdge1.setStartNodeID(cNode.getId());
            cEdge1.setEndNodeID("D");
            cEdge1.setWeight(30);
            cNode.getEdgeList().add(cEdge1);
    
            // ***************** D Node *******************
            Node dNode = new Node("D");
            list.add(dNode);
    
            // ***************** E Node *******************
            Node eNode = new Node("E");
            list.add(eNode);
            // E -> D
            Edge eEdge1 = new Edge();
            eEdge1.setStartNodeID(eNode.getId());
            eEdge1.setEndNodeID("D");
            eEdge1.setWeight(20);
            eNode.getEdgeList().add(eEdge1);
    
            g.setM_nodeList(list);
        }
    
        public RoutePlanResult plan(String originID, String targetID) throws Exception {
            return planner.plan(g.getM_nodeList(), originID, targetID);
        }
    
        public PlanCourse plan(String originID) throws Exception {
            return planner.plan(g.getM_nodeList(), originID);
        }
    
        public class Edge {
            private String startNodeID;
            private String endNodeID;
            private double weight;
    
            public String getStartNodeID() {
                return startNodeID;
            }
    
            public void setStartNodeID(String startNodeID) {
                this.startNodeID = startNodeID;
            }
    
            public String getEndNodeID() {
                return endNodeID;
            }
    
            public void setEndNodeID(String endNodeID) {
                this.endNodeID = endNodeID;
            }
    
            public double getWeight() {
                return weight;
            }
    
            public void setWeight(double weight) {
                this.weight = weight;
            }
    
        }
    
        public class Node {
            private String id;
            private List<Edge> edgeList;
    
            public Node(String id) {
                this.id = id;
                this.edgeList = new ArrayList<Edge>();
            }
    
            public String getId() {
                return id;
            }
    
            public void setId(String id) {
                this.id = id;
            }
    
            public List<Edge> getEdgeList() {
                return edgeList;
            }
    
            public void setEdgeList(List<Edge> edgeList) {
                this.edgeList = edgeList;
            }
    
        }
    
        public class Graph {
            private List<Node> m_nodeList = null;
    
            public List<Node> getM_nodeList() {
                return m_nodeList;
            }
    
            public void setM_nodeList(List<Node> m_nodeList) {
                this.m_nodeList = m_nodeList;
            }
        }
    
        class PassedPath {
            private String curNodeID;
            private boolean beProcessed;
            private double weight;
            private List<String> passedIDList;
    
            public PassedPath(String ID) {
                this.curNodeID = ID;
                this.weight = Double.MAX_VALUE;
                this.passedIDList = new ArrayList<String>();
                this.beProcessed = false;
            }
    
            public String getCurNodeID() {
                return curNodeID;
            }
    
            public void setCurNodeID(String curNodeID) {
                this.curNodeID = curNodeID;
            }
    
            public boolean isBeProcessed() {
                return beProcessed;
            }
    
            public void setBeProcessed(boolean beProcessed) {
                this.beProcessed = beProcessed;
            }
    
            public double getWeight() {
                return weight;
            }
    
            public void setWeight(double weight) {
                this.weight = weight;
            }
    
            public List<String> getPassedIDList() {
                return passedIDList;
            }
    
            public void setPassedIDList(List<String> passedIDList) {
                this.passedIDList = passedIDList;
            }
    
        }
    
        class PlanCourse {
            private Hashtable<String, PassedPath> htPassedPath;
    
            public PlanCourse(List<Node> nodeList, String originID) throws Exception {
                this.htPassedPath = new Hashtable<String, PassedPath>();
                Node originNode = null;
                for (Node node : nodeList) {
                    if (originID.equals(node.getId())) {
                        originNode = node;
                    } else {
                        PassedPath pPath = new PassedPath(node.getId());
                        this.htPassedPath.put(node.getId(), pPath);
                    }
                }
                if (originNode == null) {
                    throw new Exception("The origin node is not exist !");
                }
                this.InitializeWeight(originNode);
            }
    
            private void InitializeWeight(Node originNode) {
                if ((originNode.getEdgeList() == null) || (originNode.getEdgeList().size() == 0)) {
                    return;
                }
    
                for (Edge edge : originNode.getEdgeList()) {
                    PassedPath pPath = getPassedPath(edge.getEndNodeID());
                    if (pPath == null) {
                        continue;
                    }
    
                    pPath.getPassedIDList().add(originNode.getId());
                    pPath.setWeight(edge.getWeight());
                }
            }
    
            public PassedPath getPassedPath(String nodeID) {
                return this.htPassedPath.get(nodeID);
            }
        }
    
        class RoutePlanner {
            public RoutePlanResult plan(List<Node> nodeList, String originID, String destID) throws Exception {
                PlanCourse planCourse = plan(nodeList, originID);
                return this.getResult(planCourse, destID);
            }
    
            public PlanCourse plan(List<Node> nodeList, String originID) throws Exception {
                PlanCourse planCourse = new PlanCourse(nodeList, originID);
                Node curNode = this.getMinWeightRudeNode(planCourse, nodeList, originID);
                while (curNode != null) {
                    PassedPath curPath = planCourse.getPassedPath(curNode.getId());
                    for (Edge edge : curNode.getEdgeList()) {
                        PassedPath targetPath = planCourse.getPassedPath(edge.getEndNodeID());
                        double tempWeight = curPath.getWeight() + edge.getWeight();
    
                        if (tempWeight < targetPath.getWeight()) {
                            targetPath.setWeight(tempWeight);
                            targetPath.getPassedIDList().clear();
    
                            for (int i = 0; i < curPath.getPassedIDList().size(); i++) {
                                targetPath.getPassedIDList().add(curPath.getPassedIDList().get(i));
                            }
    
                            targetPath.getPassedIDList().add(curNode.getId());
                        }
                    }
                    planCourse.getPassedPath(curNode.getId()).setBeProcessed(true);
                    curNode = this.getMinWeightRudeNode(planCourse, nodeList, originID);
                }
                return planCourse;
            }
    
            private RoutePlanResult getResult(PlanCourse planCourse, String destID) {
                PassedPath pPath = planCourse.getPassedPath(destID);
    
                if (pPath.getWeight() == Integer.MAX_VALUE) {
                    RoutePlanResult result1 = new RoutePlanResult(null, Integer.MAX_VALUE);
                    return result1;
                }
    
                String[] passedNodeIDs = new String[pPath.getPassedIDList().size()];
                for (int i = 0; i < passedNodeIDs.length; i++) {
                    passedNodeIDs[i] = pPath.getPassedIDList().get(i);
                }
                RoutePlanResult result = new RoutePlanResult(passedNodeIDs, pPath.getWeight());
    
                return result;
            }
    
            private Node getMinWeightRudeNode(PlanCourse planCourse, List<Node> nodeList, String originID) {
                double weight = Double.MAX_VALUE;
                Node destNode = null;
                for (int i = 0; i < nodeList.size(); i++) {
                    Node node = (Node) nodeList.get(i);
                    if (originID.equals(node.getId())) {
                        continue;
                    }
    
                    PassedPath pPath = planCourse.getPassedPath(node.getId());
                    if (pPath.isBeProcessed()) {
                        continue;
                    }
    
                    if (pPath.getWeight() < weight) {
                        weight = pPath.getWeight();
                        destNode = node;
                    }
                }
                return destNode;
            }
        }
    
        public class RoutePlanResult {
            public RoutePlanResult(String[] passedNodes, double value) {
                m_resultNodes = passedNodes;
                m_value = value;
            }
    
            private String[] m_resultNodes;
    
            private double m_value;
    
            public String[] getM_resultNodes() {
                return m_resultNodes;
            }
    
            public void setM_resultNodes(String[] m_resultNodes) {
                this.m_resultNodes = m_resultNodes;
            }
    
            public double getM_value() {
                return m_value;
            }
    
            public void setM_value(double m_value) {
                this.m_value = m_value;
            }
    
            public String getStringResult() {
                String result;
                StringBuffer sb = new StringBuffer("[");
                for (int i = 0; i < m_resultNodes.length; i++)
                    sb.append(m_resultNodes[i] + ",");
                if (sb.length() > 1)
                    result = sb.substring(0, sb.length() - 1) + "]";
                else
                    result = sb.append("]").toString();
                return result;
            }
        }
    }

    调用方法如下:

    import com.util.DijkstraUtil;
    import com.util.DijkstraUtil.RoutePlanResult;
    
    /** 最短路径 **/
    public class Test {
    
        public static void main(String[] args) throws Exception {
            DijkstraUtil du = new DijkstraUtil();
            RoutePlanResult result = du.plan("A", "D");
            System.out.println(result.getM_value());
            System.out.println(result.getStringResult());
    
        }
    }
  • 相关阅读:
    结对-结对编项目贪吃蛇-最终程序
    团队-团队编程项目中国象棋-模块测试过程
    团队-团队编程项目中国象棋-模块开发过程
    团队-团队编程项目中国象棋-项目进度
    结对-结对编项目贪吃蛇-测试过程
    结对-贪吃蛇-开发过程
    课后作业-阅读任务-阅读提问-2
    20171005-构建之法:现代软件工程-阅读笔记
    结队-结队编程项目贪吃蛇-项目进度
    课后作业-阅读任务-任务阅读-2
  • 原文地址:https://www.cnblogs.com/sm21312/p/6374267.html
Copyright © 2020-2023  润新知