精华内容
下载资源
问答
  • 最短距离算法

    2014-06-27 10:38:56
    在两点间找到最短距离算法。 类似GPS寻找最短路径,在两点间寻找可行的最短路径。
  • Jave Web实现多条线路最短距离算法,其中有道理拥堵以及路口红绿灯的延迟。
  • 点到线段的最短距离算法

    千次阅读 2019-07-09 11:25:35
    原文地址点到线段的最短距离算法http://blog.sina.com.cn/s/blog_5d5c80840101bnhw.html 点到线段最短距离的运算与点到直线的最短距离的运算二者之间存在一定的差别,即求点到线段最短距离时需要考虑参考点在沿线段...

    原文地址点到线段的最短距离算法  http://blog.sina.com.cn/s/blog_5d5c80840101bnhw.html

    点到线段最短距离的运算与点到直线的最短距离的运算二者之间存在一定的差别,即求点到线段最短距离时需要考虑参考点在沿线段方向的投影点是否在线段上,若在线段上才可采用点到直线距离公式,如图1所示。

                      点到线段的最短距离算法

    图1 (a)最短距离为点P与其在线段AB上投影C之间的线段PC

                                            (b)最短距离为点P与端点B(或A)所构成的线段PB(或PA)

     

    具体算法主要有以下三种:

    1、方法——经典算法

    该算法直接用高中时所学习到的解析几何知识对点到线段的距离进行求解。其基本思想是先判断点在线段端点、点在线上等等的特殊情况,逐步的由特殊到一般,当忽略点在线段上的特殊情况时,判断点到线段方向的垂线是否落在线段上的方法是通过比较横纵坐标的方式来判断,最后把不同的判断情况用不同的几何方式来进行处理计算得出结果。

    由上面叙述的基本思路可以知道这种算法虽然很容易理解和接受,但从算法的实用性的角度分析还是有很大的缺点的,首先是算法复杂,计算量巨大,大量的比较判断、距离计算、角度计算等等,实际应用中往往是需要求由大量线段组成的折线到某点的最短距离,如此用这样的算法计算量是不能想象的。其次经典算法中使用的一些简化运算的函数不利于语言的重新包装,如果想换编程语言的话,就比较麻烦了。

    2、方法二——面积算法

    该方法主要是先判断投影点是否在线段上,投影点在线段延长线上时,最短距离长度为点到端点的线段长度;当投影点在线段上时,先使用海伦公式计算三角形面积,再计算出三角形的高,即为最短距离。

    运用面积算法求解点到线段最短距离思路很清晰,也很容易理解。从效率方面考虑,比如需要多次计算平方、根号,这对于大量数据进行运算是负担很重的。求面积就必须把三条边长全部求出,并且用到的海伦公式也需要进行开方运算,计算过程显得繁琐。

    3、方法三——矢量算法

    矢量算法过程清晰,如果具有一定的空间几何基础,则是解决此类问题时应优先考虑的方法。当需要计算的数据量很大时,这种方式优势明显。

    由于矢量具有方向性,故一些方向的判断直接根据其正负号就可以得知,使得其中的一些问题得以很简单的解决。

         用此方法考虑,我们只需要找到向量 点到线段的最短距离算法点到线段的最短距离算法方向上的投影,具体如下:

                 点到线段的最短距离算法

    上面的 点到线段的最短距离算法点到线段的最短距离算法方向上的单位向量,其意义是给所求向量确定方向。点到线段的最短距离算法是的两个向量的内积,且 点到线段的最短距离算法  ,其中θ为向量AP与AB之间的夹角。点到线段的最短距离算法是向量长度。

     

    那么点到线段的最短距离算法即为上图中线段AC的长度值,不带有方向性。此数值与上述表征方向的 点到线段的最短距离算法整体构成有大小、有方向的新向量点到线段的最短距离算法,即为 点到线段的最短距离算法点到线段的最短距离算法方向上的投影向量,C为投影点。

    根据得到的点到线段的最短距离算法,由向量的方向性可知:如果情况是上图(a)所示,那么0<r<1;如果是如图(b)所示的情况,那么r ≥1;如果是如图(c)所示的情况,那么得到r ≤0;

    特殊情况如点在线段上、点在端点、点在线段延长线上等等的情况全部适用于此公式,只是作为特殊情况出现,无需另作讨论。这也是矢量算法思想的优势所在。

    故根据r值的不同,最短距离?可以计算为:   

                                          点到线段的最短距离算法

    使用C#实现上述算法:

    public static double PointToSegDist(double x, double y, double x1, double y1, double x2, double y2)

    {

    double cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);

    if (cross <= 0) return Math.Sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));

     

    double d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);

    if (cross >= d2) return Math.Sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));

     

    double r = cross / d2;

    double px = x1 + (x2 - x1) * r;

    double py = y1 + (y2 - y1) * r;

    return Math.Sqrt((x - px) * (x - px) + (py - y1) * (py - y1));

    }

     

    除了代码简单、计算量少的优点外,上述代码不依赖其它函数和自定义的数据结构,便于直接使用或者转换为其他编程语言(诸如C++、java等)使用而无需做较大的改动。

    展开全文
  • java-floyd最短距离算法

    2018-12-10 20:51:02
    java-floyd最短距离算法 public static void main (String[] args){ MatrixDG matrixDG = new MatrixDG(); System.out.println("初始化邻接矩阵"); matrixDG.printMatrix(); System.out.println(&...

    java-floyd最短距离算法

    public static void main (String[] args){
        MatrixDG matrixDG = new MatrixDG();
        System.out.println("初始化邻接矩阵");
        matrixDG.printMatrix();
        System.out.println("运行 floyd 算法");
        matrixDG.floyd();
        System.out.println("最终值");
        matrixDG.printMatrix();
    }
    public static class MatrixDG{
        private char[] mVexs=new char[]{'a','b','c','d'};//顶点集合
        private int[][] mMatrix;//邻接矩阵
        private int mnfinity=99;//表示无穷大
        //创建图,根据已有的数据
        public MatrixDG(){
            //初始化顶点边
            initEdge();
            //初始化边,及距离
            initEdgeSpace();
        }
    
        /**
            * floyd 佛洛伊德
            */
        private void floyd(){
            //输入顶点数和边数
            int n = mVexs.length;//vertex,顶点数
            int [][] e = mMatrix;
                //Floyd-Warshall算法核心语句(设k为中转节点,计算节点i到节点j的距离值)
                for(int k=0;k<n;k++) {
                    for (int i = 0; i < n; i++) {
                        for (int j = 0; j < n; j++) {
                            if (e[i][j] > e[i][k] + e[k][j]) {
                                e[i][j] = e[i][k] + e[k][j];
                            }
                        }
                    }
                }
        }
        private void initEdge(){
            //输入顶点数和边数
            int vlen = mVexs.length;//vertex,顶点数
            int elen = mVexs.length;//edge,边数
            //初始化边
            mMatrix = new int[vlen][elen];
            //初始化,使相同顶点距离为0,到其他订单距离为正无穷
            for(int i=0;i<vlen;i++){
                for(int j=0;j<elen;j++){
                    if(i==j){
                        mMatrix[i][j]=0;
                    }else{
                        mMatrix[i][j]=mnfinity;
                    }
                }
            }
        }
        //初始化,边及距离
        private void initEdgeSpace(){
            edgeSpace('a','b',2);
            edgeSpace('a','c',6);
            edgeSpace('a','d',4);
    
            edgeSpace('b','c',3);
    
            edgeSpace('c','a',7);
            edgeSpace('c','d',1);
    
            edgeSpace('d','a',5);
            edgeSpace('d','c',12);
        }
    
        /**
            *
            * @param e1 边
            * @param e2 边
            * @param space 距离
            */
        private void edgeSpace(char e1,char e2,int space){
            int i= getPosition(e1);
            int j= getPosition(e2);
            mMatrix[i][j]=space;
        }
        //获取字符在数组中的位置
        private int getPosition(char ch){
            for(int i=0;i<mVexs.length;i++){
                if(mVexs[i] == ch)
                    return i;
            }
            return -1;
        }
    
        //打印邻接矩阵
        private void printMatrix(){
            //顶点
            for(int i=0;i<mVexs.length;i++){
                if(i==0) {
                    System.out.print("\t");
                }
                System.out.print(mVexs[i] + "\t");
            }
            System.out.println();
            //顶点的邻接表
            for(int i=0;i<mVexs.length;i++){
                System.out.print(mVexs[i] + "\t");
                for(int j=0;j<mVexs.length;j++) {
                    System.out.print(mMatrix[i][j] + "\t");
                }
                System.out.println();
            }
        }
    }

     

    展开全文
  • 最短距离数学建模 基于路网分层策略的多源点最短距离算法 希望对大家有用
  • 利 用 数理规划软件 LINGO 求解多点之间距离问 题 的 研 究 方 法, 计 算 出 该 方 案 距 离 的 配 送 路 径, 该研究结果也在一定程度上验证了该算法研究理论及研究方法的可行性。
  • JAVA实现最短距离算法之迪杰斯特拉算法

    万次阅读 热门讨论 2016-03-14 22:13:42
    最短路径问题是图论研究中的一个经典的算法问题,旨在寻找图中两个节点之间的最短路径,常用的算法有Dijkstra算法、SPFA算法\Bellman-Ford算法、Floyd算法\Floyd-Warshall算法、Johnson算法等,这篇博客将重点介绍...

    转载请注明出处:http://blog.csdn.net/xiaojimanman/article/details/50889670

    http://www.llwjy.com/blogdetail/9f4acca84ef514bdc8c2abb695cdf56f.html

    个人博客站已经上线了,网址 www.llwjy.com ~欢迎各位吐槽~

    -------------------------------------------------------------------------------------------------

          最短路径问题是图论研究中的一个经典的算法问题,旨在寻找图中两个节点之间的最短路径,最常用的算法有Dijkstra算法、SPFA算法\Bellman-Ford算法、Floyd算法\Floyd-Warshall算法、Johnson算法等,这篇博客将重点介绍Dijkstra算法。


    迪杰斯特拉算法

          迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的,因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法,解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。具体的计算规则我们可以通过下图进行查看。

    img

          通过这幅图(如果图片无法正确显示,请通过百度百科查看)我们可以简单的理解迪杰斯特拉算法算法的基础思路,下面我们就通过JAVA来实现这个算法。


    算法实现

          在具体的实现之前,我们先有一个基础的约定,就是途中的每一个节点我们都用正整数进行编码,相邻两点之间的距离是正整数,图中两个直接相邻两点的距离我们保存到map中,也就是求最短距离我们需要实现这样的一个方法:

    public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength);

          第一个参数是起始节点的编号,第二个参数是终点节点的编号,第三个参数是图中直接相邻两个节点的距离组成的map。关于第三个参数,会在后面做详细的介绍。这里我们定义一个接口,用于计算两点之间的最短路径,具体如下:

     /**  
     *@Description:     
     */ 
    package com.lulei.distance;  
    
    import java.util.HashMap;
    
    import com.lulei.distance.bean.MinStep;
      
    public interface Distance {
    	public static final MinStep UNREACHABLE = new MinStep(false, -1);
    	/**
    	 * @param start
    	 * @param end
    	 * @param stepLength
    	 * @return
    	 * @Author:lulei  
    	 * @Description: 起点到终点的最短路径
    	 */
    	public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength);
    }
    

    一、方法返回值介绍

          上面方法的返回值是我们自定义的一个数据类型,下面我们通过代码来看其具体的数据结构:

    /**  
     *@Description:     
     */
    package com.lulei.distance.bean;
    
    import java.util.List;
    
    public class MinStep {
    	private boolean reachable;//是否可达
    	private int minStep;//最短步长
    	private List<Integer> step;//最短路径
    
    	public MinStep() {
    	}
    	
    	public MinStep(boolean reachable, int minStep) {
    		this.reachable = reachable;
    		this.minStep = minStep;
    	}
    
    	public boolean isReachable() {
    		return reachable;
    	}
    	public void setReachable(boolean reachable) {
    		this.reachable = reachable;
    	}
    	public int getMinStep() {
    		return minStep;
    	}
    	public void setMinStep(int minStep) {
    		this.minStep = minStep;
    	}
    	public List<Integer> getStep() {
    		return step;
    	}
    	public void setStep(List<Integer> step) {
    		this.step = step;
    	}
    }
    

          其中最短路径的那个List数组保存了从起点到终点最短路径所经历的节点。


    二、每一个节点的最优前一节点

          在迪杰斯特拉算法中我们需要保存从起点开始到每一个节点最短步长,这也是图中需要比较得出的步长,同时我们还需要存储该步长下的前一个节点是哪个,这样我们就可以通过终点一个一个往前推到起点,这样就出来了完整的最优路径。

    /**  
     *@Description:     
     */
    package com.lulei.distance.bean;
    
    public class PreNode {
    	private int preNodeNum;// 最优 前一个节点
    	private int nodeStep;// 最小步长
    
    	public PreNode(int preNodeNum, int nodeStep) {
    		this.preNodeNum = preNodeNum;
    		this.nodeStep = nodeStep;
    	}
    
    	public int getPreNodeNum() {
    		return preNodeNum;
    	}
    	public void setPreNodeNum(int preNodeNum) {
    		this.preNodeNum = preNodeNum;
    	}
    	public int getNodeStep() {
    		return nodeStep;
    	}
    	public void setNodeStep(int nodeStep) {
    		this.nodeStep = nodeStep;
    	}
    }
    

    三、迪杰斯特拉算法计算过程中需要关注的变量

          从介绍迪杰斯特拉算法的图中,我们知道在计算的过程中我们需要保存起点到各个节点的最短距离、已经计算过的节点、下次需要计算节点队列和图中相邻两个节点的距离。我们通过代码来看下具体的定义:

    //key1节点编号,key2节点编号,value为key1到key2的步长
    private HashMap<Integer, HashMap<Integer, Integer>> stepLength;
    //非独立节点个数
    private int nodeNum;
    //移除节点
    private HashSet<Integer> outNode;
    //起点到各点的步长,key为目的节点,value为到目的节点的步长
    private HashMap<Integer, PreNode> nodeStep;
    //下一次计算的节点
    private LinkedList<Integer> nextNode;
    //起点、终点
    private int startNode;
    private int endNode;

          我们这里看下stepLength这个属性,它保存了图中相邻两个节点之间的距离,比如key1=1;key2=3;value=9;这代表的意义就是从节点1到节点3的距离是9。通过这样的存储,我们就需要把图中每两个相邻的点保存到这个类型的map中。


    四、属性初始化

          在开始计算之前,我们需要对这些属性进行初始化,具体如下:

    private void initProperty(int start, int end) {
    	outNode = new HashSet<Integer>();
    	nodeStep = new HashMap<Integer, PreNode>();
    	nextNode = new LinkedList<Integer>();
    	nextNode.add(start);
    	startNode = start;
    	endNode = end;
    }

           这一步我们需要把起点添加到下一次需要计算的节点队列中。


    五、迪杰斯特拉算法

          这一步也就是迪杰斯特拉算法的核心部分,在计算的过程中,我们需要进行如下步骤:

    1)判断是否达到终止条件,如果达到终止条件,结束本次算法,如果没有达到,执行下一步;(终止条件:下一次需要计算的节点队列没有数据或已经计算过的节点数等于节点总数)

    2)获取下一次计算的节点A;

    3)从起点到各节点之间的最短距离map中获取到达A点的最小距离L;

    4)获取A节点的可达节点B,计算从起点先到A再到B是否优于已有的其他方式到B,如果优于,则更新B节点,否则不更新;

    5)判断B是否是已经移除的节点,如果不是移除的节点,把B添加到下一次需要计算的节点队列中,否则不做操作;

    6)判断A节点是否还有除B以外的其他节点,如果有,执行第4)步,否则执行下一步;

    7)将A节点从下一次需要计算的节点中移除添加到已经计算过的节点中;

    8)执行第一步。

          我们来看下具体的代码实现:

    private void step() {
    	if (nextNode == null || nextNode.size() < 1) {
    		return;
    	}
    	if (outNode.size() == nodeNum) {
    		return;
    	}
    	//获取下一个计算节点
    	int start = nextNode.removeFirst();
    	//到达该节点的最小距离
    	int step = 0;
    	if (nodeStep.containsKey(start)) {
    		step = nodeStep.get(start).getNodeStep();
    	}
    	//获取该节点可达节点
    	HashMap<Integer,Integer> nextStep = stepLength.get(start);
    	Iterator<Entry<Integer, Integer>> iter = nextStep.entrySet().iterator();
    	while (iter.hasNext()) {
    		Entry<Integer, Integer> entry = iter.next();
    		Integer key = entry.getKey();
    		//如果是起点到起点,不计算之间的步长
    		if (key == startNode) {
    			continue;
    		}
    		//起点到可达节点的距离
    		Integer value = entry.getValue() + step;
    		if ((!nextNode.contains(key)) && (!outNode.contains(key))) {
    			nextNode.add(key);
    		}
    		if (nodeStep.containsKey(key)) {
    			if (value < nodeStep.get(key).getNodeStep()) {
    				nodeStep.put(key, new PreNode(start, value));
    			}
    		} else {
    			nodeStep.put(key, new PreNode(start, value));
    		}
    	}
    	//将该节点移除
    	outNode.add(start);
    	//计算下一个节点
    	step();
    }

    六、组装最短路径返回结果

          通过前面的计算,已经计算出了起点到各个节点的最短路径,下面就需要组装起点到终点的最短路径,在计算最短距离下的路径方式,我们需要从终点依次往前推,即到达终点最短距离下的前一个节点是A,到达A节点最短距离下的前一节点是B,直到找到起点终止。

    private MinStep changeToMinStep() {
    	MinStep minStep = new MinStep();
    	minStep.setMinStep(nodeStep.get(endNode).getNodeStep());
    	minStep.setReachable(true);
    	LinkedList<Integer> step = new LinkedList<Integer>();
    	minStep.setStep(step);
    	int nodeNum = endNode;
    	step.addFirst(nodeNum);
    	while (nodeStep.containsKey(nodeNum)) {
    		int node = nodeStep.get(nodeNum).getPreNodeNum();
    		step.addFirst(node);
    		nodeNum = node;
    	}
    	return minStep;
    }

    七、接口定义方法实现

    public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength) {
    	this.stepLength = stepLength;
    	this.nodeNum = this.stepLength != null ? this.stepLength.size() : 0;
    	//起点、终点不在目标节点内,返回不可达
    	if (this.stepLength == null || (!this.stepLength.containsKey(start)) || (!this.stepLength.containsKey(end))) {
    		return UNREACHABLE;
    	}
    	initProperty(start, end);
    	step();
    	if (nodeStep.containsKey(end)) {
    		return changeToMinStep();
    	}
    	return UNREACHABLE;
    }

    八、迪杰斯特拉算法完整代码

    /**  
     *@Description:     
     */
    package com.lulei.distance.dijkstra;
    
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.Map.Entry;
    
    import com.lulei.distance.Distance;
    import com.lulei.distance.bean.MinStep;
    import com.lulei.distance.bean.PreNode;
    
    public class DistanceDijkstraImpl implements Distance{
    	//key1节点编号,key2节点编号,value为key1到key2的步长
    	private HashMap<Integer, HashMap<Integer, Integer>> stepLength;
    	//非独立节点个数
    	private int nodeNum;
    	//移除节点
    	private HashSet<Integer> outNode;
    	//起点到各点的步长,key为目的节点,value为到目的节点的步长
    	private HashMap<Integer, PreNode> nodeStep;
    	//下一次计算的节点
    	private LinkedList<Integer> nextNode;
    	//起点、终点
    	private int startNode;
    	private int endNode;
    	
    	/**
    	 * @param start
    	 * @param end
    	 * @param stepLength
    	 * @return
    	 * @Author:lulei  
    	 * @Description: start 到 end 的最短距离
    	 */
    	public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength) {
    		this.stepLength = stepLength;
    		this.nodeNum = this.stepLength != null ? this.stepLength.size() : 0;
    		//起点、终点不在目标节点内,返回不可达
    		if (this.stepLength == null || (!this.stepLength.containsKey(start)) || (!this.stepLength.containsKey(end))) {
    			return UNREACHABLE;
    		}
    		initProperty(start, end);
    		step();
    		if (nodeStep.containsKey(end)) {
    			return changeToMinStep();
    		}
    		return UNREACHABLE;
    	}
    	
    	/**
    	 * 返回最短距离以及路径
    	 */
    	private MinStep changeToMinStep() {
    		MinStep minStep = new MinStep();
    		minStep.setMinStep(nodeStep.get(endNode).getNodeStep());
    		minStep.setReachable(true);
    		LinkedList<Integer> step = new LinkedList<Integer>();
    		minStep.setStep(step);
    		int nodeNum = endNode;
    		step.addFirst(nodeNum);
    		while (nodeStep.containsKey(nodeNum)) {
    			int node = nodeStep.get(nodeNum).getPreNodeNum();
    			step.addFirst(node);
    			nodeNum = node;
    		}
    		return minStep;
    	}
    	
    	/**
    	 * @param start
    	 * @Author:lulei  
    	 * @Description: 初始化属性
    	 */
    	private void initProperty(int start, int end) {
    		outNode = new HashSet<Integer>();
    		nodeStep = new HashMap<Integer, PreNode>();
    		nextNode = new LinkedList<Integer>();
    		nextNode.add(start);
    		startNode = start;
    		endNode = end;
    	}
    	
    	/**
    	 * @param end
    	 * @Author:lulei  
    	 * @Description:
    	 */
    	private void step() {
    		if (nextNode == null || nextNode.size() < 1) {
    			return;
    		}
    		if (outNode.size() == nodeNum) {
    			return;
    		}
    		//获取下一个计算节点
    		int start = nextNode.removeFirst();
    		//到达该节点的最小距离
    		int step = 0;
    		if (nodeStep.containsKey(start)) {
    			step = nodeStep.get(start).getNodeStep();
    		}
    		//获取该节点可达节点
    		HashMap<Integer,Integer> nextStep = stepLength.get(start);
    		Iterator<Entry<Integer, Integer>> iter = nextStep.entrySet().iterator();
    		while (iter.hasNext()) {
    			Entry<Integer, Integer> entry = iter.next();
    			Integer key = entry.getKey();
    			//如果是起点到起点,不计算之间的步长
    			if (key == startNode) {
    				continue;
    			}
    			//起点到可达节点的距离
    			Integer value = entry.getValue() + step;
    			if ((!nextNode.contains(key)) && (!outNode.contains(key))) {
    				nextNode.add(key);
    			}
    			if (nodeStep.containsKey(key)) {
    				if (value < nodeStep.get(key).getNodeStep()) {
    					nodeStep.put(key, new PreNode(start, value));
    				}
    			} else {
    				nodeStep.put(key, new PreNode(start, value));
    			}
    		}
    		//将该节点移除
    		outNode.add(start);
    		//计算下一个节点
    		step();
    	}
    }
    


    代码测试

         对于上述代码的测试,我们还是使用我们事例图形中的例子,计算从节点1到节点5的最短距离。

     /**  
     *@Description:     
     */ 
    package com.lulei.distance.test;  
    
    import java.util.HashMap;
    
    import com.lulei.distance.Distance;
    import com.lulei.distance.bean.MinStep;
    import com.lulei.distance.dijkstra.DistanceDijkstraImpl;
    import com.lulei.util.JsonUtil;
      
    public class DistanceTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub  
    		HashMap<Integer, HashMap<Integer,Integer>> stepLength = new HashMap<Integer, HashMap<Integer,Integer>>();
    		HashMap<Integer,Integer> step1 = new HashMap<Integer, Integer>();
    		stepLength.put(1, step1);
    		step1.put(6, 14);
    		step1.put(3, 9);
    		step1.put(2, 7);
    		
    		HashMap<Integer,Integer> step2 = new HashMap<Integer, Integer>();
    		stepLength.put(2, step2);
    		step2.put(1, 7);
    		step2.put(3, 10);
    		step2.put(4, 15);
    		
    		HashMap<Integer,Integer> step3 = new HashMap<Integer, Integer>();
    		stepLength.put(3, step3);
    		step3.put(1, 9);
    		step3.put(2, 10);
    		step3.put(4, 11);
    		step3.put(6, 2);
    		
    		HashMap<Integer,Integer> step4 = new HashMap<Integer, Integer>();
    		stepLength.put(4, step4);
    		step4.put(2, 15);
    		step4.put(5, 5);
    		step4.put(3, 11);
    		
    		HashMap<Integer,Integer> step5 = new HashMap<Integer, Integer>();
    		stepLength.put(5, step5);
    		step5.put(6, 9);
    		step5.put(4, 5);
    		
    		HashMap<Integer,Integer> step6 = new HashMap<Integer, Integer>();
    		stepLength.put(6, step6);
    		step6.put(1, 14);
    		step6.put(5, 9);
    		step6.put(3, 2);
    		
    		Distance distance = new DistanceDijkstraImpl();
    		MinStep step = distance.getMinStep(1, 5, stepLength);
    		System.out.println(JsonUtil.parseJson(step));
    	}
    
    }
    

          这里组装相邻两个节点之间的距离用了大量的代码,我们看下输出结果:

    {"reachable":true,"minStep":20,"step":[1,3,6,5]}


    最后的思考

          最短路径算法在现实生活中其实有很多的用处,比如迷宫解法、路径规划、路由寻址等等,这些问题看似很复杂,其实只需要做对应的转化后还是可以用最基础的算法解决的。

          最近发现很多网站或者个人转载博客,个人拒绝他人转载,但是最起码你给出我文章的出处,不会让我认为自己辛辛苦苦写的博客被别人剽窃。说到转载问题,又需要提到现在的互联网环境,有时候自己去找一篇博客,发现很难找到源作者或者最初的链接,一方面,自己写博客不想在博文中添加自己的博客地址介绍影响博文的质量,另一方面博主有的时候对博文中的错误进行了修改,他人无法快速获取该信息。个人呼吁互联网环境从自我做起,从最简单的源地址做起:http://blog.csdn.net/xiaojimanman/article/details/50889670。


    -------------------------------------------------------------------------------------------------
    小福利
    -------------------------------------------------------------------------------------------------
          个人在极客学院上《Lucene案例开发》课程已经上线了,欢迎大家吐槽~

    第一课:Lucene概述

    第二课:Lucene 常用功能介绍

    第三课:网络爬虫

    第四课:数据库连接池

    第五课:小说网站的采集

    第六课:小说网站数据库操作

    第七课:小说网站分布式爬虫的实现

    第八课:Lucene实时搜索


    展开全文
  • 点到线段最短距离的运算与点到直线的最短距离的运算二者之间存在一定的差别,即求点到线段最短距离时需要考虑参考点在沿线段方向的投影点是否在线段上,若在线段上才可采用点到直线距离公式
  • 求n个点之间的最短距离 部分程序如下: typedef struct{ //定义一个结构体 用于表示一个点的xy坐标 int x; int y; }point; point source[MAX],T[MAX]; //******************************************** float ...
  • A predictive model developed to identify medium-voltage electrical distribution grid infrastructure using publicly available data sources.
  • 素数最短距离算法

    2013-05-31 09:18:50
    long prevDist = 0, // 当前素数与前一个素数的距离 nextDist = 0; // 当前素数与后一个素数的距离 int i = 0, j = 0; CreatePrimeTable(); while (scanf("%d", &number) != EOF) { prevDist = 0; ...
    #include <cstdio>
    #include <cstring>
    #include <cmath>
    using namespace std;
    
    #define MAX_LENGTH 50000001
    
    bool prime[MAX_LENGTH];
    
    void CreatePrimeTable()
    {
    	int i, j;
    
    	memset(prime, true, sizeof(prime)); // 初始化全为1
    	prime[0] = prime[1] = false;  // 0和1不是素数
    
    	for (i = 2; i * i < MAX_LENGTH; i++)
    	{
    		if (prime[i]) // 如果是素数
    		{
    			// 如果i是素数,那么能整除i的肯定不是素数
    			for (j = i * 2; j < MAX_LENGTH; j += i)
    			{
    				prime[j] = false;
    			}
    		}
    	}
    }
    
    int main()
    { 
    	int number = 0;
    	long prevDist = 0, // 当前素数与前一个素数的距离
    		 nextDist = 0; // 当前素数与后一个素数的距离
    	int i = 0, j = 0;
    
    	CreatePrimeTable();
    
    	while (scanf("%d", &number) != EOF)
    	{
    		prevDist = 0;
    		nextDist = 0;
    		if (prime[number]) // 如果是素数
    		{
    			printf("%d ", number);
    
    			for (i = number - 1; i >= 2; i--)
    			{
    				if (prime[i] != 0)
    				{
    					prevDist = number - i;
    					break;
    				}
    			}
    
    			for (i = number + 1; i < MAX_LENGTH; i++)
    			{
    				if (prime[i] != 0)
    				{
    					nextDist = i - number;
    					break;
    				}
    			}
    
    			printf("%d\n", prevDist < nextDist ? prevDist : nextDist);
    		}
    		else
    		{
    			printf("%d不是素数\n", number);
    		}
    	}
    	return 0;
    }

    展开全文
  • https://zhuanlan.zhihu.com/p/38917770
  • 点到线段最短距离的运算与点到直线的最短距离的... 点到线段的最短距离算法图1 (a)最短距离为点P与其在线段AB上投影C之间的线段PC (b)最短距离为点P与端点B(或A)所构成的线段PB(或PA)具体算法主要有以下三种
  • 地图上点到范围的最短距离算法

    万次阅读 2016-08-09 16:34:50
    目前计算最短距离算法是: 1、多边形上的2点是否是相邻:则需要知道下标的绝对值是否=1 2、多边形与范围外的一点形成的夹角师傅是锐角 ==>三个坐标点 只有既是相邻点又是锐角的情况下才可以取高为最短...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 928
精华内容 371
关键字:

最短距离算法