hdu4562 守护雅典娜 DP

守护雅典娜

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

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）

思路：这道题目比赛的时候我没有做出来，思维定势认为怪兽与雅典娜之间的也要算（即没圈住怪兽，又没圈住雅典娜），后来看了网上说的自己沉下心想了一下，其实就分了四种情况（见代码注释）。先把圈住雅典娜的圆存在b数组，圈住怪兽的存在C数组，先对b,c数组进行排序，然后进行dp,过程就是找到半径第 k大的圆里面可以画多少个圆，这样子想的话就可以避免问题。判断能画在里面的条件就是，里面的圆半径与第k大的圆半径差大于两圆心的距离。具体自己画个图就出来了，对两个数组都进行操作后，就要判断b数组存在的圆会不会回影响c数组存在的圆，

首先用ans存两个数组中分别能画的最大圆的个数的大的那个。然后判断c,b数组会不会互相影响，即两圆的圆心距离大于两圆的半径和，如果互不影响，就要拿ans与b该层圆能画的个数加上c该层能画个数和相比较。最终输出结果。

#include<iostream>
#include<stdio.h>
#include<cmath>
#include<algorithm>
using namespace std;
struct circle
{
   int x,y,r;
}a[2000],b[2000],c[2000];
int cmp(circle a,circle b)
{
    return a.r<b.r;
}
int len(circle a,circle b)
{
    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}
int main()
{
    int t,n;
    int x,y;
    scanf("%d",&t);
    int cnt=0;
    while(t--)
    {
        circle p,w1,w2;
        scanf("%d %d %d",&n,&x,&y);
        w1.x=x,w1.y=y;

        w2.x=0,w2.y=0;

        int z1=0,z2=0;

        for(int i=0;i<n;i++)
        {
            scanf("%d %d %d",&a[i].x,&a[i].y,&a[i].r);
            p.x=a[i].x,p.y=a[i].y,p.r=a[i].r;

            if(len(p,w1)<p.r*p.r&&len(p,w2)<p.r*p.r) continue;///怪兽和雅典娜两个都包括

            if(len(p,w1)==p.r*p.r||len(p,w2)==p.r*p.r) continue;///与怪兽或雅典拿相切

            if(len(p,w1)>p.r*p.r&&len(p,w2)>p.r*p.r) continue;///即碰不到雅典娜有碰不到怪兽

            if(len(p,w1)<p.r*p.r)///圈到雅典娜
            {
                b[z1].x=a[i].x,b[z1].y=a[i].y,b[z1++].r=a[i].r;
            }
            else if(len(p,w2)<p.r*p.r)///圈到怪兽
            {
               c[z2].x=a[i].x,c[z2].y=a[i].y,c[z2++].r=a[i].r;
            }

        }
        int ans1=0,ans2=0,ans;
        sort(b,b+z1,cmp);
        sort(c,c+z2,cmp);
        int dp1[1050];
        int dp2[1050];
        int dis1,dis2,dis3;
        for(int i=0;i<z1;i++)
        {
            dp1[i]=1;
            for(int j=0;j<i;j++)
            {
                dis1=len(b[i],b[j]);
                if(b[i].r>b[j].r&&dis1<(b[i].r-b[j].r)*(b[i].r-b[j].r))///内切的判定
                {
                    dp1[i]=max(dp1[i],dp1[j]+1);
                }
            }
            ans1=max(dp1[i],ans1);
        }
        for(int i=0;i<z2;i++)
        {
            dp2[i]=1;
            for(int j=0;j<i;j++)
            {
                dis2=len(c[i],c[j]);
                if(c[i].r>c[j].r&&dis2<(c[i].r-c[j].r)*(c[i].r-c[j].r))
                {
                    dp2[i]=max(dp2[i],dp2[j]+1);
                }
            }
            ans2=max(dp2[i],ans2);
        }
        ans=max(ans1,ans2);
        for(int i=0;i<z1;i++)
        {
            for(int j=0;j<z2;j++)
            {
                dis3=len(b[i],c[j]);
                if(dis3>(b[i].r+c[j].r)*(b[i].r+c[j].r))///不能外切或相交
                    ans=max(ans,dp1[i]+dp2[j]);
            }
        }
        printf("Case %d: ",++cnt);
        printf("%d\n",ans);

    }
}