杭电acm4562守护雅典娜 （dp+圆）

守护雅典娜

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 712    Accepted Submission(s): 235

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
  
  

 

Source

2013金山西山居创意游戏程序挑战赛——复赛（2）

想法：

先筛选出来两种圆，一种是包含雅典娜，不包含怪兽的，一种是不包含雅典娜，包含怪兽的，然后圆的半径大小排序，分别对两种圆dp，最后合并两种dp，求出最大的就是结果

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int INF=0x3f3f3f3f;
int x[4009],y[4009],r[4009];
int dp1[4009],dp2[4009];
struct node
{
    int x,y,r;
}a[4009],b[4009];
bool cmp(node x,node y)
{
    return x.r<y.r;
}
int main()
{
    int t,cas=0;
    scanf("%d",&t);
    while(t--)
    {
        int n,sum1=0,sum2=0;
        int xx,yy;
        scanf("%d %d %d",&n,&xx,&yy);
        memset(dp1,0,sizeof dp1);
        memset(dp2,0,sizeof dp2);
        for(int i=1; i<=n; i++)
        {
            scanf("%d %d %d",&x[i],&y[i],&r[i]);
            if(x[i]*x[i]+y[i]*y[i]<r[i]*r[i]&&(xx-x[i])*(xx-x[i])+(y[i]-yy)*(y[i]-yy)>r[i]*r[i])//包含雅典娜，不包含怪兽的
                a[++sum1].x=x[i],a[sum1].y=y[i],a[sum1].r=r[i];
            if(x[i]*x[i]+y[i]*y[i]>r[i]*r[i]&&(xx-x[i])*(xx-x[i])+(y[i]-yy)*(y[i]-yy)<r[i]*r[i])//不包含雅典娜，包含怪兽的
                b[++sum2].x=x[i],b[sum2].y=y[i],b[sum2].r=r[i];
        }
        sort(a+1,a+1+sum1,cmp);
        sort(b+1,b+1+sum2,cmp);
        int maxx=0;
        for(int i=1; i<=sum1; i++)
        {
            int ma=0;
            for(int j=1; j<i; j++)
            {
                if((a[j].x-a[i].x)*(a[j].x-a[i].x)+(a[j].y-a[i].y)*(a[j].y-a[i].y)<(a[i].r-a[j].r)*(a[i].r-a[j].r))//不相交
                    ma=max(dp1[j],ma);
            }
            dp1[i]=ma+1;//加上本身
            maxx=max(dp1[i],maxx);
        }
        for(int i=1; i<=sum2; i++)
        {
            int ma=0;
            for(int j=1; j<i; j++)
            {
                if((b[j].x-b[i].x)*(b[j].x-b[i].x)+(b[j].y-b[i].y)*(b[j].y-b[i].y)<(b[i].r-b[j].r)*(b[i].r-b[j].r))//不相交
                    ma=max(dp2[j],ma);
            }
            dp2[i]=ma+1;//加上本身
            maxx=max(dp2[i],maxx);
        }
        for(int i=1; i<=sum1; i++)
        {
            for(int j=1; j<=sum2; j++)
            {
                if((a[i].x-b[j].x)*(a[i].x-b[j].x)+(a[i].y-b[j].y)*(a[i].y-b[j].y)>(a[i].r+b[j].r)*(a[i].r+b[j].r))
                    maxx=max(dp1[i]+dp2[j],maxx);
            }
        }
        printf("Case %d: %d\n",++cas,maxx);
    }
    return 0;
}