poj 1981 Circle and Points(固定半径的圆能覆盖的最多点数)

最新推荐文章于 2021-11-19 20:47:05 发布

原创最新推荐文章于 2021-11-19 20:47:05 发布 · 4.5k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#distance #each #character #integer #input #算法

计算几何专栏收录该内容

67 篇文章

订阅专栏

解决POJ 1981题，探讨如何确定固定半径为1的圆能覆盖平面上n个点的最大数量。文章讨论了O(n^3)的枚举算法和更优的O(n^2 log n)算法，后者通过枚举点和相交弧进行计算，实现覆盖次数最多的弧段确定答案。

Circle and Points

Time Limit: 5000MS		Memory Limit: 30000K
Total Submissions: 5342		Accepted: 1865
Case Time Limit: 2000MS

Description

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

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

Sample Output

Source

Japan 2004 Domestic

题目：http://poj.org/problem?id=198 1

题意：给你一个单位圆，还有平面上的n个点，求这个圆最多能覆盖的点数

分析：这题很容易想到一个O(n^3)的算法，也就是枚举两个距离小于2的点，用它们来固定一个圆，当然对称圆也要算，再枚举所有点，看是不是在这个圆内，当然这题这样就可以水过，不过这并不是最优的。还有一种O(n^2 log n)的算法，这种方法其实也简单，不过我还是没有自己想出来，先枚举一个点，再枚举所有与它距离小于2的点，这样就可以求出相交弧，把所有弧保存下来，并离散化，就能算出覆盖次数最多的一段弧，这个次数也就是答案了，具体看代码吧

O(n^3):

#include<cmath>
#include<cstdio>>
#include<iostream>
#include<algorithm>
using namespace std;
const int mm=333;
const double eps=1e-8;
typedef double diy;
struct point
{
    diy x,y;
    point(){}
    point(diy _x,diy _y):x(_x),y(_y){}
}g[mm];
bool cmp(point P,point Q)
{
    return P.x<Q.x||(P.x==Q.x&&P.y<Q.y);
}
diy SqrDis(point P,point Q)
{
    return (P.x-Q.x)*(P.x-Q.x)+(P.y-Q.y)*(P.y-Q.y);
}
int i,j,n,ans;
int solve(point P,point Q)
{
    point tmp=point((P.x+Q.x)/2,(P.y+Q.y)/2);
    double angle=atan2(P.y-Q.y,P.x-Q.x)+acos(-1.0)/2;
    double len=sqrt(1-SqrDis(P,Q)/4);
    tmp.x+=cos(angle)*len;
    tmp.y+=sin(angle)*len;
    int i,ret=0;
    for(i=0;i<n;++i)
        if(SqrDis(g[i],tmp)<=1+eps)++ret;
    return ret;
}
int main()
{
    while(scanf("%d",&n),n)
    {
        for(i=0;i<n;++i)
            scanf("%lf%lf",&g[i].x,&g[i].y);
        sort(g,g+n,cmp);
        ans=n>0;
        for(i=0;i<n;++i)
            for(j=i+1;j<n&&(g[j].x-g[i].x)<=2;++j)
                if(SqrDis(g[i],g[j])<=4)
                    ans=max(ans,max(solve(g[i],g[j]),solve(g[j],g[i])));
        printf("%d\n",ans);
    }
    return 0;
}

O(n^2log n)

#include<cmath>
#include<cstdio>>
#include<iostream>
#include<algorithm>
using namespace std;
const int mm=333;
typedef double diy;
struct point
{
    diy x,y;
    point(){}
    point(diy _x,diy _y):x(_x),y(_y){}
}g[mm];
struct alpha
{
    diy angle;
    bool flag;
}s[mm];
bool cmp(alpha P,alpha Q)
{
    return P.angle<Q.angle;
}
diy SqrDis(point P,point Q)
{
    return (P.x-Q.x)*(P.x-Q.x)+(P.y-Q.y)*(P.y-Q.y);
}
int CircleMaxPoint(int n,diy r)
{
    int i,j,m,sum,ret=n>0;
    double tmp,rad;
    for(i=0;i<n;++i)
    {
        m=0;
        for(j=0;j<n;++j)
            if(i!=j&&(tmp=SqrDis(g[i],g[j]))<=4)
            {
                rad=acos(sqrt(tmp)/2);
                tmp=atan2(g[j].y-g[i].y,g[j].x-g[i].x);
                s[m].angle=tmp-rad,s[m++].flag=1;
                s[m].angle=tmp+rad,s[m++].flag=0;
            }
        sort(s,s+m,cmp);
        for(sum=j=0;j<m;++j)
        {
            if(s[j].flag)++sum;
            else --sum;
            ret=max(ret,sum+1);
        }
    }
    return ret;
}
int main()
{
    int i,n;
    while(scanf("%d",&n),n)
    {
        for(i=0;i<n;++i)
            scanf("%lf%lf",&g[i].x,&g[i].y);
        printf("%d\n",CircleMaxPoint(n,1.0));
    }
    return 0;
}