精华内容
下载资源
问答
  • 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);
    }
    
    
    更多相关内容
  • 直接运用两点间距离公式 (x2-x1)^ 2+(y2-y1)^ 2开根号 //两点间距离 double getDistancePP(Point a,Point b) { //这个代码是部分代码,有些逻辑没有展现完全,大家往下看! Point c(b.x-a.x,b.y-a.y);//返回一个新的...

    两点之间的距离

    直接运用两点间距离公式 (x2-x1)^ 2+(y2-y1)^ 2开根号

    //两点间距离
    double getDistancePP(Point a,Point b)
    {
    //这个代码是部分代码,有些逻辑没有展现完全,大家往下看!
        Point c(b.x-a.x,b.y-a.y);//返回一个新的点
        return  c.abs();//取模
    }
    

    点到直线距离

    通常给出3个点,其中两个点构成一条直线,求另外一个点到直线的距离,我们将点与点的关系转换为向量之间关系进而利用向量知识求出点到直线距离!

    点到直线距离,我们可以利用外积的取模公式的几何意义,|axb|=|a|x|b|sinθ=所围成平行四边形面积,先求出向量a✖向量b的模,然后除以平行四边形底边边长|a|,最后用平行四边形面积除以底边边长就是高,也就是点到直线距离!

    图解

    在这里插入图片描述
    不明白外积模的几何意义点击下方超链接
    外积知识点大全

    实现代码

    //点到直线距离(利用外积平行四边形)
    double getDistancePL(Point a,Point b,Point c)
    {
        Vector ab(b.x-a.x,b.y-a.y);
        Vector ac(c.x-a.x,c.y-a.y);
    
        return cross(ab,ac)/ab.abs();//cross函数求两个向量的外积模,abs函数求向量模
    }
    

    点到线段距离

    点到线段距离有一点复杂,因为线段不像直线那样可以无限延申,线段有端点,这就导致了点到线段距离可以分为3种情况!

    第一种:点到线段距离等于点到直线的距离
    图示
    在这里插入图片描述

    第二种:点到线段距离等于点到左端点的距离
    图示
    在这里插入图片描述

    第三种:点到线段等于点到右端点的距离
    图示
    在这里插入图片描述

    如何判断θ大小呢?

    我们利用内积大小判断 a·b=|a|x|b|cosθ
    如果a·b>0则θ在0~90°之间
    如果a·b<0则θ在90°~180°之间

    实现代码

    //点到线段距离
    double getDistancePS(Point a,Point b,Point c)
    {
        //定义4个向量
        Vector ab(b.x-a.x,b.y-a.y);
        Vector ba(a.x-b.x,a.y-b.y);
        Vector ac(c.x-a.x,c.y-a.y);
        Vector bc(c.x-b.x,c.y-b.y);
        //dot函数用于求内积
        if(dot(ab,ac)<0.0) return getDistancePP(a,c);//到左端点距离
        if(dot(ba,bc)<0.0) return getDistancePP(b,c);//到右端点距离
    
        return getDistancePL(a,b,c);//点到直线距离
    }
    
    

    线段到线段距离

    有了点到线段距离,求解线段到线段距离就容易多了!

    首先、两个线段4个端点,我们分别用其中一个线段的一个端点,求出到另外一个线段的距离,在求出另一个端点到线段的距离,在更换线段,依次类推,我们求出4个不同的点到线段的距离,然后取最小值即可!

    在代码中有一点我们暂时不考虑,就是两个线段相交的时候,那么他们的距离应该为0!

    放在下一节学完两条线段相交的判定后直接添加一个if语句即可!

    实现代码

    //线段到线段的距离
    double getDistanceSS(Point a,Point b,Point c,Point d)
    {
        //从4个点到2线段距离中取最小
        return min(min(getDistancePS(c,d,a),getDistancePS(c,d,b)),min(getDistancePS(a,b,c),getDistancePS(a,b,d)));
    }
    

    完整代码

    #include <bits/stdc++.h>
    
    using namespace std;
    
    class Point
    {
    
    public:
        double x,y;
    
        Point(double x=0,double y=0):x(x),y(y) {}
    
        //向量加法
        Point operator+(Point p)
        {
            return Point(x+p.x,y+p.y);
        }
        //向量减法
        Point operator-(Point p)
        {
            return Point(x-p.x,y+p.y);
        }
        //向量伸缩
        Point operator*(double a)
        {
            return Point(x*a,y*a);
        }
        Point operator/(double a)
        {
            return Point(x/a,y/a);
        }
        //向量大小
        double abs()
        {
            return sqrt(norm());
        }
        //向量范数
        double norm()
        {
            return x*x+y*y;
        }
    
        bool operator<(const Point &p) const
        {
            return x!=p.x?x<p.x:y<p.y;
        }
    
        bool operator==(const Point &p)const
        {
            return x-p.x<1e-10&&y-p.y<1e-10;
        }
    
    };
    
    typedef Point Vector;
    
    //向量内积
    double dot(Vector a,Vector b)
    {
        return a.x*b.x+a.y*b.y;
    }
    
    //向量外积
    double cross(Vector a,Vector b)
    {
        return abs(a.x*b.y-a.y*b.x);
    }
    
    //正交
    bool isOrthogonal(Vector a,Vector b)
    {
        return a.x*b.x+a.y*b.y==0;
    }
    //平行
    bool isParallel(Vector a,Vector b)
    {
        return a.x*b.y-a.y*b.x==0;
    }
    
    //投影
    Point project(Point a,Point b,Point c)
    {
        Vector ab(b.x-a.x,b.y-a.y);
        Vector ac(c.x-a.x,c.y-a.y);
        double  r=dot(ab,ac)/ab.norm();//比例
        Vector h(ab*r);
        return Point(a.x+h.x,a.y+h.y);
    }
    
    //映象
    
    Point reflect(Point a,Point b,Point c)
    {
        //c到ab的投影点
        Point r=project(a,b,c);
        Vector cr(r.x-c.x,r.y-c.y);
        //cr扩大二倍
        Vector cr_2=cr*2;//上面重载过*
        //向量加法
        return Point(c.x+cr_2.x,c.y+cr_2.y);
    }
    
    //两点间距离
    double getDistancePP(Point a,Point b)
    {
        Point c(b.x-a.x,b.y-a.y);
        return  c.abs();
    }
    
    //点到直线距离(利用外积平行四边形)
    double getDistancePL(Point a,Point b,Point c)
    {
        Vector ab(b.x-a.x,b.y-a.y);
        Vector ac(c.x-a.x,c.y-a.y);
    
        return cross(ab,ac)/ab.abs();
    }
    
    //点到线段距离
    double getDistancePS(Point a,Point b,Point c)
    {
        //定义4个向量
        Vector ab(b.x-a.x,b.y-a.y);
        Vector ba(a.x-b.x,a.y-b.y);
        Vector ac(c.x-a.x,c.y-a.y);
        Vector bc(c.x-b.x,c.y-b.y);
    
        if(dot(ab,ac)<0.0) return getDistancePP(a,c);
        if(dot(ba,bc)<0.0) return getDistancePP(b,c);
    
        return getDistancePL(a,b,c);
    }
    
    
    //线段到线段的距离
    double getDistanceSS(Point a,Point b,Point c,Point d)
    {
        //从4个点到2线段距离中取最小
        return min(min(getDistancePS(c,d,a),getDistancePS(c,d,b)),min(getDistancePS(a,b,c),getDistancePS(a,b,d)));
    }
    int main()
    {
        int x0,y0,x1,y1,x2,y2,x3,y3;
        cin>>x0>>y0>>x1>>y1>>x2>>y2;
        Point a(x0,y0);
        Point b(x1,y1);
        cout<<"a,b两点间距离"<<getDistancePP(a,b)<<endl;
        Point c(x2,y2);
        cout<<"c点到直线ab距离"<<getDistancePL(a,b,c)<<endl;
        
        cout<<"c点到线段ab的距离"<<getDistancePS(a,b,c)<<endl;
        cin>>x3>>y3;
        
        Point d(x3,y3);
        cout<<"线段ab到线段cd的距离"<<getDistanceSS(a,b,c,d)<<endl;
    
        return 0;
    }
    
    

    线段的逆时针方向(顺时针、正上方、正下方、线段上)、相交判断
    –>click–>click

    展开全文
  • 根据经纬度计算两点之间的距离

    千次阅读 2019-09-24 14:47:40
    经纬度计算有各种计算方式,一般误差也各不相同。个人觉着结合地球半径的计算方法可能靠谱一些,但是具体的计算公式是怎么来... 距离是1057公里,误差有一些,但是相对来说已经比较准了,对于一般的应用来说够用了。

        经纬度计算有各种计算方式,一般误差也各不相同。个人觉着结合地球半径的计算方法可能靠谱一些,但是具体的计算公式是怎么来的,就不清楚,不知道谁提出的。下面给出一个计算方法和经纬度查询网站上的查询结果很接近了。

        下面给出代码,并附上运行的结果:

    package com.xxx.javaee.common;
    public class DistanceCalculate {
    	//地球半径
    	private static final double R = 6378.137d;
    	
    	public static double radius(double d) {
    		return d * Math.PI / 180.0;
    	}
    	
    	public static double getDistanceByR(Point a,Point b) {
    		double distance = 0;
    		double lata = radius(a.latitude);
    		double latb = radius(b.latitude);
    		
    		double latd = lata - latb;
    		double lond = radius(a.longitude-b.longitude);
    		
    		double sina = Math.sin(latd/2.0);
    		double sinb = Math.sin(lond/2.0);
    		
    		distance = 2 * R * Math.asin(Math.sqrt(sina*sina+Math.cos(lata)*Math.cos(latb)*sinb*sinb));
    		return distance;
    		
    	}
    	
    	public static void main(String[] args) {
    		Point a = new Point(116.4028930664d,39.9034155951d);
    		Point b = new Point(114.3347167969d,30.5433389542d);
    		System.out.println("distance by radius : "+getDistanceByR(a, b));
    	}
    }
    
    class Point{
    	double longitude;//经度
    	double latitude; //纬度
    	
    	public Point() {}
    	
    	public Point(double longitude,double latitude) {
    		this.longitude = longitude;
    		this.latitude = latitude;
    	}
    }
    

    这里给出的示例是粗略计算北京到武汉的直线距离,经纬度都定位在北京和武汉的中心位置,他们的经纬度分别是:北京(116.4028930664d,39.9034155951d)与武汉(114.3347167969d,30.5433389542d)。

    运行程序得到的结果如下:

    我这里计算的是大概1058公里,我们通过前面提到的gps查询网站的数据来对比一下:

    准确输入两点的纬度和经度,点击提交得到:

     

     距离是1057公里,误差有一些,但是相对来说已经比较准了,对于一般的应用来说够用了。

    展开全文
  • 最近比较闲,所以就顺便研究高德地图,原因是之前基本上都用的百度地图,但是百度地图的代码太多了,字,很烦。先来个效果图: 蓝色的marker就是点击的,蓝色的圆圈是我当前位置。 apk下载地址:...

    最近比较闲,所以就顺便研究高德地图,原因是之前基本上都用的百度地图,但是百度地图的代码太多了,两字,很烦。

    先来个效果图:
    这里写图片描述
    蓝色的marker就是点击的,蓝色的圆圈是我当前位置。
    apk下载地址:http://download.csdn.net/detail/hedong_77/9731739
    一些基本操作这里就不多说了,自己去看官方文档,我们这里说一下周边搜索和POI计算距离。
    首先定位一下自己当前位置,因为我要拿到当前的位置的经纬度,后面有用:

     /**
         * 设置一些amap的属性
         */
        private void setUpLocation() {
            mAMap.setLocationSource(this);// 设置定位监听
            mAMap.getUiSettings().setMyLocationButtonEnabled(true);// 设置默认定位按钮是否显示
            mAMap.setMyLocationEnabled(true);// 设置为true表示显示定位层并可触发定位,false表示隐藏定位层并不可触发定位,默认是false
            // 设置定位的类型为定位模式 ,可以由定位、跟随或地图根据面向方向旋转几种
            mAMap.setMyLocationType(AMap.LOCATION_TYPE_LOCATE);
        }
    
        /**
         * 定位成功后回调函数
         */
        @Override
        public void onLocationChanged(AMapLocation amapLocation) {
            if (mListener != null && amapLocation != null) {
                if (amapLocation != null
                        && amapLocation.getErrorCode() == 0) {
    
                    //定位成功回调信息,设置相关消息
                    amapLocation.getLocationType();//获取当前定位结果来源,如网络定位结果,详见定位类型表
                    myLat = amapLocation.getLatitude();//获取纬度
                    myLongt = amapLocation.getLongitude();//获取经度
                    amapLocation.getAccuracy();//获取精度信息
                    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    Date date = new Date(amapLocation.getTime());
                    df.format(date);//定位时间
                    amapLocation.getAddress();//地址,如果option中设置isNeedAddress为false,则没有此结果,网络定位结果中会有地址信息,GPS定位不返回地址信息。
                    amapLocation.getCountry();//国家信息
                    amapLocation.getProvince();//省信息
                    amapLocation.getCity();//城市信息
                    amapLocation.getDistrict();//城区信息
                    amapLocation.getStreet();//街道信息
                    amapLocation.getStreetNum();//街道门牌号信息
                    amapLocation.getCityCode();//城市编码
                    amapLocation.getAdCode();//地区编码
                    TextView textView = (TextView) findViewById(R.id.city_detail);
                    textView.setText(amapLocation.getCity() + "=" + amapLocation.getDistrict() + "==" + amapLocation.getStreetNum());
                    mListener.onLocationChanged(amapLocation);// 显示系统小蓝点
                } else {
                    String errText = "定位失败," + amapLocation.getErrorCode() + ": " + amapLocation.getErrorInfo();
                    Log.e("AmapErr", errText);
                }
            }
        }
    
        /**
         * 激活定位
         */
        @Override
        public void activate(OnLocationChangedListener listener) {
            mListener = listener;
            if (mlocationClient == null) {
                mlocationClient = new AMapLocationClient(this);
                mLocationOption = new AMapLocationClientOption();
                //设置定位监听
                mlocationClient.setLocationListener(this);
                //设置为高精度定位模式
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
                //设置定位参数
                mlocationClient.setLocationOption(mLocationOption);
                // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
                // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
                // 在定位结束后,在合适的生命周期调用onDestroy()方法
                // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
                mlocationClient.startLocation();
            }
        }
    
        /**
         * 停止定位
         */
        @Override
        public void deactivate() {
            mListener = null;
            if (mlocationClient != null) {
                mlocationClient.stopLocation();
                mlocationClient.onDestroy();
            }
            mlocationClient = null;
        }

    可以看到,定位成功之后我们可以拿到任何想要的数据。
    一步步来,先初始化一下数据,

      /**
         * 初始化AMap对象
         */
        private void init() {
            if (mAMap == null) {
                mAMap = mapview.getMap();
                mAMap.setOnMapClickListener(this);
                mAMap.setOnMarkerClickListener(this);
                mAMap.setOnInfoWindowClickListener(this);
                mAMap.setInfoWindowAdapter(this);
                TextView searchButton = (TextView) findViewById(R.id.btn_search);
                searchButton.setOnClickListener(this);
                setUpLocation();
                locationMarker = mAMap.addMarker(new MarkerOptions()
                        .anchor(0.5f, 0.5f)
                        .icon(BitmapDescriptorFactory
                                .fromBitmap(BitmapFactory.decodeResource(getResources(), R.mipmap.point4)))
                        .position(new LatLng(myLat, myLongt)));
                locationMarker.showInfoWindow();
    
    
            }
    
            setup();
    
            mAMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(myLat, myLongt), 14));
            tvDistance = (TextView) findViewById(R.id.poi_info);
    
        }

    我们可以根据自己想要的去搜索

    /**
         * 开始进行poi搜索
         */
        protected void doSearchQuery() {
            keyWord = mSearchText.getText().toString().trim();
            currentPage = 0;
            query = new PoiSearch.Query(keyWord, "", "");// 第一个参数表示搜索字符串,第二个参数表示poi搜索类型,第三个参数表示poi搜索区域(空字符串代表全国)
            query.setPageSize(20);// 设置每页最多返回多少条poiitem
            query.setPageNum(currentPage);// 设置查第一页
    
            LatLonPoint lp = new LatLonPoint(myLat, myLongt);
            if (lp != null) {
                poiSearch = new PoiSearch(this, query);
                poiSearch.setOnPoiSearchListener(this);
    
                poiSearch.setBound(new SearchBound(lp, 10000, true));//
                // 设置搜索区域为以lp点为圆心,其周围10000米范围
                poiSearch.searchPOIAsyn();// 异步搜索
            }
        }```
        搜索的结果会在   public void onPoiSearched(PoiResult result, int rcode) 里面来做,如果rcode==1000那就是搜索成功了
    @Override
    public void onPoiSearched(PoiResult result, int rcode) {
        if (rcode == AMapException.CODE_AMAP_SUCCESS) {
            if (result != null && result.getQuery() != null) {// 搜索poi的结果
                if (result.getQuery().equals(query)) {// 是否是同一条
                    poiResult = result;
                    poiItems = poiResult.getPois();// 取得第一页的poiitem数据,页数从数字0开始
                    List<SuggestionCity> suggestionCities = poiResult
                            .getSearchSuggestionCitys();// 当搜索不到poiitem数据时,会返回含有搜索关键字的城市信息
                    if (poiItems != null && poiItems.size() > 0) {
                        //清除POI信息显示
                        whetherToShowDetailInfo(false);
                        //并还原点击marker样式
                        if (mlastMarker != null) {
                            resetlastmarker();
                        }
                        //清理之前搜索结果的marker
                        if (poiOverlay != null) {
                            poiOverlay.removeFromMap();
                        }
                        mAMap.clear();
                        poiOverlay = new myPoiOverlay(mAMap, poiItems);
                        poiOverlay.addToMap();
                        poiOverlay.zoomToSpan();
    
                        mAMap.addMarker(new MarkerOptions()
                                .anchor(0.5f, 0.5f)
                                .icon(BitmapDescriptorFactory
                                        .fromBitmap(BitmapFactory.decodeResource(
                                                getResources(), R.mipmap.point4)))
                                .position(new LatLng(myLat, myLongt)));
    

    // mAMap.addCircle(new CircleOptions()
    // .center(new LatLng(myLat, myLongt)).radius(5000)
    // .strokeColor(Color.BLUE)
    // .fillColor(Color.argb(50, 1, 1, 1))
    // .strokeWidth(2));

                    } else if (suggestionCities != null
                            && suggestionCities.size() > 0) {
                        showSuggestCity(suggestionCities);
                    } else {
                        ToastUtil.show(PoiAroundSearchActivity.this,
                                R.string.no_result);
                    }
                }
            } else {
                ToastUtil
                        .show(PoiAroundSearchActivity.this, R.string.no_result);
            }
        } else {
            ToastUtil.showerror(this.getApplicationContext(), rcode);
        }
    }
    
    接下来要做的就是根据搜索到的marker,当用户点击这个marker的时候,就计算出用户当前点击的marker到用户之间的距离。
    

    @Override
    public boolean onMarkerClick(Marker marker) {

        if (marker.getObject() != null) {
            whetherToShowDetailInfo(true);
            try {
                PoiItem mCurrentPoi = (PoiItem) marker.getObject();
                if (mlastMarker == null) {
                    mlastMarker = marker;
                } else {
                    // 将之前被点击的marker置为原来的状态
                    resetlastmarker();
                    mlastMarker = marker;
                }
                detailMarker = marker;
                detailMarker.setIcon(BitmapDescriptorFactory
                        .fromBitmap(BitmapFactory.decodeResource(
                                getResources(),
                                R.mipmap.poi_marker_pressed)));
    
                setPoiItemDisplayContent(mCurrentPoi);
            } catch (Exception e) {
                // TODO: handle exception
            }
        } else {
            whetherToShowDetailInfo(false);
            resetlastmarker();
        }
    
        //我的当前位置与点击的marker的距离
        LatLng latlngA = new LatLng(myLat, myLongt);
        distance = AMapUtils.calculateLineDistance(latlngA, marker.getPosition());
        tvDistance.setText("两点间距离为:" + distance + "m");
        return true;
    }
    

    这里我只是显示十个marker。
    怎么把marker添加到地图里面呢,我们自己定义一个类吧,

     /**
         * 自定义PoiOverlay
         */
        private class myPoiOverlay {
            private AMap mamap;
            private List<PoiItem> mPois;
            private ArrayList<Marker> mPoiMarks = new ArrayList<Marker>();
    
            public myPoiOverlay(AMap amap, List<PoiItem> pois) {
                mamap = amap;
                mPois = pois;
            }
    
            /**
             * 添加Marker到地图中。
             *
             * @since V2.1.0
             */
            public void addToMap() {
                for (int i = 0; i < mPois.size(); i++) {
                    Marker marker = mamap.addMarker(getMarkerOptions(i));
                    PoiItem item = mPois.get(i);
                    marker.setObject(item);
                    mPoiMarks.add(marker);
                }
            }
    
            /**
             * 去掉PoiOverlay上所有的Marker。
             *
             * @since V2.1.0
             */
            public void removeFromMap() {
                for (Marker mark : mPoiMarks) {
                    mark.remove();
                }
            }
    
            /**
             * 移动镜头到当前的视角。
             *
             * @since V2.1.0
             */
            public void zoomToSpan() {
                if (mPois != null && mPois.size() > 0) {
                    if (mamap == null)
                        return;
                    LatLngBounds bounds = getLatLngBounds();
                    mamap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 100));
                }
            }
    
            private LatLngBounds getLatLngBounds() {
                LatLngBounds.Builder b = LatLngBounds.builder();
                for (int i = 0; i < mPois.size(); i++) {
                    b.include(new LatLng(mPois.get(i).getLatLonPoint().getLatitude(),
                            mPois.get(i).getLatLonPoint().getLongitude()));
                }
                return b.build();
            }
    
            private MarkerOptions getMarkerOptions(int index) {
                return new MarkerOptions()
                        .position(
                                new LatLng(mPois.get(index).getLatLonPoint()
                                        .getLatitude(), mPois.get(index)
                                        .getLatLonPoint().getLongitude()))
                        .title(getTitle(index)).snippet(getSnippet(index))
                        .icon(getBitmapDescriptor(index));
            }
    
            protected String getTitle(int index) {
                return mPois.get(index).getTitle();
            }
    
            protected String getSnippet(int index) {
                return mPois.get(index).getSnippet();
            }
    
            /**
             * 从marker中得到poi在list的位置。
             *
             * @param marker 一个标记的对象。
             * @return 返回该marker对应的poi在list的位置。
             * @since V2.1.0
             */
            public int getPoiIndex(Marker marker) {
                for (int i = 0; i < mPoiMarks.size(); i++) {
                    if (mPoiMarks.get(i).equals(marker)) {
                        return i;
                    }
                }
                return -1;
            }
    
            /**
             * 返回第index的poi的信息。
             *
             * @param index 第几个poi。
             * @return poi的信息。poi对象详见搜索服务模块的基础核心包(com.amap.api.services.core)中的类 <strong><a href="../../../../../../Search/com/amap/api/services/core/PoiItem.html" title="com.amap.api.services.core中的类">PoiItem</a></strong>。
             * @since V2.1.0
             */
            public PoiItem getPoiItem(int index) {
                if (index < 0 || index >= mPois.size()) {
                    return null;
                }
                return mPois.get(index);
            }
    
            protected BitmapDescriptor getBitmapDescriptor(int arg0) {
                if (arg0 < 10) {
                    BitmapDescriptor icon = BitmapDescriptorFactory.fromBitmap(
                            BitmapFactory.decodeResource(getResources(), markers[arg0]));
                    return icon;
                } else {
                    BitmapDescriptor icon = BitmapDescriptorFactory.fromBitmap(
                            BitmapFactory.decodeResource(getResources(), R.mipmap.marker_other_highlight));
                    return icon;
                }
            }
        }
    代码解释很全面,应该看懂没问题了。主要代码也就这么多。
    贴一个全面的类给大家参考:
    

    import android.graphics.BitmapFactory;
    import android.os.Bundle;
    import android.support.annotation.Nullable;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.EditText;
    import android.widget.RelativeLayout;
    import android.widget.TextView;

    import com.amap.api.location.AMapLocation;
    import com.amap.api.location.AMapLocationClient;
    import com.amap.api.location.AMapLocationClientOption;
    import com.amap.api.location.AMapLocationListener;
    import com.amap.api.maps.AMap;
    import com.amap.api.maps.AMap.InfoWindowAdapter;
    import com.amap.api.maps.AMap.OnInfoWindowClickListener;
    import com.amap.api.maps.AMap.OnMapClickListener;
    import com.amap.api.maps.AMap.OnMarkerClickListener;
    import com.amap.api.maps.AMapUtils;
    import com.amap.api.maps.CameraUpdateFactory;
    import com.amap.api.maps.LocationSource;
    import com.amap.api.maps.MapView;
    import com.amap.api.maps.model.BitmapDescriptor;
    import com.amap.api.maps.model.BitmapDescriptorFactory;
    import com.amap.api.maps.model.LatLng;
    import com.amap.api.maps.model.LatLngBounds;
    import com.amap.api.maps.model.Marker;
    import com.amap.api.maps.model.MarkerOptions;
    import com.amap.api.services.core.AMapException;
    import com.amap.api.services.core.LatLonPoint;
    import com.amap.api.services.core.PoiItem;
    import com.amap.api.services.core.SuggestionCity;
    import com.amap.api.services.poisearch.PoiResult;
    import com.amap.api.services.poisearch.PoiSearch;
    import com.amap.api.services.poisearch.PoiSearch.OnPoiSearchListener;
    import com.amap.api.services.poisearch.PoiSearch.SearchBound;
    import com.example.donghe.maptest.utils.ToastUtil;

    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;

    /**
    * 周边搜索
    */
    public class PoiAroundSearchActivity extends AppCompatActivity implements OnClickListener,
    OnMapClickListener, OnInfoWindowClickListener, InfoWindowAdapter, OnMarkerClickListener,
    OnPoiSearchListener, LocationSource,
    AMapLocationListener {
    private MapView mapview;
    private AMap mAMap;

    private PoiResult poiResult; // poi返回的结果
    private int currentPage = 0;// 当前页面,从0开始计数
    private PoiSearch.Query query;// Poi查询条件类
    private Marker locationMarker; // 选择的点
    private Marker detailMarker;
    private Marker mlastMarker;
    private PoiSearch poiSearch;
    private myPoiOverlay poiOverlay;// poi图层
    private List<PoiItem> poiItems;// poi数据
    
    private RelativeLayout mPoiDetail;
    private TextView mPoiName, mPoiAddress;
    private String keyWord = "";
    private EditText mSearchText;
    private TextView tvDistance;
    
    private float distance;
    private Double myLat = 0.0, myLongt = 0.0;//我的当前位置的经纬度
    
    //定位
    private OnLocationChangedListener mListener;
    private AMapLocationClient mlocationClient;
    private AMapLocationClientOption mLocationOption;
    
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.poiaroundsearch_activity);
        mapview = (MapView) findViewById(R.id.mapView);
        mapview.onCreate(savedInstanceState);
        init();
    }
    
    /**
     * 初始化AMap对象
     */
    private void init() {
        if (mAMap == null) {
            mAMap = mapview.getMap();
            mAMap.setOnMapClickListener(this);
            mAMap.setOnMarkerClickListener(this);
            mAMap.setOnInfoWindowClickListener(this);
            mAMap.setInfoWindowAdapter(this);
            TextView searchButton = (TextView) findViewById(R.id.btn_search);
            searchButton.setOnClickListener(this);
            setUpLocation();
            locationMarker = mAMap.addMarker(new MarkerOptions()
                    .anchor(0.5f, 0.5f)
                    .icon(BitmapDescriptorFactory
                            .fromBitmap(BitmapFactory.decodeResource(getResources(), R.mipmap.point4)))
                    .position(new LatLng(myLat, myLongt)));
            locationMarker.showInfoWindow();
    
    
        }
    
        setup();
    
        mAMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(myLat, myLongt), 14));
        tvDistance = (TextView) findViewById(R.id.poi_info);
    
    }
    
    private void setup() {
        mPoiDetail = (RelativeLayout) findViewById(R.id.poi_detail);
        mPoiDetail.setOnClickListener(new OnClickListener() {
    
            @Override
            public void onClick(View v) {
    

    // Intent intent = new Intent(PoiSearchActivity.this,
    // SearchDetailActivity.class);
    // intent.putExtra(“poiitem”, mPoi);
    // startActivity(intent);

            }
        });
        mPoiName = (TextView) findViewById(R.id.poi_name);
        mPoiAddress = (TextView) findViewById(R.id.poi_address);
        mSearchText = (EditText) findViewById(R.id.input_edittext);
    }
    
    /**
     * 开始进行poi搜索
     */
    protected void doSearchQuery() {
        keyWord = mSearchText.getText().toString().trim();
        currentPage = 0;
        query = new PoiSearch.Query(keyWord, "", "");// 第一个参数表示搜索字符串,第二个参数表示poi搜索类型,第三个参数表示poi搜索区域(空字符串代表全国)
        query.setPageSize(20);// 设置每页最多返回多少条poiitem
        query.setPageNum(currentPage);// 设置查第一页
    
        LatLonPoint lp = new LatLonPoint(myLat, myLongt);
        if (lp != null) {
            poiSearch = new PoiSearch(this, query);
            poiSearch.setOnPoiSearchListener(this);
    
            poiSearch.setBound(new SearchBound(lp, 10000, true));//
            // 设置搜索区域为以lp点为圆心,其周围10000米范围
            poiSearch.searchPOIAsyn();// 异步搜索
        }
    }
    
    /**
     * 方法必须重写
     */
    @Override
    protected void onResume() {
        super.onResume();
        mapview.onResume();
        whetherToShowDetailInfo(false);
    }
    
    /**
     * 方法必须重写
     */
    @Override
    protected void onPause() {
        super.onPause();
        mapview.onPause();
    }
    
    /**
     * 方法必须重写
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        mapview.onSaveInstanceState(outState);
    }
    
    /**
     * 方法必须重写
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mapview.onDestroy();
    }
    
    @Override
    public void onPoiItemSearched(PoiItem arg0, int arg1) {
        // TODO Auto-generated method stub
    
    }
    
    
    @Override
    public void onPoiSearched(PoiResult result, int rcode) {
        if (rcode == AMapException.CODE_AMAP_SUCCESS) {
            if (result != null && result.getQuery() != null) {// 搜索poi的结果
                if (result.getQuery().equals(query)) {// 是否是同一条
                    poiResult = result;
                    poiItems = poiResult.getPois();// 取得第一页的poiitem数据,页数从数字0开始
                    List<SuggestionCity> suggestionCities = poiResult
                            .getSearchSuggestionCitys();// 当搜索不到poiitem数据时,会返回含有搜索关键字的城市信息
                    if (poiItems != null && poiItems.size() > 0) {
                        //清除POI信息显示
                        whetherToShowDetailInfo(false);
                        //并还原点击marker样式
                        if (mlastMarker != null) {
                            resetlastmarker();
                        }
                        //清理之前搜索结果的marker
                        if (poiOverlay != null) {
                            poiOverlay.removeFromMap();
                        }
                        mAMap.clear();
                        poiOverlay = new myPoiOverlay(mAMap, poiItems);
                        poiOverlay.addToMap();
                        poiOverlay.zoomToSpan();
    
                        mAMap.addMarker(new MarkerOptions()
                                .anchor(0.5f, 0.5f)
                                .icon(BitmapDescriptorFactory
                                        .fromBitmap(BitmapFactory.decodeResource(
                                                getResources(), R.mipmap.point4)))
                                .position(new LatLng(myLat, myLongt)));
    

    // mAMap.addCircle(new CircleOptions()
    // .center(new LatLng(myLat, myLongt)).radius(5000)
    // .strokeColor(Color.BLUE)
    // .fillColor(Color.argb(50, 1, 1, 1))
    // .strokeWidth(2));

                    } else if (suggestionCities != null
                            && suggestionCities.size() > 0) {
                        showSuggestCity(suggestionCities);
                    } else {
                        ToastUtil.show(PoiAroundSearchActivity.this,
                                R.string.no_result);
                    }
                }
            } else {
                ToastUtil
                        .show(PoiAroundSearchActivity.this, R.string.no_result);
            }
        } else {
            ToastUtil.showerror(this.getApplicationContext(), rcode);
        }
    }
    
    
    @Override
    public boolean onMarkerClick(Marker marker) {
    
        if (marker.getObject() != null) {
            whetherToShowDetailInfo(true);
            try {
                PoiItem mCurrentPoi = (PoiItem) marker.getObject();
                if (mlastMarker == null) {
                    mlastMarker = marker;
                } else {
                    // 将之前被点击的marker置为原来的状态
                    resetlastmarker();
                    mlastMarker = marker;
                }
                detailMarker = marker;
                detailMarker.setIcon(BitmapDescriptorFactory
                        .fromBitmap(BitmapFactory.decodeResource(
                                getResources(),
                                R.mipmap.poi_marker_pressed)));
    
                setPoiItemDisplayContent(mCurrentPoi);
            } catch (Exception e) {
                // TODO: handle exception
            }
        } else {
            whetherToShowDetailInfo(false);
            resetlastmarker();
        }
    
        //我的当前位置与点击的marker的距离
        LatLng latlngA = new LatLng(myLat, myLongt);
        distance = AMapUtils.calculateLineDistance(latlngA, marker.getPosition());
        tvDistance.setText("两点间距离为:" + distance + "m");
        return true;
    }
    
    // 将之前被点击的marker置为原来的状态
    private void resetlastmarker() {
        int index = poiOverlay.getPoiIndex(mlastMarker);
        if (index < 10) {
            mlastMarker.setIcon(BitmapDescriptorFactory
                    .fromBitmap(BitmapFactory.decodeResource(
                            getResources(),
                            markers[index])));
        } else {
            mlastMarker.setIcon(BitmapDescriptorFactory.fromBitmap(
                    BitmapFactory.decodeResource(getResources(), R.mipmap.marker_other_highlight)));
        }
        mlastMarker = null;
    
    }
    
    
    private void setPoiItemDisplayContent(final PoiItem mCurrentPoi) {
        mPoiName.setText(mCurrentPoi.getTitle());
        mPoiAddress.setText(mCurrentPoi.getSnippet() + mCurrentPoi.getDistance());
    }
    
    
    @Override
    public View getInfoContents(Marker arg0) {
        // TODO Auto-generated method stub
        return null;
    }
    
    
    @Override
    public View getInfoWindow(Marker arg0) {
        // TODO Auto-generated method stub
        return null;
    }
    
    
    @Override
    public void onInfoWindowClick(Marker arg0) {
        // TODO Auto-generated method stub
    
    }
    
    
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_search:
                doSearchQuery();
                break;
    
            default:
                break;
        }
    
    }
    
    private int[] markers = {R.mipmap.poi_marker_1,
            R.mipmap.poi_marker_2,
            R.mipmap.poi_marker_3,
            R.mipmap.poi_marker_4,
            R.mipmap.poi_marker_5,
            R.mipmap.poi_marker_6,
            R.mipmap.poi_marker_7,
            R.mipmap.poi_marker_8,
            R.mipmap.poi_marker_9,
            R.mipmap.poi_marker_10
    };
    
    private void whetherToShowDetailInfo(boolean isToShow) {
        if (isToShow) {
            mPoiDetail.setVisibility(View.VISIBLE);
    
        } else {
            mPoiDetail.setVisibility(View.GONE);
    
        }
    }
    
    
    @Override
    public void onMapClick(LatLng arg0) {
        whetherToShowDetailInfo(false);
        if (mlastMarker != null) {
            resetlastmarker();
        }
    }
    
    /**
     * poi没有搜索到数据,返回一些推荐城市的信息
     */
    private void showSuggestCity(List<SuggestionCity> cities) {
        String infomation = "推荐城市\n";
        for (int i = 0; i < cities.size(); i++) {
            infomation += "城市名称:" + cities.get(i).getCityName() + "城市区号:"
                    + cities.get(i).getCityCode() + "城市编码:"
                    + cities.get(i).getAdCode() + "\n";
        }
        ToastUtil.show(this, infomation);
    
    }
    
    
    /**
     * 自定义PoiOverlay
     */
    private class myPoiOverlay {
        private AMap mamap;
        private List<PoiItem> mPois;
        private ArrayList<Marker> mPoiMarks = new ArrayList<Marker>();
    
        public myPoiOverlay(AMap amap, List<PoiItem> pois) {
            mamap = amap;
            mPois = pois;
        }
    
        /**
         * 添加Marker到地图中。
         *
         * @since V2.1.0
         */
        public void addToMap() {
            for (int i = 0; i < mPois.size(); i++) {
                Marker marker = mamap.addMarker(getMarkerOptions(i));
                PoiItem item = mPois.get(i);
                marker.setObject(item);
                mPoiMarks.add(marker);
            }
        }
    
        /**
         * 去掉PoiOverlay上所有的Marker。
         *
         * @since V2.1.0
         */
        public void removeFromMap() {
            for (Marker mark : mPoiMarks) {
                mark.remove();
            }
        }
    
        /**
         * 移动镜头到当前的视角。
         *
         * @since V2.1.0
         */
        public void zoomToSpan() {
            if (mPois != null && mPois.size() > 0) {
                if (mamap == null)
                    return;
                LatLngBounds bounds = getLatLngBounds();
                mamap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 100));
            }
        }
    
        private LatLngBounds getLatLngBounds() {
            LatLngBounds.Builder b = LatLngBounds.builder();
            for (int i = 0; i < mPois.size(); i++) {
                b.include(new LatLng(mPois.get(i).getLatLonPoint().getLatitude(),
                        mPois.get(i).getLatLonPoint().getLongitude()));
            }
            return b.build();
        }
    
        private MarkerOptions getMarkerOptions(int index) {
            return new MarkerOptions()
                    .position(
                            new LatLng(mPois.get(index).getLatLonPoint()
                                    .getLatitude(), mPois.get(index)
                                    .getLatLonPoint().getLongitude()))
                    .title(getTitle(index)).snippet(getSnippet(index))
                    .icon(getBitmapDescriptor(index));
        }
    
        protected String getTitle(int index) {
            return mPois.get(index).getTitle();
        }
    
        protected String getSnippet(int index) {
            return mPois.get(index).getSnippet();
        }
    
        /**
         * 从marker中得到poi在list的位置。
         *
         * @param marker 一个标记的对象。
         * @return 返回该marker对应的poi在list的位置。
         * @since V2.1.0
         */
        public int getPoiIndex(Marker marker) {
            for (int i = 0; i < mPoiMarks.size(); i++) {
                if (mPoiMarks.get(i).equals(marker)) {
                    return i;
                }
            }
            return -1;
        }
    
        /**
         * 返回第index的poi的信息。
         *
         * @param index 第几个poi。
         * @return poi的信息。poi对象详见搜索服务模块的基础核心包(com.amap.api.services.core)中的类 <strong><a href="../../../../../../Search/com/amap/api/services/core/PoiItem.html" title="com.amap.api.services.core中的类">PoiItem</a></strong>。
         * @since V2.1.0
         */
        public PoiItem getPoiItem(int index) {
            if (index < 0 || index >= mPois.size()) {
                return null;
            }
            return mPois.get(index);
        }
    
        protected BitmapDescriptor getBitmapDescriptor(int arg0) {
            if (arg0 < 10) {
                BitmapDescriptor icon = BitmapDescriptorFactory.fromBitmap(
                        BitmapFactory.decodeResource(getResources(), markers[arg0]));
                return icon;
            } else {
                BitmapDescriptor icon = BitmapDescriptorFactory.fromBitmap(
                        BitmapFactory.decodeResource(getResources(), R.mipmap.marker_other_highlight));
                return icon;
            }
        }
    }
    
    /**
     * 设置一些amap的属性
     */
    private void setUpLocation() {
        mAMap.setLocationSource(this);// 设置定位监听
        mAMap.getUiSettings().setMyLocationButtonEnabled(true);// 设置默认定位按钮是否显示
        mAMap.setMyLocationEnabled(true);// 设置为true表示显示定位层并可触发定位,false表示隐藏定位层并不可触发定位,默认是false
        // 设置定位的类型为定位模式 ,可以由定位、跟随或地图根据面向方向旋转几种
        mAMap.setMyLocationType(AMap.LOCATION_TYPE_LOCATE);
    }
    
    /**
     * 定位成功后回调函数
     */
    @Override
    public void onLocationChanged(AMapLocation amapLocation) {
        if (mListener != null && amapLocation != null) {
            if (amapLocation != null
                    && amapLocation.getErrorCode() == 0) {
    
                //定位成功回调信息,设置相关消息
                amapLocation.getLocationType();//获取当前定位结果来源,如网络定位结果,详见定位类型表
                myLat = amapLocation.getLatitude();//获取纬度
                myLongt = amapLocation.getLongitude();//获取经度
                amapLocation.getAccuracy();//获取精度信息
                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date date = new Date(amapLocation.getTime());
                df.format(date);//定位时间
                amapLocation.getAddress();//地址,如果option中设置isNeedAddress为false,则没有此结果,网络定位结果中会有地址信息,GPS定位不返回地址信息。
                amapLocation.getCountry();//国家信息
                amapLocation.getProvince();//省信息
                amapLocation.getCity();//城市信息
                amapLocation.getDistrict();//城区信息
                amapLocation.getStreet();//街道信息
                amapLocation.getStreetNum();//街道门牌号信息
                amapLocation.getCityCode();//城市编码
                amapLocation.getAdCode();//地区编码
                TextView textView = (TextView) findViewById(R.id.city_detail);
                textView.setText(amapLocation.getCity() + "=" + amapLocation.getDistrict() + "==" + amapLocation.getStreetNum());
                mListener.onLocationChanged(amapLocation);// 显示系统小蓝点
            } else {
                String errText = "定位失败," + amapLocation.getErrorCode() + ": " + amapLocation.getErrorInfo();
                Log.e("AmapErr", errText);
            }
        }
    }
    
    /**
     * 激活定位
     */
    @Override
    public void activate(OnLocationChangedListener listener) {
        mListener = listener;
        if (mlocationClient == null) {
            mlocationClient = new AMapLocationClient(this);
            mLocationOption = new AMapLocationClientOption();
            //设置定位监听
            mlocationClient.setLocationListener(this);
            //设置为高精度定位模式
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
            //设置定位参数
            mlocationClient.setLocationOption(mLocationOption);
            // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
            // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
            // 在定位结束后,在合适的生命周期调用onDestroy()方法
            // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
            mlocationClient.startLocation();
        }
    }
    
    /**
     * 停止定位
     */
    @Override
    public void deactivate() {
        mListener = null;
        if (mlocationClient != null) {
            mlocationClient.stopLocation();
            mlocationClient.onDestroy();
        }
        mlocationClient = null;
    }
    

    }

    展开全文
  • 设有两空间线段 Ls,其起点、终点坐标为s0、s1,方向向量u⃗ =s1−s0 Lt,其起点、终点坐标为t0、t1,方向向量v⃗ =t1−t0 ...设最短距离两点分别为sj、tj,则有 sj=s0+sc⋅u⃗ tj=t0+sc⋅v⃗ 其...
  •  #include #include int main() { float a,b,c,d,X; while(scanf("%f %f %f %f",&a,&b,&c,&d)!=EOF) { X=sqrt((a-c)*(a-c)+(b-d)*(b-d)); printf("%.2f\n",X); } return 0; }
  • python计算个地址之间的距离方法

    千次阅读 2021-02-11 04:05:16
    r * 1000 最终结果如下,个地方之间的距离约18公里 c * r * 1000 Out[58]: 18397.59615786144 以上这篇python计算个地址之间的距离方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多...
  • js根据经纬度计算两点距离

    千次阅读 2017-02-20 16:16:10
    公式:两点间距离 = [ (A点经度 - B点经度)^2 + (A点纬度 - B点纬度)^2 ] ^ (1/2) = [ (11695400 - 11695300)^2 + (3995400 - 3995300)^2 ] ^(1/2) =(10000+10000) ^ (1/2) =141米 公式说明:加法 + ,减法 - ...
  • 根据两点的经纬度求方位角和距离

    千次阅读 2017-11-13 15:48:05
    最近自己做的一个小东西要用到经纬度方面的计算,查遍中文网页见到的要么基本上是一帮惜字如金装大爷的“砖家”,要么就是像贴膏药一样,啪,一大堆代码往上一贴,一点...1、已知两点经纬度,求一点相对于另一点方位
  • 地球是一个近乎标准的椭球体,它的赤道半径为6378.140千米,极半径为6356.755千米,平均半径6371.004千米。...如果以0度经线为基准,那么根据地球表面任意两点的经纬度就可以计算出这两点间的地表距离(这里忽略
  • 输入两点坐标(X1,Y1),(X2,Y2),计算并输出两点间距离。输入数据有多组,每组 占一行,由 4 个实数组成,分别表示 x1,y1,x2,y2,数据之间用空格隔开。 注意:结果保留两位小数。 public class Week2 { public ...
  • 假想线),在地球中腰画一个与地轴垂直的大圆圈,使圈上的每一点都和南北两极的距离相等,这个圆圈 就叫作“赤道”。在赤道的南北两边,画出许多和赤道平行的圆圈,就是“纬圈”;构成这些圆圈的线段, 叫做纬线。...
  • 距离最近的他们之间的距离。 分治法: 将一个大问题缩减到一定的规模变成若干个相同的小问题一一解决。它与动态规划法类似,都是将问题分而治之,变成若干个能够解决小问题,但是动态规划一般分解问题后...
  • 大家好,我们今天来看一道非常非常经典的算法题——最近对问题。这个问题经常在各种面试当中出现,难度不低,很少有人能答上来。说实话,我也被问过,因为毫无准备,所以也没有答上来。是的,这道题...
  • 欧式距离计算公式

    万次阅读 多人点赞 2019-06-26 15:06:02
    欧式距离也称欧几里得距离,是最常见的距离度量,衡量的是多维空间中两个点之间的绝对距离。 也可以理解为:m维空间中两个点之间...在二维和三维空间中的欧氏距离就是两点之间的实际距离 下面是具体的计算公式 ...
  • NLP点滴——文本相似度,计算文本距离

    万次阅读 多人点赞 2017-12-06 16:51:49
    在自然语言处理过程中,经常会涉及到如何度量个文本之间的相似性,我们都知道文本是一种高维的语义空间,如何对其进行抽象分解,从而能够站在数学角度去量化其相似性。而有了文本之间相似性的度量方式,我们便可以...
  • a=Lat1 – Lat2 为两点纬度之差 b=Lung1 * -Lung2 为两点经度之差; 6378.137为地球半径,单位为千米; 计算出来的结果单位为千米。 * 通过经纬度获取距离(单位:千米) * @param lat1 * @param lng1...
  • 问题描述:给定平面上N个的坐标,找出距离最近的。 这是编程之美2.11的一道题目,从昨天到现在就一直在设法解决它;如果用常规的解法,只需要将N个两两计算距离,然后找出最小距离就可以了;但是...
  • 求空间条直线之间的距离

    万次阅读 2017-07-06 09:58:05
    最近老板让写一段空间匹配的代码, 其中涉及到求空间直线之间的距离,写起来满费劲的, 这里做一个记录。 2. 处理思路 空间直线之间的位置关系主要可以分为: 重合, 平行, 相交, 异面。 2.1...
  • 欧氏距离和马氏距离简介

    千次阅读 2020-06-19 06:47:04
    在数学中,欧几里得距离或欧几里得度量是欧几里得空间中两点间“普通”(即直线)距离。欧几里得度量(euclidean metric)(也称欧氏距离)是一个通常采用的距离定义,指在m维空间中两个点之间的真实距离,或者向量...
  • 文章目录欧式距离闵可夫斯基距离马氏距离...曼哈顿距离就是模的和,比如在二维空间,就是两点的差的绝对值之和。 马氏距离 这里开始复杂一点了,扯到了概率分布,即开始不再只是简单考虑这两个向量本身,而是把他们
  • 知识都是环环相扣的, 在阅读这编文章之前, 要求懂个知识 1. 会求到线段的最短距离 传送门 2. 会判断与线段位置关系 传送门 如果上面个知识都懂, 那么就进入正题了 给出点A1、A2的坐标, 构成线段...
  • #include &lt;stdio.h&gt; #include &lt;math.h&gt; int main(){ double x1,y1,x2,y2,dx,dy; printf("请输入第一个座标:/n"); scanf("%lf %lf",&amp;x1,&...
  • 对于真正的业务上的位置,这远远不够,后来谷歌提供一种计算公式,可以很快的计算出个坐标之间的距离,这在一定程度上帮助我们快速的计算出距离,感觉很不错,将代码分享给有需要的同学。 以
  • 计算个经纬度距离(c++)

    千次阅读 2012-05-24 09:48:47
     通过的经纬度计算距离 关键词: gis  从google maps的脚本里扒了段代码,没准啥时会用上。大家一块看看是怎么算的。 private const double EARTH_RADIUS = 6378.137;  private static double ...
  • 我们在做图像拼接时,最重要的一步就是关于特征匹配的问题,我们常用到的特征检测方法有SIFT,SURF以及ORB等,对于特征匹配我们有Bruteforce方法,Flannbesed方法,这些方法处理完之后,或许特征匹配效果还是...
  • 求二叉树中任意结点的距离

    万次阅读 2013-10-04 13:49:34
    首先回顾一下:如何求二叉树中两结点的最长距离,即两点之间边数。 分析:距离和深度之间存在必然联系。如果已知最长距离的两结点的最低公共根节点r,那么我们求r的左右子树深度相加即最长距离求出。如下图所示: ...
  • 现在我们知道这n个的坐标,要求找出这n个当中距离最近的的间距。 番外: 不知为何我第一时间想到的是距离最近的,那他们起码是所有点中x最近,或者y最近,不可能x和y都不是最近的但是他们距离最近...
  • js 根据经纬度计算两地之间的距离

    千次阅读 2020-07-31 14:57:57
    注意:是根据两地之间的经纬度来计算他们距离。 下面直接上代码: space(lat1, lng1, lat2, lng2) { console.log(lat1, lng1, lat2, lng2) var radLat1 = lat1 * Math.PI / 180.0; var radLat2 = lat2 * ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,656
精华内容 30,662
关键字:

他们是两点间的距离