You are given N points in the xy-plane. You have a circle of radius one and move it on the xy-plane, so as to enclose as many of the points as possible. Find how many points can be simultaneously enclosed at the maximum. A point is considered enclosed by a circle when it is inside or on the circle.
Fig 1. Circle and Points
Input
The input consists of a series of data sets, followed by a single line only containing a single character '0', which indicates the end of the input. Each data set begins with a line containing an integer N, which indicates the number of points in the data set. It is followed by N lines describing the coordinates of the points. Each of the N lines has two decimal fractions X and Y, describing the x- and y-coordinates of a point, respectively. They are given with five digits after the decimal point.
You may assume 1 <= N <= 300, 0.0 <= X <= 10.0, and 0.0 <= Y <= 10.0. No two points are closer than 0.0001. No two points in a data set are approximately at a distance of 2.0. More precisely, for any two points in a data set, the distance d between the two never satisfies 1.9999 <= d <= 2.0001. Finally, no three points in a data set are simultaneously very close to a single circle of radius one. More precisely, let P1, P2, and P3 be any three points in a data set, and d1, d2, and d3 the distances from an arbitrarily selected point in the xy-plane to each of them respectively. Then it never simultaneously holds that 0.9999 <= di <= 1.0001 (i = 1, 2, 3).
Output
For each data set, print a single line containing the maximum number of points in the data set that can be simultaneously enclosed by a circle of radius one. No other characters including leading and trailing spaces should be printed.
Sample
| Input | Output |
|---|---|
3 6.47634 7.69628 5.16828 4.79915 6.69533 6.20378 6 7.15296 4.08328 6.50827 2.69466 5.91219 3.86661 5.29853 4.16097 6.10838 3.46039 6.34060 2.41599 8 7.90650 4.01746 4.10998 4.18354 4.67289 4.01887 6.33885 4.28388 4.98106 3.82728 5.12379 5.16473 7.84664 4.67693 4.02776 3.87990 20 6.65128 5.47490 6.42743 6.26189 6.35864 4.61611 6.59020 4.54228 4.43967 5.70059 4.38226 5.70536 5.50755 6.18163 7.41971 6.13668 6.71936 3.04496 5.61832 4.23857 5.99424 4.29328 5.60961 4.32998 6.82242 5.79683 5.44693 3.82724 6.70906 3.65736 7.89087 5.68000 6.23300 4.59530 5.92401 4.92329 6.24168 3.81389 6.22671 3.62210 0 | 2 5 5 11 |
题意： 给出平面上n个点的坐标，询问一个单位圆最多能覆盖多少个点。
分析： 可以发现能覆盖最多点的单位圆上一定最少有两个点，因为若圆上没有两点，那么总可以通过平移或旋转得到一个过至少两点且覆盖更多点的圆，如下图：
之后就可以枚举平面上任意两点，以这两点连线为弦长，这样可以得到两个圆，对于枚举到的每个圆再统计一下有多少点，记录覆盖最大点数，最终复杂度为O(n^3)。
但是这道题目最多有300个点，时间上卡的还是挺紧的，O(n^3)的算法只能擦着边过，如果每条弦都产生两个圆会TLE，实际上一条弦对应的是一个圆，另一侧的圆会在处理其它弦的时候包括进去。
如图所示，一条弦产生了两个圆，如果只取右侧的圆，可以对左侧圆包围点作凸包。
凸包用黄线标示，凸包的外接圆用绿圆标示，显然绿圆总是小于左侧蓝圆。
以凸包上任意边为弦将绿圆放大至单位圆，这时可以得到一个包围更多点的单位圆。这样对于每条弦就只需要处理一个圆，运算速度会快上许多。
具体代码如下：
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
using namespace std;
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 1010;
//`Compares a double to zero`
int sgn(double x)
{
if(fabs(x) < eps)return 0;
if(x < 0)return -1;
else return 1;
}
//square of a double
inline double sqr(double x){return x*x;}
struct Point
{
double x, y;
Point(){}
Point(double _x,double _y){x = _x, y = _y;}
void input(){scanf("%lf%lf",&x,&y);}
void output(){printf("%.2f %.2f\n",x,y);}
bool operator == (Point b)const{return sgn(x-b.x) == 0 && sgn(y-b.y) == 0;}
//第一关键字为x，第二关键字为y
bool operator < (Point b)const{return sgn(x-b.x)== 0?sgn(y-b.y)<0:x<b.x;}
Point operator -(const Point &b)const{return Point(x-b.x,y-b.y);}
//叉积
double operator ^(const Point &b)const{return x*b.y - y*b.x;}
//点积
double operator *(const Point &b)const{return x*b.x + y*b.y;}
//返回长度的平方
double len2(){return x*x + y*y;}
//返回两点的距离
double distance(Point p){return sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));}
Point operator +(const Point &b)const{return Point(x+b.x,y+b.y);}
Point operator *(const double &k)const{return Point(x*k,y*k);}
Point operator /(const double &k)const{return Point(x/k,y/k);}
//`计算pa 和 pb 的夹角`
//`就是求这个点看a,b 所成的夹角`
//`测试 LightOJ1203`
double rad(Point a,Point b)
{
Point p = *this;
return fabs(atan2( fabs((a-p)^(b-p)),(a-p)*(b-p) ));
}
//`化为长度为r的向量`
Point trunc(double r)
{
double l = this->distance(Point(0.0, 0.0));
if(!sgn(l))return *this;
r /= l;
return Point(x*r,y*r);
}
//`逆时针旋转90度`
Point rotleft(){return Point(-y,x);}
//`顺时针旋转90度`
Point rotright(){return Point(y,-x);}
//`绕着p点逆时针旋转angle`
Point rotate(Point p,double angle)
{
Point v = (*this) - p;
double c = cos(angle), s = sin(angle);
return Point(p.x + v.x*c - v.y*s,p.y + v.x*s + v.y*c);
}
};
//圆
struct circle{
Point p;//圆心
double r;//半径
circle(){}
circle(Point _p,double _r){
p = _p;
r = _r;
}
circle(double x,double y,double _r){
p = Point(x,y);
r = _r;
}
//输入
void input(){
p.input();
scanf("%lf",&r);
}
//输出
void output(){
printf("%.2lf %.2lf %.2lf\n",p.x,p.y,r);
}
bool operator == (circle v){
return (p==v.p) && sgn(r-v.r)==0;
}
bool operator < (circle v)const{
return ((p<v.p)||((p==v.p)&&sgn(r-v.r)<0));
}
//`点和圆的关系`
//`0 圆外`
//`1 圆上`
//`2 圆内`
int relation(Point b){
double dst = b.distance(p);
if(sgn(dst-r) < 0)return 2;
else if(sgn(dst-r)==0)return 1;
return 0;
}
};
Point p[305];
int n;
signed main()
{
while(~scanf("%d", &n))
{
if(n == 0) break;
for(int i = 1; i <= n; i++)
p[i].input();
int ans = 1;//圆内最大点数
for(int i = 1; i <= n; i++)
for(int j = i+1; j <= n; j++)
{
//弦长不能大于2
double len2 = (p[i].x-p[j].x)*(p[i].x-p[j].x)+(p[i].y-p[j].y)*(p[i].y-p[j].y);
if(sgn(len2-4.0) > 0) continue;
double d = sqrt(1.0-len2/4);
circle c;
c.p = (p[i]+p[j])/2+(p[j]-p[i]).rotleft().trunc(d);
c.r = 1.0;
int num = 0;
for(int k = 1; k <= n; k++)
{
if(c.relation(p[k]))
num++;
}
ans = max(ans, num);
}
printf("%d\n", ans);
}
return 0;
}
1181
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
