精华内容
下载资源
问答
  • 2020-10-05 14:27:39
    两点之间最短距离

    这是我的一个测试,也是我学习html的/起点,他们说一个合格的程序员必须学会html,我比他们起步晚了一些,可是我认为还来的及,以后我就用html来记录我的学习记录了。

    问题的提出:
    在二维平面的n个点上,找出其中的一对点,使得在n个点组成的所有的点中,该点对的距离最小。


    一维:最接近点对问题

    方法一:(暴力法)
      直接使用双层遍历来计算每一对点的距离,另外新建一个变量记录两点之间距离最小的值,但是如此一来时间复杂度就变为O(n2),

    方法二:(分治法)
    分治法的思路:

    1. 划分成子规模点集S1和S2;
    2. 找到S1和S2的最小距离d;
    3. 合并S1和S2:利用d在S1的(m-d,m]和S2(m,m+d]中找到最大点和最小点,即p3和q3.选出最小距离,完成合并。

    ![示意图](https://img-blog.csdnimg.cn/20201004201704741.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNTExOTY0,size_16,color_FFFFFF,t_70#pic_center)

    m如何选择
    m=(max(s)+min(s))/2;


    代码:
    talking is cheap,show me the code;
    /*根据算法随便写的,返回的是两个点之间最小的距离,不是两个点的坐标,如果有问题,欢迎指正*/
    /*这里的坐标默认为正序的*/
    #include<iostream>
    #include<vector>
    using namespace std;
    int search(vector<int> target)
    {   
    int n=target.size();   
    if(n<2)   //如果分到一个元素就返回最大数值
    return INT_MAX;   
    int mid=n/2;   //中线
    vector<int> temp_left;  
     vector<int> temp_right;   temp_left.insert(temp_left.begin(),target.begin(),target.begin()+mid); //中线分割  temp_right.insert(temp_right.begin(),target.begin()+mid,target.end());  
     int p=search(temp_left);  
     int q=search(temp_right);  
     int d=temp_right.front()-temp_left.back();  
     cout<<temp_right.front()<<" "<<temp_left.back()<<endl;  
    return d>min(p,q)?min(p,q):d;}//返回两边和贯穿中间的最小的两点距离
     int main(){    
     int a[6]={-9,-6,0,4,7,9};    
     vector<int> target(a,a+6);    
    cout<<search(target);    
    return 0;
    }
    
    二维最接近点的问题:

    思路与一维的最接近点对相似。

    1. 选取中垂线l:x=m来作为分割直线。
    2. 递归的在S1和S2找出其最小距离d1和d2,并设d=min{d1,d2},S中最接近点对或是d,或者是某个{p,q}
    3. 合并起来

    // 随便写思路的如果有误,请指正(注意返回的是两点之间的距离,不是坐标)
    #include <iostream>
    #include <math.h>
    #include<algorithm>
    using namespace std;
    struct point
    {
    	int x, y;
    };
    double distance(struct point p1, struct point p2)
    {
    	return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y,2));
    }
    double search(struct point p[],int pl,int pr)
    {
    	if (pl == pr)
    		return INT_MAX;
    	int mid = (pl + pr) / 2;
    	double d_left = search(p, pl, mid);
    	double d_right = search(p, mid + 1, pr);
    	double temp_d = min(d_left, d_right);
    	while (abs(p[pl].y - p[mid].y) > temp_d&&pl < pr)//如果仅仅是单边距离就已经大于上一次比较返回的d就没必要在接下来的敌方继续比较了。
    		pl++;
    	while (abs(p[pr].y - p[mid].y) > temp_d&&pl < pr)
    		pr--;
    	for (int i = pl; i < pr; i++)
    	{
    		for (int j = i + 1; j < pr; j++)
    		{
    			if (temp_d < abs(p[i].x - p[j].x))//同理与上面的注释
    				break;
    			else
    				temp_d = min(temp_d, distance(p[i], p[j]));//找到最小的距离
    		}
    	}
    	return temp_d;
    }
    int main()
    {
    	struct point p[100];
    	int n;
    	cin >> n;
    	for (int i = 0; i < n; i++)
    	{
    		cin >> p[i].x;
    		cin >> p[i].y;
    	}
    	cout<<search(p, 0, n - 1);
    }
    
    
    更多相关内容
  • 您可以使用此代码根据视频中的手部动作绘制一条线。 它画一条线比较连续的帧和手的中心位置。 您的第一手位置是 (x,y),第二手位置是 (x1,y1),将此信息保存在缓冲区中您可以画一条线。
  • 广度优先遍历寻找两点之间最短路径的操作分为以下几步:  1).首先定义起始点和终点src和dst。接着定义一个数组distance[ ],用于存放各点到src的距离。初始化时各点到src的距离是INF(表示正无穷。这里可自行定义,...
  • 本文实例为大家分享了JS实现深度优先搜索求解两点最短路径的具体代码,供大家参考,具体内容如下 效果: 找出图里点到点最短路径,并打印轨迹 图片如下所示: 代码: const map = [ [0, 1, 1, 0, 1], [1, ...
  • 里面有详细的相关编程实现,Floyd算法
  • 给定一个乡镇网络图,求取个乡镇的最短路径,并输出路径,以及路径距离的大小。
  • 下载如有问题,可私信博主。下载前建议先查看博客内容,其地址为:https://blog.csdn.net/QQ98281642/article/details/120483897
  • 通过输入,能够实现找到最短路径。源代码能运行,简单易懂
  • 展开全部Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法,用于计算一个节点到其他所有节e68a8462616964757a686964616f31333361316131最短路径。主要特点是以起始为中心向外层层扩展,直到扩展到终点为止。...

    展开全部

    Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法,用于计算一个节点到其他所有节e68a8462616964757a686964616f31333361316131点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。

    Dijkstra一般的表述通常有两种方式,一种用永久和临时标号方式,一种是用OPEN, CLOSE表方式

    用OPEN,CLOSE表的方式,其采用的是贪心法的算法策略,大概过程如下:

    1.声明两个集合,open和close,open用于存储未遍历的节点,close用来存储已遍历的节点

    2.初始阶段,将初始节点放入close,其他所有节点放入open

    3.以初始节点为中心向外一层层遍历,获取离指定节点最近的子节点放入close并从新计算路径,直至close包含所有子节点

    代码实例如下:

    Node对象用于封装节点信息,包括名字和子节点

    [java] view plain copy

    public class Node {

    private String name;

    private Map child=new HashMap();

    public Node(String name){

    this.name=name;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public Map getChild() {

    return child;

    }

    public void setChild(Map child) {

    this.child = child;

    }

    }

    MapBuilder用于初始化数据源,返回图的起始节点

    [java] view plain copy

    public class MapBuilder {

    public Node build(Set open, Set close){

    Node nodeA=new Node("A");

    Node nodeB=new Node("B");

    Node nodeC=new Node("C");

    Node nodeD=new Node("D");

    Node nodeE=new Node("E");

    Node nodeF=new Node("F");

    Node nodeG=new Node("G");

    Node nodeH=new Node("H");

    nodeA.getChild().put(nodeB, 1);

    nodeA.getChild().put(nodeC, 1);

    nodeA.getChild().put(nodeD, 4);

    nodeA.getChild().put(nodeG, 5);

    nodeA.getChild().put(nodeF, 2);

    nodeB.getChild().put(nodeA, 1);

    nodeB.getChild().put(nodeF, 2);

    nodeB.getChild().put(nodeH, 4);

    nodeC.getChild().put(nodeA, 1);

    nodeC.getChild().put(nodeG, 3);

    nodeD.getChild().put(nodeA, 4);

    nodeD.getChild().put(nodeE, 1);

    nodeE.getChild().put(nodeD, 1);

    nodeE.getChild().put(nodeF, 1);

    nodeF.getChild().put(nodeE, 1);

    nodeF.getChild().put(nodeB, 2);

    nodeF.getChild().put(nodeA, 2);

    nodeG.getChild().put(nodeC, 3);

    nodeG.getChild().put(nodeA, 5);

    nodeG.getChild().put(nodeH, 1);

    nodeH.getChild().put(nodeB, 4);

    nodeH.getChild().put(nodeG, 1);

    open.add(nodeB);

    open.add(nodeC);

    open.add(nodeD);

    open.add(nodeE);

    open.add(nodeF);

    open.add(nodeG);

    open.add(nodeH);

    close.add(nodeA);

    return nodeA;

    }

    }

    图的结构如下图所示:

    Dijkstra对象用于计算起始节点到所有其他节点的最短路径

    [java] view plain copy

    public class Dijkstra {

    Set open=new HashSet();

    Set close=new HashSet();

    Map path=new HashMap();//封装路径距离

    Map pathInfo=new HashMap();//封装路径信息

    public Node init(){

    //初始路径,因没有A->E这条路径,所以path(E)设置为Integer.MAX_VALUE

    path.put("B", 1);

    pathInfo.put("B", "A->B");

    path.put("C", 1);

    pathInfo.put("C", "A->C");

    path.put("D", 4);

    pathInfo.put("D", "A->D");

    path.put("E", Integer.MAX_VALUE);

    pathInfo.put("E", "A");

    path.put("F", 2);

    pathInfo.put("F", "A->F");

    path.put("G", 5);

    pathInfo.put("G", "A->G");

    path.put("H", Integer.MAX_VALUE);

    pathInfo.put("H", "A");

    //将初始节点放入close,其他节点放入open

    Node start=new MapBuilder().build(open,close);

    return start;

    }

    public void computePath(Node start){

    Node nearest=getShortestPath(start);//取距离start节点最近的子节点,放入close

    if(nearest==null){

    return;

    }

    close.add(nearest);

    open.remove(nearest);

    Map childs=nearest.getChild();

    for(Node child:childs.keySet()){

    if(open.contains(child)){//如果子节点在open中

    Integer newCompute=path.get(nearest.getName())+childs.get(child);

    if(path.get(child.getName())>newCompute){//之前设置的距离大于新计算出来的距离

    path.put(child.getName(), newCompute);

    pathInfo.put(child.getName(), pathInfo.get(nearest.getName())+"->"+child.getName());

    }

    }

    }

    computePath(start);//重复执行自己,确保所有子节点被遍历

    computePath(nearest);//向外一层层递归,直至所有顶点被遍历

    }

    public void printPathInfo(){

    Set> pathInfos=pathInfo.entrySet();

    for(Map.Entry pathInfo:pathInfos){

    System.out.println(pathInfo.getKey()+":"+pathInfo.getValue());

    }

    }

    /**

    * 获取与node最近的子节点

    */

    private Node getShortestPath(Node node){

    Node res=null;

    int minDis=Integer.MAX_VALUE;

    Map childs=node.getChild();

    for(Node child:childs.keySet()){

    if(open.contains(child)){

    int distance=childs.get(child);

    if(distance

    minDis=distance;

    res=child;

    }

    }

    }

    return res;

    }

    }

    Main用于测试Dijkstra对象

    [java] view plain copy

    public class Main {

    public static void main(String[] args) {

    Dijkstra test=new Dijkstra();

    Node start=test.init();

    test.computePath(start);

    test.printPathInfo();

    }

    }

    本回答由提问者推荐

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • 交通道路网中任意两点之间最短路径的快速算法.docx
  • 用C++求图的最小生成树、单元点最短路径、两点之间最短路径
  • 要实现的是输入一张 图,起点,终点,输出起点和终点之间最短路径。 广度优先搜索 适用范围: 无权重的图,与深度优先搜索相比,深度优先搜索法占内存少但速度较慢,广度优先搜索算法占内存多但速度较快 复杂度:...
  • NULL 博文链接:https://128kj.iteye.com/blog/1689015
  • 计算给定起点和终点的条线段之间最短距离。 改编在 Dan Sunday 网站上找到的算法 ( http://softsurfer.com/Archive/algorithm_0106/algorithm_0106.htm#dist3D_Segment_to_Segment )。 用法:输入条线段的...
  • 泛函 泛函是函数的函数,定义域是函数集,值域是数集。也就是说,输入是函数,输出是实数。 参考:欧拉-拉格朗日方程(Euler -Lagrange equation)_qq_43217195...为什么两点之间直线段距离最短?谈谈泛函与变分法...

    泛函

    泛函是函数的函数,定义域是函数集,值域是数集。也就是说,输入是函数,输出是实数。

    参考:欧拉-拉格朗日方程(Euler -Lagrange equation)_qq_43217195的博客-CSDN博客_欧拉-拉格朗日方程

     

    简单泛函

     

     

    泛函的极值&欧拉-拉格朗日方程

     

     

    两点之间直线最短

    可以看出,初等数学为高等数学的推导提供了依据,高等数学反过来又能证明初等数学。

    参考视频:

    为什么两点之间直线段距离最短?谈谈泛函与变分法的应用和证明,教育,在线教育,好看视频

     

     

    展开全文
  • 主要为大家详细介绍了java计算图两点之间的所有路径,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 我有个数据框。一个包含properties locations,另一个包含railway stations locations。属性数据框样本(原始数据框由约700行组成):properties=pd.DataFrame({'propertyID':['13425','32535','43255','52521'],'...

    我有两个数据框。一个包含properties locations,另一个包含railway stations locations。

    属性数据框样本(原始数据框由约700行组成):

    properties=pd.DataFrame({'propertyID':['13425','32535','43255','52521'],

    'lat':[-37.79230,-37.86400,-37.85450,-37.71870],

    'lon':[145.10290,145.09720,145.02190,144.94330]})

    火车站数据框样本(原始数据框由约90行组成):

    stations=pd.DataFrame({'stationID':['11','33','21','34','22'],

    'lat':[-37.416861,-37.703293,-37.729261,-37.777764,-37.579206],

    'lon':[145.005372,144.572524,144.650631,144.772304,144.728165]})

    我有一个函数来计算两个位置之间的距离

    from math import radians, cos, sin, asin, sqrt

    def haversine(lon1, lat1, lon2, lat2):

    """

    Calculate the great circle distance between two points

    on the earth (specified in decimal degrees)

    """

    # convert decimal degrees to radians

    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

    # haversine formula

    dlon = lon2 - lon1

    dlat = lat2 - lat1

    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2

    c = 2 * asin(sqrt(a))

    r = 6378 # Radius of earth in kilometers

    return c * r

    我想找到每个属性与所有站点之间的距离。然后选择距离最短的车站。

    我试图构造一个for循环,但它没有返回最短距离(分钟)

    lst=[]

    for stopLat in stations['lat']:

    for stopLon in stations['lon']:

    for propLat in properties['lat']:

    for propLon in properties['lon']:

    lst.append(haversine(propLon,propLat,stopLon,stopLat))

    我的最终输出将如下所示。(每个属性都链接到最近的车站)。

    stationID propertyID

    11 52521

    33 13425

    21 32535

    34 43255

    关于如何解决此问题的任何建议都将有所帮助。谢谢

    解决方案

    这是一种解决方法,但我首先将两个数据框与一个附加的“键”合并。然后我使用apply计算距离:

    properties['key'] = 1

    stations['key'] = 1

    df = properties.merge(stations,on='key')

    del df['key']

    df['distance'] = df.apply(lambda x: haversine(x['lon_x'],x['lat_x'],x['lon_y'],x['lat_y']),axis=1)

    print(df)

    df = df.loc[df.groupby("propertyID")["distance"].idxmin()]

    df = df[['stationID','propertyID']]

    print(df)

    第一次打印:

    propertyID lat_x lon_x stationID lat_y lon_y distance

    0 13425 -37.7923 145.1029 11 -37.416861 145.005372 42.668639

    1 13425 -37.7923 145.1029 33 -37.703293 144.572524 47.723406

    2 13425 -37.7923 145.1029 21 -37.729261 144.650631 40.415507

    3 13425 -37.7923 145.1029 34 -37.777764 144.772304 29.129338

    4 13425 -37.7923 145.1029 22 -37.579206 144.728165 40.650436

    5 32535 -37.8640 145.0972 11 -37.416861 145.005372 50.428078

    6 32535 -37.8640 145.0972 33 -37.703293 144.572524 49.504807

    7 32535 -37.8640 145.0972 21 -37.729261 144.650631 42.047056

    8 32535 -37.8640 145.0972 34 -37.777764 144.772304 30.138684

    9 32535 -37.8640 145.0972 22 -37.579206 144.728165 45.397047

    10 43255 -37.8545 145.0219 11 -37.416861 145.005372 48.738487

    11 43255 -37.8545 145.0219 33 -37.703293 144.572524 42.971083

    12 43255 -37.8545 145.0219 21 -37.729261 144.650631 35.510616

    13 43255 -37.8545 145.0219 34 -37.777764 144.772304 23.552690

    14 43255 -37.8545 145.0219 22 -37.579206 144.728165 40.101407

    15 52521 -37.7187 144.9433 11 -37.416861 145.005372 34.043280

    16 52521 -37.7187 144.9433 33 -37.703293 144.572524 32.696875

    17 52521 -37.7187 144.9433 21 -37.729261 144.650631 25.795774

    18 52521 -37.7187 144.9433 34 -37.777764 144.772304 16.424364

    19 52521 -37.7187 144.9433 22 -37.579206 144.728165 24.508280

    第二次印刷:

    stationID propertyID

    3 34 13425

    8 34 32535

    13 34 43255

    18 34 52521

    但是根据该输出站34总是最接近的。那是对的吗?

    编辑:进一步的解释:

    我曾经试图找到一种方法来将两个数据帧“合并”在一起,而这两个数据帧没有通常用于合并的通用唯一标识符。

    我还想将一个数据帧的每一行与另一数据帧(在您的情况下,每个工作站具有每个属性)配对,以便能够比较那些条目。在我的研究中,我发现了使用虚拟密钥的巧妙解决方法。

    在使用的这种解决方法中,我们看到每一行的键都是1,因此每一行将与其他数据帧中的每一行完全匹配我们想要的。

    使用apply函数,您可以将任何函数逐行应用于数据框。

    展开全文
  • 两点间所有最短路径寻找 This is an implementation of the dijkstra algorithm, wich finds the minimal cost path between two nodes.
  • 两点之间最短路径-Dijkstra算法

    千次阅读 2019-09-30 07:50:55
    主要特点是以起始为中心向外层层扩展,直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法,在很多专业课程中都作为基本内容有详细的介绍,如数据结构,图论,运筹学等等。注意该算法要求图中不存在负权...
  • 顶点表示城市,边表示各个城市之间的交通关系,所带权值为个城市间的耗费。 这个交通咨询系统可以回答旅客提出的各种问题,例如:如何选择一条路径使得 从A城到B城途中中转次数最少;如何选择一条路径使得从A城到B...
  • 最短路径(图中两点最短路径)

    千次阅读 2020-12-24 11:13:34
    importjava.util.Scanner;//最短路径求解public classDistMin {static classGraphMatrix{static final int MaxNum=20;char[] Vertex=new char[MaxNum]; //保存顶点信息(序号或字母)int GType; //图的类型(0:...
  • 含有各种障碍物的,水平面两点最短的距离算法。就相当于计算你从一个地方走到另一个地方,最短的路径。 注意:不是图论!不是节点!不是Dijkstra!不是Floyd!
  • 求解两点最短路径的算法

    千次阅读 2020-07-19 23:42:40
    最短路径算法1.Dijkstra算法2.Bellman-Ford算法3.SPFA算法4.Floyd算法几种最短路径算法的对比Dijkstra算法、Bellman-Ford算法和SPFA算法的对比Dijkstra算法和Floyd算法的...多源最短路算法:求任意两点之间最短路径.
  • MAX——定义两点之间若无路径赋予的最大值 变量: DIST[N]——存储已经搜寻到的最短路径 Is[N]——存储节点是否被遍历的状态 Path[N]——图之间的路径矩阵 Road[N]——存储最短路径时该节点的上一节点 算法...
  • 我们经常在考试当中看到求线段之和最小的问题,首先来看下这几个数学模型:模型1:两点之间线段最短要在l找点P,使得PA+PB最短,这模型最简单,两点之间线段最短。模型2:将军饮马问题在l上找一点P,使得PA+PB最短,...
  • 刷到一道算法笔试题,求在有障碍的“棋盘”上任意两点最短路径。 题目描述 如图为一个10*10的网格图,黑点处为障碍物,给定任意两点——start和end,求最短路径,走一格距离为1。 Code # 算法思想:通过BFS找end,...
  • 椭球面上的两点球面距离的解析计算是难以实现的,现提供一种切割方法,可采取贪心策略取得最短路径!
  • 两点顶点之间最短路径问题 基于matlab的dijkstra算法 前言 看了很多篇介绍dijkstra算法的博客,没发现对于程序来说很多的地方都有问题。 一、函数代码 代码如下(示例): function [ mydistance,mypath] = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,327
精华内容 46,130
关键字:

两点之间最短的是

友情链接: cpphtm.zip