Problem Description
许多塔防游戏都是以经典的“守护雅典娜”为原型的。玩家需要建立各种防御工具来阻止怪物接近我们的女神——雅典娜。

这里，我们可以建造的防御工具只有标准圆形状的防御墙，建立在雅典娜与怪物出生点之间的防御墙数目越多，胜利的希望就越大。这里，将问题简化到一个二维坐标系里，并且假设雅典娜的坐标为原点(0, 0)，怪物出生点的坐标为(X, Y)。有N个给定圆心坐标与半径的防御墙可以供玩家选择建立，但要保证所有的圆都不发生相切或相交的情况。注意这些雅典娜位置与怪物出生点位置也不能在墙壁的边缘，即表示防御墙的圆上。点的面积与墙的厚度都很小，可以忽略不计。

记住，在游戏开始之后，怪物可以沿着任何轨迹，选择突破最少的圆形防御墙来到雅典娜的身边，而一个防御墙一旦被突破，它就会失去保护作用。所以，你的方案必须足够优秀。为了守护女神，快去找出最优的建设方案吧！
 

Input
输入第一行为T，表示有T组测试数据。
每组数据以三个整数N，X，Y开始，接下去的N行每行包括三个整数Xi，Yi，Ri，表示一个可以选择的圆心为(Xi, Yi)半径为Ri的防御墙。

[Technical Specification]

1. 1 <= T <= 100
2. 1 <= N <= 1000
3. 1 <= Ri <= 10 000
4. -10 000 <= X, Y, Xi, Yi <= 10 000，坐标不会相同
 

Output
对每组数据，先输出为第几组数据，然后输出能够间隔在雅典娜与怪物出生点之间最多的防御墙数目。
 

Sample Input
3
1 5 5
1 0 2
1 5 5
1 0 9
3 5 5
1 0 2
4 5 2
2 0 6
 

Sample Output
Case 1: 1
Case 2: 0
Case 3: 2
以下是自己的代码,不知道是不是精度不对

#include<stdio.h>//y=k*x k=y/x -k*x+y=0 A=-k B=1 |-k*xi+yi|/sqrt(k*k+1)
#include<math.h>//bi(-k*xi+yi)/sqrt(k*k+1)<=ri&&xy(X,Y,xi,yi)>ri
float bi(float x)
{
    if(x>0)
    return x;
    else
    return -x;
}
float xy(float x1,float y1,float x2,float y2)
{
    return sqrt(bi(x1-x2)*bi(x1-x2)+bi(y1-y2)*bi(y1-y2));
}
int main()
{
    int T,N,su,i;
    float X,Y,xi,yi,ri,k;
    scanf("%d",&T);
    for(i=1;i<=T;i++)
    {
        scanf("%d%f%f",&N,&X,&Y);
        su=0;
        k=X/Y;//printf("N=%d,X=%f,Y=%f\n",N,X,Y);
        //printf("%f\n",k);
        while(N--)
        {
            scanf("%f%f%f",&xi,&yi,&ri);
            //printf("%f %f %f\n",xi,yi,ri);
            //printf("%f\n",bi(-k*xi+yi)/sqrt(k*k+1));
            if(xy(0,0,xi,yi)<ri&&xy(X,Y,xi,yi)>ri||xy(0,0,xi,yi)>ri&&xy(X,Y,xi,yi))
            su++;
            if(bi(-k*xi+yi)/sqrt(k*k+1)<=ri&&xy(0,0,xi,yi)>ri&&xy(X,Y,xi,yi)>ri)
            su+=2;
            //printf("%d\n",su);
        }
        printf("Case %d: %d\n",i,su);
    }    
    return 0;
}

这是第3个例子的图

你的程序保证以上两点了吗？

这问题有点看不懂......
求指教

首先一个圆是有用的，即它能产生一次保护，要么是它包含了怪物不包含雅典娜，要么是它包含了雅典娜而不包含怪物

按照圆半径大小先排序，然后用动态规划求出对于某个圆来说，
它以及它包含的圆，最多能对雅典娜产生几次保护-->a[i]
它以及它包含的圆，最多能对怪物产生几次阻碍-->b[i]

然后求max(a[i]+b[j]) i和j这两个圆互斥（即不包含或者相交）

#include <iostream>
#define N 1000
using namespace std;

struct cir
{
       int x,y,r;
}c[N+1];

int n,T,dx,dy,ans;

int cmp(const void *a,const void *b)
{
    return ((cir*)a)->r-((cir*)b)->r;
}

int contain_point(int p,int x,int y)
{
    int t=(x-c[p].x)*(x-c[p].x)+(y-c[p].y)*(y-c[p].y);
    return t<c[p].r*c[p].r;
}

int contain_circle(int p,int q)
{
    int t1=(c[p].x-c[q].x)*(c[p].x-c[q].x)+(c[p].y-c[q].y)*(c[p].y-c[q].y);
    int t2=(c[p].r-c[q].r)*(c[p].r-c[q].r);
    return t1<t2;
}

int intersect(int p,int q)
{
    int t1=(c[p].x-c[q].x)*(c[p].x-c[q].x)+(c[p].y-c[q].y)*(c[p].y-c[q].y);
    int t2=(c[p].r+c[q].r)*(c[p].r+c[q].r);
    return t1<=t2;
}

int calculate()
{
     int a[N+1],b[N+1],ans=0;
     for (int i=1; i<=n; i++)
     {
         a[i]=0; b[i]=0;
     }
     for (int i=1; i<=n; i++)
     {
         if (contain_point(i,0,0) && !contain_point(i,dx,dy))
         {
                                  a[i]=1;
                                  for (int j=1; j<i; j++)
                                      if (a[i]<a[j]+1 && contain_circle(i,j)) a[i]=a[j]+1;
                                  if (a[i]>ans) ans=a[i];
         }
         if (contain_point(i,dx,dy) && !contain_point(i,0,0))
         {
                                    b[i]=1;
                                    for (int j=1; j<i; j++)
                                        if (b[i]<b[j]+1 && contain_circle(i,j)) b[i]=b[j]+1;
                                    if (b[i]>ans) ans=b[i];
         }
     }
     
     for (int i=1; i<=n; i++)
         for (int j=1; j<=n; j++)
             if (i!=j && a[i]+b[j]>ans && !intersect(i,j)) ans=a[i]+b[j];
             
     return ans;
}
     

int main()
{
    cin>>T;
    for (int j=1; j<=T; j++)
    {
          cin>>n>>dx>>dy;
          for (int i=1; i<=n; i++) cin>>c[i].x>>c[i].y>>c[i].r;
          
          qsort(c+1,n,sizeof(c[0]),cmp);
          
          cout<<"Case "<<j<<": "<<calculate()<<endl;
    }
}