HDOJ 1007 Quoit Design 分治 贪心

🍑 OJ专栏

---

---

🍑 HDOJ 1007 Quoit Design

输入

2
0 0
1 1
2
1 1
1 1
3
-1.5 0
0 0
0 1.5
0

输出

0.71
0.00
0.75

---

🤠 题意

圆环套玩具，要求一个环顶多能套一个玩具（边上的不算），求环的最大半径 即：求一堆点中距离最近的两点的距离，此距离就是最大直径，再 ➗2 即可

🍑 分治 + 贪心

分区间求最小值（分治），合并去掉不可能的点（剪枝），对合法的点进行 y值排序
从小到大计算距离（贪心）

👨‍🏫 参考题解

🍑 AC代码 O(n logn)

import java.util.*;

public class Main
{
	static int N = 100010;
	static Node[] tmp = new Node[N];
	static Node[] ns = new Node[N];

//	点类
	static class Node
	{
		double x;
		double y;

		public Node(double x, double y)
		{
			super();
			this.x = x;
			this.y = y;
		}
	}

//	求两点之间的欧几里得距离
	static double dis(Node n1, Node n2)
	{
		return Math.sqrt((n1.x - n2.x) * (n1.x - n2.x) + (n1.y - n2.y) * (n1.y - n2.y));
	}

//	返回 l~r 区间内的最小距离
	static double find(int l, int r)
	{
//		此函数至少需要两个点，一个点不合法无法比较
//		区间只剩两点,返回结果
		if (l + 1 == r)
			return dis(ns[l], ns[r]);
//		区间只剩三点,无法继续分下去了,直接返回结果
		if (l + 2 == r)
			return min(dis(ns[l], ns[l + 1]), dis(ns[l + 1], ns[r]), dis(ns[l], ns[r]));

//		寻找左右区间的最小距离
		int mid = (l + r) >> 1;
		double d = Math.min(find(l, mid), find(mid + 1, r));// d 是左右 区间最小值 的 较小值

//		合并左右区间的最小距离(关键优化)
//		各选一个点进行比较,只需要考虑 x 距离小于 d 的,也就是与中点 x 轴上的距离 <= d 的所有点
//		即 x 值落在 [midx-d, midx+d] 区间内的点
		int cnt = 0;
		for (int i = l; i <= r; i++)// 枚举 区间的所有点 o(n)
//			if (ns[i].x >= ns[mid].x - d && ns[i].x <= ns[mid].x + d) // AC
			if (ns[i].x >= ns[mid + 1].x - d && ns[i].x <= ns[mid + 1].x + d)// AC
				tmp[cnt++] = ns[i];

//		对筛选出来的点按 y 值进行升序排序
		Arrays.sort(tmp, 0, cnt, (o1, o2) -> new Double(o1.y).compareTo(new Double(o2.y)));
		for (int i = 0; i < cnt; i++)// 枚举点1
			for (int j = i + 1; j < cnt; j++)// 枚举点2
			{
//				点1的y 与 点2的y 差距 >= d直接跳出,后边的都不可能再小了
				if (tmp[j].y - tmp[i].y >= d)
					break;
				d = Math.min(d, dis(tmp[i], tmp[j]));// 计算最小值
			}
		return d;
	}

//	返回参数中的最小值
	private static double min(double d1, double d2, double d3)
	{
		return Math.min(Math.min(d1, d2), d3);
	}

	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext())
		{
			int n = sc.nextInt();
			if (n == 0)
				break;
			for (int i = 0; i < n; i++)
			{
				double x = sc.nextDouble();
				double y = sc.nextDouble();
				ns[i] = new Node(x, y);
			}
//			按照 x 对点进行升序排序
			Arrays.sort(ns, 0, n, (o1, o2) -> new Double(o1.x).compareTo(new Double(o2.x)));
			System.out.printf("%.2f", find(0, n - 1) / 2);
			System.out.println();
		}
	}
}