hdu2215（最小覆盖圆）

Maple trees

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1578    Accepted Submission(s): 488

Problem Description

There are a lot of trees in HDU. Kiki want to surround all the trees with the minimal required length of the rope . As follow,

To make this problem more simple, consider all the trees are circles in a plate. The diameter of all the trees are the same (the diameter of a tree is 1 unit). Kiki can calculate the minimal length of the rope , because it's so easy for this smart girl.
But we don't have a rope to surround the trees. Instead, we only have some circle rings of different radius. Now I want to know the minimal required radius of the circle ring. And I don't want to ask her this problem, because she is busy preparing for the examination.
As a smart ACMer, can you help me ?

 

Input

The input contains one or more data sets. At first line of each input data set is number of trees in this data set n （1 <= n <= 100）, it is followed by n coordinates of the trees. Each coordinate is a pair of integers, and each integer is in [-1000, 1000], it means the position of a tree’s center. Each pair is separated by blank.
Zero at line for number of trees terminates the input for your program.

 

Output

Minimal required radius of the circle ring I have to choose. The precision should be 10^-2.

 

Sample Input

2

1 0

-1 0

0

 

Sample Output

1.50

 

题意：用一个最小的圆把所有的点都圈在里边，点可以在圆上，每个点的半径为0.50

#include<stdio.h>
#include<math.h>
#define PI acos(-1.0)
struct   TPoint
{
    double x,y;
}a[1005],d;
double r;
double   distance(TPoint   p1,   TPoint   p2)
{
    return (sqrt((p1.x-p2.x)*(p1.x -p2.x)+(p1.y-p2.y)*(p1.y-p2.y)));
}
double multiply(TPoint   p1,   TPoint   p2,   TPoint   p0)
{
    return   ((p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y));
}
void MiniDiscWith2Point(TPoint   p,TPoint   q,int   n)
{
    d.x=(p.x+q.x)/2.0;
    d.y=(p.y+q.y)/2.0;
    r=distance(p,q)/2;
    int k;
    double c1,c2,t1,t2,t3;
    for(k=1; k<=n; k++)
    {
        if(distance(d,a[k])<=r)
            continue;
        if(multiply(p,q,a[k])!=0.0)
        {
            c1=(p.x*p.x+p.y*p.y-q.x*q.x-q.y*q.y)/2.0;
            c2=(p.x*p.x+p.y*p.y-a[k].x*a[k].x-a[k].y*a[k].y)/2.0;

            d.x=(c1*(p.y-a[k].y)-c2*(p.y-q.y))/((p.x-q.x)*(p.y-a[k].y)-(p.x-a[k].x)*(p.y-q.y));
            d.y=(c1*(p.x-a[k].x)-c2*(p.x-q.x))/((p.y-q.y)*(p.x-a[k].x)-(p.y-a[k].y)*(p.x-q.x));
            r=distance(d,a[k]);
        }
        else
        {
            t1=distance(p,q);
            t2=distance(q,a[k]);
            t3=distance(p,a[k]);
            if(t1>=t2&&t1>=t3)
            {
                d.x=(p.x+q.x)/2.0;
                d.y=(p.y+q.y)/2.0;
                r=distance(p,q)/2.0;
            }
            else if(t2>=t1&&t2>=t3)
            {
                d.x=(a[k].x+q.x)/2.0;
                d.y=(a[k].y+q.y)/2.0;
                r=distance(a[k],q)/2.0;
            }
            else
            {
                d.x=(a[k].x+p.x)/2.0;
                d.y=(a[k].y+p.y)/2.0;
                r=distance(a[k],p)/2.0;
            }
        }
    }
}

void MiniDiscWithPoint(TPoint   pi,int   n)
{
    d.x=(pi.x+a[1].x)/2.0;
    d.y=(pi.y+a[1].y)/2.0;
    r=distance(pi,a[1])/2.0;
    int j;
    for(j=2; j<=n; j++)
    {
        if(distance(d,a[j])<=r)
            continue;
        else
        {
            MiniDiscWith2Point(pi,a[j],j-1);
        }
    }
}
int main()
{
    int i,n;
    while(scanf("%d",&n)&&n)
    {
        for(i=1; i<=n; i++)
            scanf("%lf %lf",&a[i].x,&a[i].y);
        if(n==1)
        {
            printf("0.50
");
            continue;
        }

        r=distance(a[1],a[2])/2.0;
        d.x=(a[1].x+a[2].x)/2.0;
        d.y=(a[1].y+a[2].y)/2.0;
        for(i=3; i<=n; i++)
        {
            if(distance(d,a[i])<=r)
                continue;
            else
                MiniDiscWithPoint(a[i],i-1);
        }
        printf("%.2lf
",r+0.5);
    }
    return 0;
}