hdu4562(贪心策略+DP)

守护雅典娜

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

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
  
  
  
  

   
    
  
  
  
  

   
   //看了大神的代码之后自己动手做的，向大神致敬！
  
  
  
  

   
   //雅典娜与怪物都不是傻子，故因选择最优的方案（贪心策略），本题可以先依据只能覆盖雅典娜与怪物其中一个的圆将所有圆划分为两类有用的；
  
  
  
  

   
   然后排序分别选择满足条件最大个数，此处分3种情况：
  
  
  
  

   
   //    只包含覆盖雅典娜的圆个数
  
  
  
  

   
   //    只包含覆盖怪物的圆个数
  
  
  
  

   
   //    包含覆盖雅典娜与怪物的圆个数
  
  
  
  

   
   //为了选择上述3种情况可以用DP思想
  
  
  
  

   
   
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;struct Circle
{
 int x,y,r;
};struct Point
{
 int x,y;
};int sqr(int a)
{
 return a*a;
}bool Is_InCilcle(Point a,Circle b)
//判断点是否在圆内
{
 int dis=sqr(a.x-b.x)+sqr(a.y-b.y);
 int sqr_r=sqr(b.r);
 return dis<sqr_r;
}bool Is_OnCilcle(Point a,Circle b)
//判断点是否在圆上
{
 int dis=sqr(a.x-b.x)+sqr(a.y-b.y);
 int sqr_r=sqr(b.r);
 return dis==sqr_r;
}bool Is_NotComCilcle(Circle a,Circle b)
//判断两圆是否不相交或相切
{
 int sub=sqr(a.r-b.r);
 int sum=sqr(a.r+b.r);
 int dis=sqr(a.x-b.x)+sqr(a.y-b.y);
 return !((sub<=dis)&&(sum>=dis));
}bool cmp(Circle a,Circle b)
//按半径升序排序
{
 return a.r<b.r;
}int max(int a,int b)
//选出最大者
{
 return a<b?b:a;
}int dp_add[1000+10];
int dp_pet[1000+10];int main()
{
 int t,i,n,j;
 int tag=0;
 cin>>t;
 while(t--)
 {
  Point ad,pet;
  vector<Circle>add,pett;
  scanf("%d%d%d",&n,&pet.x,&pet.y);
  ad.x=ad.y=0;
  Circle temp;
  for(i=0;i<n;i++)
  {
   scanf("%d%d%d",&temp.x,&temp.y,&temp.r);
   bool flag_ad_In=Is_InCilcle(ad,temp);
   bool flag_pet_In=Is_InCilcle(pet,temp);
   bool flag_ad_On=Is_OnCilcle(ad,temp);
   bool flag_pet_On=Is_OnCilcle(pet,temp);
   if((flag_ad_In^flag_pet_In)&&!flag_ad_On&&!flag_pet_On)
   {
    if(flag_ad_In)
     add.push_back(temp);
    else 
     pett.push_back(temp);
   }
  }  sort(add.begin(),add.end(),cmp);
  sort(pett.begin(),pett.end(),cmp);
  int mx=0;
  for(i=0;i<add.size();i++)
  {
   dp_add[i]=0;
   for(j=0;j<i;j++)
   {
    if(Is_NotComCilcle(add[i],add[j]))
     dp_add[i]=max(dp_add[i],dp_add[j]);
   }
   dp_add[i]++;
   mx=max(mx,dp_add[i]);
  }  for(i=0;i<pett.size();i++)
  {
   dp_pet[i]=0;
   for(j=0;j<i;j++)
   {
    if(Is_NotComCilcle(pett[i],pett[j]))
     dp_pet[i]=max(dp_pet[i],dp_pet[j]);
   }
   dp_pet[i]++;
   mx=max(mx,dp_pet[i]);
  }  for(i=0;i<add.size();i++)
  {
   for(j=0;j<pett.size();j++)
   {
    if(Is_NotComCilcle(add[i],pett[j]))
        mx=max(mx,dp_add[i]+dp_pet[j]);
   }
  }  printf("Case %d: %d\n",++tag,mx);
 }
 return 0;
}