Expm 3_2 寻找最邻近的点对

 

【问题描述】

设p₁=(x₁,y₁), p₂=(x₂,y₂), … , p_n=(x_n,y_n) 是平面上n个点构成的集合S，设计和实现找出集合S中距离最近点对的算法。

　　每一个格子最多只能存在一个点,三行最多存在12个顶点，因此对于上图中的第(i=27)个顶点来说，最多只需要比较第27个顶点与之后的11个顶点，对于i之后或之前的11个顶点之外的顶点j，即|i-j|>=12,i与j之间的距离一定大于d，因为i和j已经相隔了至少两行。两个顶点若相隔大于等于两行或两列，则他们之间的距离一定大于等于d

package org.xiu68.exp.exp3;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Exp3_2 {

    //设p1=(x1,y1), p2=(x2,y2), … , pn=(xn,yn)
    //是平面上n个点构成的集合S，设计和实现找出集合S中距离最近点对的算法。
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i=0;i<20;i++){
            System.out.println("***************************");
            List<Point> pointList=new ArrayList<>();
            for(int j=0;j<50;j++){
                Point p=new Point(new Random().nextInt(100),new Random().nextInt(100));
                pointList.add(p);
            }
            System.out.println(bruteforce(pointList));        //蛮力法
            System.out.println(closestPair(pointList));        //分治法
            
            System.out.println("****************************");
        }
    }

    
    
    //寻找最近点对
    public static double closestPair(List<Point> pointList){
        //对pointList中的点按横坐标和纵坐标进行升序排序
        
        List<Point> sortedListX=new ArrayList<>();    
        List<Point> sortedListY=new ArrayList<>();    
        
        //按横坐标对数组进行升序排序
        pointList.sort((Point a,Point b)->{
            if(a.getX()<b.getX())
                return -1;
            else 
                return 1;
        });
        sortedListX.addAll(pointList);
        
        //按纵坐标对数组进行升序排序
        pointList.sort((Point a,Point b)->{
            if(a.getY()<b.getY())
                return -1;
            else 
                return 1;
        });
        sortedListY.addAll(pointList);
        
/*        for(int i=0;i<pointList.size();i++)
            System.out.println(sortedListX.get(i));
        System.out.println("*********************");
        for(int i=0;i<pointList.size();i++)
            System.out.println(sortedListY.get(i));
        
        System.out.println("*********************");
        System.out.println(divide(sortedListX,sortedListY));*/
        
        return divide(sortedListX,sortedListY);
        
    }
    
    /*
     * 原问题的分解
     * sortedListX:横坐标升序排序的数组
     * sortedListY:纵坐标升序排序的数组
     */
    public static double divide(List<Point> sortedListX,List<Point> sortedListY){
        if(sortedListX.size()==1)        //如果只有一个元素
            return Double.MAX_VALUE;
        else if(sortedListX.size()==2)    //如果只有两个元素
            return dist(sortedListX.get(0),sortedListX.get(1));
        
        else{                            //大于2个元素
            int mid=sortedListX.size()/2;                //在第mid个点处把点分成左右相等的两部分
            double L=sortedListX.get(mid).getX();    //把点分成左右相等的两部分的直线的横坐标，设这条直线为L
            
            //L左边的点的横坐标升序排序的数组
            List<Point> sortedListXL=sortedListX.subList(0, mid);    
            
            //L右边的点的横坐标升序排序的数组
            List<Point> sortedListXR=sortedListX.subList(mid, sortedListX.size());
            
            List<Point> sortedListYL=new ArrayList<>();        //L左边的点的纵坐标升序排序的数组
            List<Point> sortedListYR=new ArrayList<>();        //L右边的点的纵坐标升序排序的数组
            
            //求sortedListYL与sortedListYR
            for(int i=0;i<sortedListY.size();i++){
                Point p=sortedListY.get(i);
                if(sortedListY.get(i).getX()<L){
                    sortedListYL.add(p);
                }else{
                    sortedListYR.add(p);
                }
            }
            
            double dL=divide(sortedListXL,sortedListYL);    //L左边两个点之间的最短距离
            double dR=divide(sortedListXR,sortedListYR);    //L右边两个点之间的最短距离
            
            //比较L左边最短距离、L右边最短距离以及跨越L的顶点对之间的最短距离
            return conquer(sortedListY,L,Math.min(dL, dR));    
        }//else
    }
    
    //子问题解的合并
    public static double conquer(List<Point> sortedListY,double L,double d){
        //求在L-d以及L+d之间的顶点(2d-strip)
        List<Point> inside2DList=new ArrayList<>();
        for(int i=0;i<sortedListY.size();i++){
            Point p=sortedListY.get(i);
            if(p.getX()>L-d || p.getX()<L+d){
                inside2DList.add(p);
            }
        }
        
        //求2d-strip之间顶点对的最短距离、与L左边和右边的最短距离比较，最小者为最终结果
        double minDistance=d;
        for(int i=0;i<inside2DList.size()-1;i++){
            //i只需与i之后的11个顶点比较，i与大于11个顶点之后的顶点的距离一定大于等于d
            for(int j=i+1;j<=i+11 && j<inside2DList.size();j++){
                double temp=dist(inside2DList.get(i),inside2DList.get(j));
                if(temp<minDistance)
                    minDistance=temp;
            }
        }
        return minDistance;
    }
    
    //计算两点之间的距离
    public static double dist(Point a,Point b){
        return Math.sqrt(Math.pow(a.getX()-b.getX(), 2)+Math.pow(a.getY()-b.getY(), 2));
    }
    
    //蛮力法
    public static double bruteforce(List<Point> pointList){
        double minDistance=Double.MAX_VALUE;
        //依次比较每个顶点对
        for(int i=0;i<pointList.size();i++){
            for(int j=i+1;j<pointList.size();j++){
                double temp=dist(pointList.get(i),pointList.get(j));
                if(temp<minDistance)
                    minDistance=temp;
            }
        }
        return minDistance;
    }
}

class Point{
    private double x;        //横坐标
    private double y;        //纵坐标
    
    public Point(int x,int y){
        this.x=x;
        this.y=y;
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public String toString(){
        return x+","+y;
    }
}