oj-分治法解最近对问题-java

最新推荐文章于 2022-09-14 13:22:53 发布
最新推荐文章于 2022-09-14 13:22:53 发布
阅读量505 收藏
点赞数
分类专栏： 算法
原文链接：https://github.com/njuselw/AdvancedAlgorithm
版权

Description

最近对问题：使用分治算法解决最近对问题。

Input

第一行为测试用例个数。后面每一行表示一个用例，一个用例为一些平面上点的集合，点与点之间用逗号隔开，一个点的两个坐标用空格隔开。坐标值都是正数。

Output

对每一个用例输出两个距离最近的点（坐标使用空格隔开），用逗号隔开，先按照第一个坐标大小排列，再按照第二个坐标大小排列。如果有多个解，则按照每个解的第一个点的坐标排序，连续输出多个解，用逗号隔开。

Sample Input 1

1
1 1,2 2,3 3,4 4,5 5,1.5 1.5

Sample Output 1

1 1,1.5 1.5,1.5 1.5,2 2

代码

仅仅微调了大佬的代码

package org.alphacat.first;

import java.util.*;

public class ClosestPair {

    static class Point implements Comparable<Point> {
        private final String x;
        private final String y;

        public Point() {
            this.x = "0";
            this.y = "0";
        }

        public Point(String x, String y) {
            this.x = x;
            this.y = y;
        }

        public double getX() {
            return Double.parseDouble(x);
        }

        public double getY() {
            return Double.parseDouble(y);
        }

        @Override
        public String toString() {
            return this.x + " " + this.y;
        }

        @Override
        public int compareTo(Point o) {
            if (this.getX() < o.getX()) {
                return -1;
            } else if (this.getX() > o.getX()) {
                return 1;
            } else {
                if (this.getY() < o.getY()) {
                    return -1;
                } else if (this.getY() > o.getY()) {
                    return 1;
                }
            }
            return 0;
        }
    }

    public static double distance(Point p1, Point p2) {
        return Math.sqrt(Math.pow(p1.getX() - p2.getX(), 2) + Math.pow(p1.getY() - p2.getY(), 2));
    }

    //通过分治法获取最近点对集合
    public static List<Point[]> getNearest(Point[] points, int l, int h) {
        //若只有一个点，则不存在最近点对的情况
        if (l == h) {
            return new ArrayList<>();
        }
        //若只有两个点，则它们就是最近点
        if (l + 1 == h) {
            Point[] nearest = new Point[]{points[l], points[h]};
            List<Point[]> res = new ArrayList<>();
            res.add(nearest);
            return res;
        }

        //不止两个点的情况下，划分左右区间，分别取左右区间的最近点对集合
        int mid = l + ((h - l) >> 1);
        List<Point[]> leftNearest = getNearest(points, l, mid);
        List<Point[]> rightNearest = getNearest(points, mid + 1, h);

        double leftMinDistance = getMinDistance(leftNearest);
        double rightMinDistance = getMinDistance(rightNearest);

        //比较左右区间的最近点距离，更新当前区间的最近点距离以及最近点集合
        double minDistance = 0.0;
        List<Point[]> nearest = new ArrayList<>();
        if (leftMinDistance < rightMinDistance) {
            minDistance = leftMinDistance;
            nearest.addAll(leftNearest);
        } else if (leftMinDistance > rightMinDistance) {
            minDistance = rightMinDistance;
            nearest.addAll(rightNearest);
        } else {
            minDistance = leftMinDistance;
            nearest.addAll(leftNearest);
            nearest.addAll(rightNearest);
        }

        //处理最近点对一个点在左区间，另一个点在右区间的情况
        //在左区间检索到中间线距离<= minDistance的点，在右区间检索到中间线距离>= minDistance的点
        //记录检索到的点的索引
        List<Integer> leftIndex = new ArrayList<>();
        List<Integer> rightIndex = new ArrayList<>();
        for (int i = mid; i >= 0; i--) {
            if (points[mid].getX() - points[i].getX() <= minDistance) {
                leftIndex.add(i);
            } else {
                break;
            }
        }
        for (int i = mid + 1; i <= h; i++) {
            if (points[i].getX() - points[mid].getX() <= minDistance) {
                rightIndex.add(i);
            } else {
                break;
            }
        }

        for (int i = 0; i < leftIndex.size(); i++) {
            for (int j = 0; j < rightIndex.size(); j++) {
                Point leftPoint = points[leftIndex.get(i)];
                Point rightPoint = points[rightIndex.get(j)];
                //若两个点在y轴方向上的距离> minDistance，则跳过距离计算
                if (Math.abs(leftPoint.getY() - rightPoint.getY()) > minDistance) {
                    continue;
                }
                double tempDistance = distance(leftPoint, rightPoint);
                if (tempDistance < minDistance) {
                    //若距离小于当前最小距离，更新minDistance，并删除原有最近点对集合，将该点对插入
                    minDistance = tempDistance;
                    nearest = new ArrayList<>();
                    nearest.add(new Point[]{leftPoint, rightPoint});
                } else if (tempDistance == minDistance) {
                    //若距离等于当前最小距离，将点对插入最近点对集合
                    nearest.add(new Point[]{leftPoint, rightPoint});
                }
            }
        }
        return nearest;
    }

    private static double getMinDistance(List<Point[]> list) {
        if (list.size() == 0) {
            return Double.MAX_VALUE;
        }

        //取哪个点都一样，不妨取第一对点
        Point[] points = list.get(0);
        return distance(points[0], points[1]);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = Integer.parseInt(scanner.nextLine());
        for (int i = 0; i < t; i++) {
            String pointsString = scanner.nextLine();
            String[] pointsStrings = pointsString.split(",");
            Point[] points = new Point[pointsStrings.length];
            for (int j = 0; j < points.length; j++) {
                String[] point_str = pointsStrings[j].split(" ");
                points[j] = new Point(point_str[0], point_str[1]);
            }
            initialPoints(points);
            List<Point[]> nearest = getNearest(points, 0, points.length - 1);
            print(nearest);
        }


    }

    private static void initialPoints(Point[] points) {
        Arrays.sort(points, (o1, o2) -> {
            if (o1.getX() < o2.getX()) {
                return -1;
            } else if (o1.getX() > o2.getX()) {
                return 1;
            } else {
                if (o1.getY() < o2.getY()) {
                    return -1;
                } else if (o1.getY() > o2.getY()) {
                    return 1;
                }
            }
            return 0;  //按x轴坐标进行排序，方便后续进行分治处理
        });
    }

    private static void print(List<Point[]> nearest) {
        //将结果按第一个点x坐标进行排序
        nearest.sort((o1, o2) -> {
            if (o1[0].getX() < o2[0].getX()) {
                return -1;
            } else if (o1[0].getX() > o2[0].getX()) {
                return 1;
            }
            return 0;
        });
        for (int j = 0; j < nearest.size() - 1; j++) {
            String line = nearest.get(j)[0] + "," + nearest.get(j)[1] + ",";
            System.out.print(line);
        }
        String line = nearest.get(nearest.size() - 1)[0] + "," + nearest.get(nearest.size() - 1)[1];
        System.out.println(line);
    }
}

原代码地址

njuselw/AdvancedAlgorithm

class Point implements Comparable<Point>{
    private final String x;
    private final String y;

    public Point() {
        this.x = "0";
        this.y = "0";
    }

    public Point(String x, String y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return Integer.parseInt(x);
    }

    public int getY() {
        return Integer.parseInt(y);
    }

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

    @Override
    public int compareTo(Point o) {
        if (this.getX() < o.getX()) {
            return -1;
        } else if (this.getX() > o.getX()) {
            return 1;
        } else {
            if (this.getY() < o.getY()) {
                return -1;
            } else if (this.getY() > o.getY()) {
                return 1;
            }
        }
        return 0;
    }
}

public class Problem0124 {
    /*
    分治法解最近对问题
    Description
    最近对问题：使用分治算法解决最近对问题。

    Input
    第一行为测试用例个数。后面每一行表示一个用例，一个用例为一些平面上点的集合，点与点之间用逗号隔开，一个点的两个坐标用空格隔开。坐标值都是正数。

    Output
    对每一个用例输出两个距离最近的点（坐标使用空格隔开），用逗号隔开，先按照第一个坐标大小排列，再按照第二个坐标大小排列。
    如果有多个解，则按照每个解的第一个点的坐标排序，连续输出多个解，用逗号隔开。
     */

    //获取两个点之间的欧氏距离
    public static double distance(Point p1, Point p2) {
        return Math.sqrt(Math.pow(p1.getX() - p2.getX(), 2) + Math.pow(p1.getY() - p2.getY(), 2));
    }

    //通过分治法获取最近点对集合
    public static List<Point[]> getNearest(Point[] points, int left, int right) {
        //若只有一个点，则不存在最近点对的情况
        if (left == right) return new ArrayList<>();
        //若只有两个点，则它们就是最近点
        if (right == left + 1) {
            Point[] nearest = new Point[]{points[left], points[right]};
            List<Point[]> res = new ArrayList<>();
            res.add(nearest);
            return res;
        }
        //不止两个点的情况下，划分左右区间，分别取左右区间的最近点对集合
        int mid = (left + right) / 2;
        List<Point[]> leftNearest = getNearest(points, left, mid);
        List<Point[]> rightNearest = getNearest(points, mid + 1, right);
        double leftMinDistance = leftNearest.size() == 0 ? Double.MAX_VALUE : distance(leftNearest.get(0)[0], leftNearest.get(0)[1]);
        double rightMinDistance = rightNearest.size() == 0 ? Double.MAX_VALUE : distance(rightNearest.get(0)[0], rightNearest.get(0)[1]);
        //比较左右区间的最近点距离，更新当前区间的最近点距离以及最近点集合
        double minDistance = 0.0;
        List<Point[]> nearest = new ArrayList<>();
        if (leftMinDistance < rightMinDistance) {
            minDistance = leftMinDistance;
            nearest.addAll(leftNearest);
        } else if (leftMinDistance > rightMinDistance) {
            minDistance = rightMinDistance;
            nearest.addAll(rightNearest);
        } else {
            minDistance = leftMinDistance;
            nearest.addAll(leftNearest);
            nearest.addAll(rightNearest);
        }
        //处理最近点对一个点在左区间，另一个点在右区间的情况
        //在左区间检索到中间线距离<= minDistance的点，在右区间检索到中间线距离>= minDistance的点
        //记录检索到的点的索引
        List<Integer> leftIndex = new ArrayList<>();
        List<Integer> rightIndex = new ArrayList<>();
        for (int i = mid; i >= 0; i--) {
            if (points[mid].getX() - points[i].getX() <= minDistance) {
                leftIndex.add(i);
            } else {
                break;
            }
        }
        for (int i = mid + 1; i <= right; i++) {
            if (points[i].getX() - points[mid].getX() <= minDistance) {
                rightIndex.add(i);
            } else {
                break;
            }
        }
        for (int i = 0; i < leftIndex.size(); i++) {
            for (int j = 0; j < rightIndex.size(); j++) {
                Point leftPoint = points[leftIndex.get(i)];
                Point rightPoint = points[rightIndex.get(j)];
                //若两个点在y轴方向上的距离> minDistance，则跳过距离计算
                if (Math.abs(leftPoint.getY() - rightPoint.getY()) > minDistance) {
                    continue;
                }
                double tempDistance = distance(leftPoint, rightPoint);
                if (tempDistance < minDistance) {
                    //若距离小于当前最小距离，更新minDistance，并删除原有最近点对集合，将该点对插入
                    minDistance = tempDistance;
                    nearest = new ArrayList<>();
                    nearest.add(new Point[]{leftPoint, rightPoint});
                } else if (tempDistance == minDistance) {
                    //若距离等于当前最小距离，将点对插入最近点对集合
                    nearest.add(new Point[]{leftPoint, rightPoint});
                }
            }
        }
        return nearest;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = Integer.parseInt(scanner.nextLine());
        for (int i = 0; i < T; i++) {
            String[] points_str = scanner.nextLine().split(",");
            Point[] points = new Point[points_str.length];
            for (int j = 0; j < points.length; j++) {
                String[] point_str = points_str[j].split(" ");
                points[j] = new Point(point_str[0], point_str[1]);
            }
            Arrays.sort(points, new Comparator<Point>() {
                @Override
                public int compare(Point o1, Point o2) {
                    if (o1.getX() < o2.getX()) {
                        return -1;
                    } else if (o1.getX() > o2.getX()) {
                        return 1;
                    } else {
                        if (o1.getY() < o2.getY()) {
                            return -1;
                        } else if (o1.getY() > o2.getY()) {
                            return 1;
                        }
                    }
                    return 0;  //按x轴坐标进行排序，方便后续进行分治处理
                }
            });
            List<Point[]> nearest = getNearest(points, 0, points.length - 1);
            //将结果按第一个点x坐标进行排序
            nearest.sort(new Comparator<Point[]>() {
                @Override
                public int compare(Point[] o1, Point[] o2) {
                    if (o1[0].getX() < o2[0].getX()) {
                        return -1;
                    } else if (o1[0].getX() > o2[0].getX()) {
                        return 1;
                    }
                    return 0;
                }
            });
            for (int j = 0; j < nearest.size() - 1; j++) {
                System.out.print(nearest.get(j)[0] + "," + nearest.get(j)[1] + ",");
            }
            System.out.println(nearest.get(nearest.size() - 1)[0] + "," + nearest.get(nearest.size() - 1)[1]);
        }
    }
}
什么你竟然不会敲代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode-OJ:破解 Leetcode 问题
06-08
问题（来源： ) # 标题困难解决方案1 :star: :star: 2 :star: :star: 3 :star: :star: 5 :star: :star: 7 :star: 8 :star: 9 :star: :unlocked: 12 整数转罗马 :star: :star: :unlocked: 13 罗马到整数 :star: :...
杭电OJ——1007 Quoit Design(最近点对问题)
热门推荐
李树花开，风中摇曳
06-24 1万+
Quoit Design Problem Description Have you ever played quoit in a playground? Quoit is a game in which flat rings are pitched at some toys, with all the toys encircled awarded. In the field of
794: 最近对问题
Mr_atopos的博客
05-15 481
794: 最近对问题 题目描述 设p1=(x1, y1), p2=(x2, y2), …, pn=(xn, yn)是平面上n个点构成的集合S，设计算法找出集合S中距离最近的点对。 输入 多组测试数据，第一行为测试数据组数n（0<n≤100），每组测试数据由两个部分构成，第一部分为一个点的个数m（0<m≤1000），紧接着是m行，每行为一个点的坐标x和y，用空格隔开，（0<x，y≤100000） 输出 每组测试数据输出一行，为该组数据最近点的距离，保留4为小数。 样例输入 2
SWUST OJ#794 最近对问题
qq_62102968的博客
09-14 2165
题目描述设p1=(x1, y1), p2=(x2, y2), …, pn=(xn, yn)是平面上n个点构成的集合S，设计算法找出集合S中距离最近的点对。输入多组测试数据，第一行为测试数据组数n（0
分治法求最近点对（ java ）
weixin_44272266的博客
04-04 2349
分治法求最近点对问题 下面是我的代码，还有些地方需要改进，但是一直有空指针问题（代码中已标出），主要在调用静态函数进行递归和求两点间距离时出现错误，请大佬指正！ 总共30个点，a数组是对x的排序，b数组是对y的排序 import java.util.Arrays; import java.util.Comparator; public class MinDistance { static ...
最接近点对问题一维Java算法_【分治法】最接近点对问题（转）
weixin_36431145的博客
02-26 1559
转自：http://blog.csdn.net/liufeng_king/article/details/8484284问题场景：在应用中，常用诸如点、圆等简单的几何对象代表现实世界中的实体。在涉及这些几何对象的问题中，常需要了解其邻域中其他几何对象的信息。例如，在空中交通控制问题中，若将飞机作为空间中移动的一个点来看待，则具有最大碰撞危险的2架飞机，就是这个空间中最接近的一对点。这类问题是计算几...
-OJ-:在线评委（java）
04-06
OJ刷题自用,算是做个记录吧10.23——leetcode每日一题
leetcode和oj-leetcode:LeetcodeOJ问题Java代码
06-30
leetcode 和 oj leetcode Leetcode OJ Question Java 代码问题：WildCardMatching.java 因 TLE 未能通过大法官。 尝试了DP和递归。 需要想出一个迭代的方法。
leetcode和oj-Leetcode:我对LeetCode问题的Java解决方案
06-30
leetcode 和 oj LeetCode 解决方案：Java 我会继续在这里发布我的解决方案，希望有详细的解释和不同的方法。 力扣 OJ：
A2OJ-Ladder:A2OJ梯形图复选框
03-19
A2OJ-梯子选框ID姓名问题计数完毕11 100完毕12 100完毕13 100完毕14 100完毕15 100完毕16 100完毕17 100完毕18岁 100完毕19 100完毕20 100完毕21岁 100完毕22 200完毕23 200完毕24 200完毕25 200完毕26 200完毕27 ...
【分治法】最接近点对问题——Java 实现
飞龙的博客
05-28 4832
问题描述：        给定平面上n个点，找其中的一对点，使得在n个点组成的所有点对中，该点对间的距离最小。        注： a、严格地讲，最接近点对可能多余1对，为简单起见，只找其中的1对作为问题的解。 b、一个简单的算法是——只要将每一个点与其他 n-1 个点的距离算出，找到达到最小距离的2个点即可。然而，这样做效率太低，需要O(n^2)的计算时间。
分治法——最近对问题
qq_53226437的博客
03-24 3436
最近对问题 令P为笛卡儿平面上n>1个点构成的集合。简单起见，假设集合中的每个点都不一样。我们还假设这些点是按照其x轴坐标升序排列的。（如果不是这样，可以事先用类似合并排序这样的高效算法对其排序。)为了更加方便，我们还可以按照点的y轴坐标在另一个列表中进行升序排列，并将这个列表示为Q。 当2≤n≤3时，问题就可以通过蛮力算法求解。当n>3时，可以利用点集在x轴方向上的中位数m,在该处作一条垂线，将点集分成大小分别为⌈n/2⌉和⌊n/2⌋\lceil n/2 \rceil 和\lfloor n/2
分治法解决最近对问题
weixin_50843252的博客
11-25 196
分治法解决最近对问题
分治法--一维最接近点对问题
weixin_44721537的博客
02-01 1601
1）问题描述 2）基本思路 3）代码实现 package hello; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Scanner; public class fuck { public static void main(String...
最邻近点对问题(Closest-Pair Problem)：一维的分治解法详解
Carl_Rabbit的博客
06-18 3016
低维时，最邻近点对问题可以利用分治求解。但是网络上相关资料良莠不齐，对于3维甚至难有有价值的参考。最近恰巧梳理了123维最邻近点对问题的相关知识，故在此分享。这是该系列的第一篇，介绍一维情况的分治解法。
分治法-最接近点对问题
HeinSven的博客
12-30 1万+
背景： 计算机应用中经常采用点、圆等简单的几何对象表示物理实体，常需要了解其邻域中其他几何对象的信息 例如：在空中交通控制中，若将飞机作为空间中的一个点来处理，则具有最大碰撞危险的两架飞机所处的点对，就是这个空间中距离最接近的一对点。 这类问题是计算几何学中研究的基本问题之一。 我们着重考虑平面上的最接近点对问题。 最接近点对问题： 给定平面上的n个点，找出其中的一对点，使得在n个点组成...
一维最接近点对的分治解法 .
dianjie1005的博客
01-18 224
import java.util.Arrays; import java.util.Scanner; /* * 用分治法输出一个一维数组中的n个不同实数间距离最小的两个实数。输入：实数数组X, 实数个数n, 输出: 距离最小的两个实数. * */ public class Divided { private static float[] X; priva...
分治法实现最近对问题（JAVA）
落叶为了归根
10-10 2644
  假设所有点都在集合S中。   1.用S中个点坐标的中位数作为分割点，则会得到一个平衡的分割点m，使得子集S1,S2中有个数大致相同的点。   2.选取垂直线x=c（中位线）来作为分割线。   3.递归地求出S1和S2中的最近对，假设D1、D2是最近距离。   4.距离最近的点，可能在线的俩边，所以，我们需要在以x=c为对称的、宽度为2D的（D为D1、D2中的最小值）的垂直带中。   ...
java最近点对分治算法_分治法-最近点对问题
weixin_27956639的博客
02-25 982
设p1=(x1,y1),p2=(x2,y2)...pn=(xn,yn)是平面n上n个点构成的集合S，最近对问你就是找出集合S中距离最近的点对。分支策略：(1)划分：将集合S分成两个子集S1和S2，根据平衡子问题原则，每个子集中大约有n/2个点，设集合S的最近点对是pi和pj(1<=i,j<=n)则有以下三种情况 1.pi∈S1,pj∈S12.pi∈S1,pj∈S23.pi∈S2, pj...
自底向上的哈夫曼编码(oj-1804)
最新发布
06-08
自底向上的哈夫曼编码是一种构建哈夫曼树的方法，它与传统的从上往下构建哈夫曼树的方法不同。下面是自底向上的哈夫曼编码的步骤： 1. 对于给定的n个权值，将它们看作n棵只有一个节点的树，即森林F={T1,T2,...,Tn}...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值