使用java和分治法写出代码，解决以下问题，设 p1 = ( x1 , y1 ) , p2 = ( x2 , y2 ) , ⋯, pn = ( xn , yn )是平面上 n 个点构成的集合 S ,设计算 法找出集合 S 中距离最近的点对。

这是一个经典的问题，也称为最近点对问题。我们可以使用分治法来解决它。

具体来说，我们可以按照以下步骤实现：

1. 将点按照 x 坐标排序，将其分成左右两部分。
2. 对左右两部分递归地求解最近点对。分别得到左部分的最近点对距离为 d1，右部分的最近点对距离为 d2。
3. 取 d=min(d1,d2)。
4. 找到横跨左右两部分的距离小于 d 的点对中距离最小的一对。

接下来是使用 Java 代码实现：

import java.util.*;

class Point {
    double x, y;
    Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

public class ClosestPair {

    static double dist(Point p1, Point p2) {
        double dx = p1.x - p2.x;
        double dy = p1.y - p2.y;
        return Math.sqrt(dx * dx + dy * dy);
    }

    static double bruteForce(Point[] points, int left, int right) {
        double minDist = Double.POSITIVE_INFINITY;
        for (int i = left; i <= right; i++) {
            for (int j = i + 1; j <= right; j++) {
                double dist = dist(points[i], points[j]);
                if (dist < minDist) {
                    minDist = dist;
                }
            }
        }
        return minDist;
    }

    static double minDistance(Point[] points, int left, int right) {
        if (right - left <= 3) {
            return bruteForce(points, left, right);
        }
        int mid = (left + right) / 2;
        double d1 = minDistance(points, left, mid);
        double d2 = minDistance(points, mid + 1, right);
        double d = Math.min(d1, d2);
        List<Point> strip = new ArrayList<>();
        for (int i = left; i <= right; i++) {
            if (Math.abs(points[i].x - points[mid].x) < d) {
                strip.add(points[i]);
            }
        }
        Collections.sort(strip, new Comparator<Point>() {
            @Override
            public int compare(Point p1, Point p2) {
                return Double.compare(p1.y, p2.y);
            }
        });
        double stripMin = Double.POSITIVE_INFINITY;
        for (int i = 0; i < strip.size(); i++) {
            for (int j = i + 1; j < strip.size(); j++) {
                if (strip.get(j).y - strip.get(i).y >= d) {
                    break;
                }
                double dist = dist(strip.get(i), strip.get(j));
                if (dist < stripMin) {
                    stripMin = dist;
                }
            }
        }
        return Math.min(d, stripMin);
    }

    public static void main(String[] args) {
        Point[] points = new Point[] {
                new Point(2, 3),
                new Point(12, 30),
                new Point(40, 50),
                new Point(5, 1),
                new Point(12, 10),
                new Point(3, 4)
        };
        Arrays.sort(points, new Comparator<Point>() {
            @Override
            public int compare(Point p1, Point p2) {
                return Double.compare(p1.x, p2.x);
            }
        });
        System.out.println(minDistance(points, 0, points.length - 1));
    }
}

在这个实现中，我们首先定义了一个 Point 类，表示平面上的一个点。然后我们定义了一个 dist 方法，用来计算两个点之间的距离。

接着我们实现了两个辅助方法：bruteForce 和 minDistance。其中 bruteForce 方法用来暴力枚举给定范围内的所有点对距离，找到其中的最小值。minDistance 方法是整个算法的核心实现，使用分治法递归地求解最近点对问题。

在 main 方法中，我们定义了一个简单的点集，然后按照 x 坐标排序，并调用 minDistance 方法求解最近点对距离。

注意：这个代码是为了演示分治法如何求解最近点对问题而写的，实际使用时可能需要进行一些优化，比如去掉排序步骤，使用桶排等。