精华内容
下载资源
问答
  • C++ 两点之间最短距离

    2020-10-05 14:27:39
    两点之间最短距离 这是我的一个测试,也是我学习html的起点,他们说一个合格的程序员必须学会html,我比他们起步晚了一些,可是我认为还来的及,以后我就用html来记录我的学习记录了。 问题的提出...
        两点之间最短距离  
    
     

    这是我的一个测试,也是我学习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);
    }
    
    
    展开全文
  • 我对弗洛伊德算法的理解(图中任意两点之间最短距离) 基本过程: for k = 1:n for i = 1:n for j = 1:n if route(i,k)+route(k,j) (i,j) route(i,j) = route(i,k) + route(k,j);

    我对弗洛伊德算法的理解(求图中任意两点之间最短距离)

    基本过程:
    for k = 1:n
        for i = 1:n
             for j = 1:n
                 if route(i,k)+route(k,j) < route(i,j)
                      route(i,j) = route(i,k) + route(k,j);
                 end
             end
        end
    end

    预备知识:
    最优路径的子路径也是最优路径,即连接两个结点之间的最短路径上任意两个节点之间的路径即为这两点间的最短路径。

    基本过程文字描述:
    初始:任意两个结点直接连接最短距离
    第一步:任意两个结点可借用第一个结点的至多一次间接连接最短距离
    第二步:任意两个结点可借用第一第二两个结点的至多二次间接连接最短距离
    ……

    关键问题:
    这个操作方法能保证最后得到任意两个节点之间的最短路径吗?又是怎么得到的?
    分析:假设a1 a2 a3 ... an 是连接a1到an的最短路径上的所有点,我们用示例说明,弗洛伊德算法是怎样最终求出a1到an的最短路径是a1 a2 ... an的连接(为了简单起见,我们用n=6做示范)。
    假若第一个出现的点是a3是最外层循环中第一次出现的点,那么经过里面两层循环可以求出a2到a4的最短路径是a2 a3 a4;假若后面出现的点是a5,那么有a4到a6的最短路径是a4 a5 a6;若再出现的点事a4,那么会求出a2到a6的最短路径是a2 a3 a4 a5 a6;最后只要外层循环出现a2,那么里层循环会求出a1-a2 + a2-a6是a1-a6的最短路径,这样就可以求出a1-a6的最短路径为a1 a2 a3 a4 a5 a6了。

     

    展开全文
  • using System; using System.Collections.Generic; using System.Linq; using System.Text;...//迪杰斯特拉算法 计算两点最短距离 namespace Dijkstra { class Program { /// /// 邻接矩阵 ///
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    //迪杰斯特拉算法 计算两点最短距离
    namespace Dijkstra
    {
        class Program
        {
            /// <summary>
            /// 邻接矩阵
            /// </summary>
            private static int?[,] rectMatrix;
    
            /// <summary>
            /// 点 的距离
            /// </summary>
            private static int[] distanse;
    
            /// <summary>
            /// 访问过的点
            /// </summary>
            private static int[] visitPoints;
    
            /// <summary>
            /// 路径
            /// </summary>
            private static string[] path;
    
            /// <summary>
            /// 坐标点数量
            /// </summary>
            private static int pointNum = 10;
    
            /// <summary>
            /// 起始点
            /// </summary>
            private static int startPoint;
    
            /// <summary>
            /// 终点
            /// </summary>
            private static int endPoint;
    
            static void Main(string[] args)
            {
                visitPoints = new int[pointNum];
                distanse = new int[pointNum];
                path = new string[pointNum];
                initRectMatrix();
                Console.WriteLine("请输入起始点坐标:");
                string strPoint = Console.ReadLine();
                Console.WriteLine("请输入终点坐标:");
                string ePoint = Console.ReadLine();
                if (Int32.TryParse(strPoint, out startPoint) && Int32.TryParse(ePoint, out endPoint))
                {
                    computePath(startPoint);
                    Console.WriteLine("最佳路径:" + path[endPoint]);
                    Console.WriteLine("最短距离:" + distanse[endPoint]);
                    Console.ReadLine();
                }
            }
    
            /// <summary>
            /// 计算路径
            /// </summary>
            /// <param name="index"></param>
            private static void computePath(int index)
            {
                //设置为1,标记当前点已经遍历
                visitPoints[index] = 1;
                if (isCurIndex(index))
                {
                    int curDistanse;
                    for (int i = 0; i < pointNum; i++)
                    {
                        if (i != index && rectMatrix[index, i] != null)
                        {
                            curDistanse = distanse[index] == 0 ? 0 : (int)distanse[index];
                            if (curDistanse + rectMatrix[index, i] < distanse[i] || distanse[i] == 0)
                            {
                                distanse[i] = curDistanse + (int)rectMatrix[index, i];
                                if (index == startPoint)
                                {
                                    path[i] = startPoint.ToString() + "=>" + i.ToString();
                                }
                                else
                                {
                                    path[i] = path[index].ToString() + "=>" + i.ToString();
                                    computePath(i);
                                }
                            }
                        }
                    }
                }
    
                int visit = getVisitIndex();
                if (visit != -1)
                {
                    computePath(visit);
                }
            }
    
            /// <summary>
            /// 得到未访问节点的最小索引
            /// </summary>
            /// <returns></returns>
            private static int getVisitIndex()
            {
                int index=-1;
                for(int i=0;i<pointNum;i++)
                {
                    if (visitPoints[i] != 1)
                    {
                        index = i;
                        break;
                    }
                }
                return index;
            }
    
            /// <summary>
            /// 判断当前节点是否与上一节点相连
            /// </summary>
            /// <param name="index"></param>
            /// <returns></returns>
            private static bool isCurIndex(int index)
            {
                if (index == startPoint ||(path[index] != null 
                    && path[index].IndexOf(index.ToString()) != -1))
                {
                    return true;
                }
                return false;
            }
            /// <summary>
            /// 初始化邻接矩阵
            /// </summary>
            private static void initRectMatrix()
            {
                rectMatrix = new int?[pointNum, pointNum];
    
                rectMatrix[0, 1] = 15;
                rectMatrix[0, 2] = 20;
                rectMatrix[1, 3] = 30;
                rectMatrix[1, 2] = 30;
                rectMatrix[1, 4] = 20;
                rectMatrix[1, 5] = 30;
                rectMatrix[2, 3] = 30;
                rectMatrix[2, 4] = 20;
                rectMatrix[2, 6] = 30;
                rectMatrix[3, 5] = 30;
                rectMatrix[4, 7] = 20;
                rectMatrix[4, 8] = 30;
                rectMatrix[5, 6] = 30;
                rectMatrix[6, 9] = 20;
                rectMatrix[7, 8] = 30;
                rectMatrix[7, 9] = 30;
                rectMatrix[8, 4] = 20;
                rectMatrix[8, 0] = 30;
                rectMatrix[8, 3] = 30;
                rectMatrix[9, 2] = 20;
                rectMatrix[9, 7] = 30;
                rectMatrix[9, 6] = 30;
    
                for (int i = 0; i < pointNum; i++)
                {
                    rectMatrix[i, i] = 0;
                }
            }
        }
    }
    

    展开全文
  • 无向图两点之间最短距离怎么?有什么算法可以实现啊。头疼死了,好几天了,指点,给个具体点的代码。
  • 在计算两点之间最短路径时,如果两点之间存在其他的点,那么可以将最短路径的情况分为两类,经过某个点和不经过这个点。那么在有向图中ab两点的最短路径时,遍历剩下的点,比较在a到b的路径中是经过Vi距离短...

    Floyd算法求有向图两点间最短距离

    问题描述

    用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵(顶点之间的最短距离矩阵),按实验报告模板编写算法。
    在这里插入图片描述

    算法描述

    在计算两点之间的最短路径时,如果两点之间存在其他的点,那么可以将最短路径的情况分为两类,经过某个点和不经过这个点。那么在求有向图中ab两点的最短路径时,遍历剩下的点,比较在a到b的路径中是经过Vi距离短还是不经过Vi距离短(Vi是除了ab的点)

    核心代码

    int floyd()
    {
    	int i,j,k;
    	for(k=1;k<=n;k++)
    	{
    		for(i=1;i<=n;i++)
    		{
    			for(j=1;j<=n;j++)
    			{
    				if(a[i][k]+a[k][j]==min(a[i][j],a[i][k]+a[k][j]))
    				{
    					a[i][j]=a[i][k]+a[k][j];
    					p[i][j]=k;
    				}	
    			}
    		}
    	}
     } 
     //数组a[I][J]为IJ之间的距离,无直接相连则距离无穷大
     //数组p[I][J]为IJ之间的最短路径上,从I出发要经过的下一个点
    

    git源码

    https://github.com/1651928813/Pepsi_juice.git
    作业二文件夹

    展开全文
  • 城市里两点之间最短距离
  • 集合内多个点之间最短距离

    千次阅读 2012-12-20 16:08:09
    返回其中距离最小的距离 */ public static double getMinDistance(List<MyPoint> lst) { if(lst==null || lst.size()) return Double.MAX_VALUE; double r = Double.MAX_VALUE; MyPoint p0 = lst....
  • 任意节点之间最短距离

    千次阅读 2016-03-21 13:09:13
    找到这个节点的最近公共父节点,然后重根遍历 计算到父节点的距离 距离-2*父节点的距离 就是所的了 TarJan package com.graph; import java.util.Scanner; import java.util.Vector; /* * * * ...
  • 经纬度一点与经纬度两点之间测最短距离思路代码 思路 如果有数学基础,看到这个图就应该懂了。 首先,拿到两个经纬度计算x,y轴各自的差值: 36.679430 - 36.633990 = xN 116.952210 - 117.054860 = yN 拿到x,y轴...
  • 给定一个乡镇网络图,个乡镇的最短路径,并输出路径,以及路径距离的大小。
  • /* *有向网中的任意两点的最短路径 *弗洛伊德算法的核心是 运用一个path二维数组 和一个A...*运用三层循环 (算法的核心) 计算任意两点之间最短路径长度 将经过的节点的下标存储在path数组中去 *递增的思想 *创...
  • 主要特点是以起始为中心向外层层扩展,直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法,在很多专业课程中都作为基本内容有详细的介绍,如数据结构,图论,运筹学等等。注意该算法要求图中不存在负权...
  • 如果中转为K,距离矩阵为D 当D(i,K)+D(K,j)(i,j) 则D(i,j)=D(i,K)+D(K,j) 否则不变 程序的参数说明 P为最短路,顶点以经过次序排序 u为最短距离 W为距离矩阵 k1为起始 k2为终止 MATLAB实现 ...
  • Dijkstra算法是源点到其它顶点的最短路径。怎样任意个顶点之间最短路径?
  • #include #include #include #include ...#include //Floyd算法,图中点之间最短距离 #define inf 1000000 //hdu2544 using namespace std; int n, map[110][110]; int main() { int i, t
  • dijkstra算法求两点之间最短路径

    千次阅读 2016-11-08 15:23:35
    // 标记当前该顶点的最短路径是否已经出,1表示已出 // 初始化,第一个顶点已经出 shortPath[start] = 0; visited[start] = 1; for (int count = 1; count ; count++) { // 要加入n-1个顶点 ...
  • 分治法求两点最短距离->HDU5721

    千次阅读 2016-08-27 00:25:44
    分治法最近对的距离:主要思想就是先把n个按x坐标排序,然后左边n/2个和右边n/2个的最近距离,最后合并。合并过程: 首先,假设是n个,编号为1到n。我们要分治,则找一个中间的编号m,先出1到m的...
  • 实验三:C#实现图的任意两点最短路径及距离 实验目的 定义Graph类、Node类,从文件中读取图结构;给定两个顶点,给出两个顶点的最短路径(如果没有连通,请给出)。把图进行可视化展示(一个适当大小的图),...
  • 这次我们反着来,给你一个有向图中每一对顶点之间的最短路的长度,请你计算出原图中最少可能包含多少条边。 输入格式 输入的第一行是一个整数T(T 每组输入的第一行是一个整数N(1 接下来N行,每行输入N个整数,...
  • null
  • 任意两点间的最短距离,使用动态规划算法实现
  • 给定地球上两点的经纬度,计算...现在想出A和B两点之间沿着地球表面最短的弧线距离(图中红线标出部分)。 思考:假设地球是个标准的球体(实际上地球是一个两极稍扁,赤道略鼓的椭球),很显然,只要知道A、B两点与
  • arcgis中求点与线之间最短距离,路径分析,
  • (1)与迪杰斯特拉(Dijkstra)算法一样,弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法,该算法 名称以创始人之一、1978 年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德...
  • 两点之间最短路径的计算-floyd算法 Floyd算法的核心内容 算法过程图解 伪代码 完整代码 void floyd() { for (int k = 0; k < n; ++k) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; +...
  • (1)与弗洛伊德(Floyd)算法一样,迪杰斯特拉(Dijkstra)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法,主要 特点是以出发为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止 2. 迪杰...
  • //邻接矩阵记录两点之间的距离 int used[110]; //标记经过的点 int sum[110]; //记录从起点到所有终点的最短距离。 int len; //累次叠加的长度 int main() { int n,m,i,j,x,y,time,temp,min,record; while( ...
  • 1.问题 用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵(顶点之间最短距离矩阵)。 2.解析 3.设计 5.源码 [github源码地址] https://github.com/tangzhejia/algorithm ...
  • 不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。 #include&lt;cstdio&gt; #include&lt;cstring&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,351
精华内容 19,340
关键字:

两点之间最短距离怎么求