hdu3511-Prison Break

纪念一下人生中第一道扫描线算法的题。。。。。其实不是严格上的第一道。。。第一次遇到的那个至今没过。。。。。

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=3511

这题应该算是扫描线的基础题。

对于每个圆，进入和出去的时候分别做扫描线，分别是x = c[i].x - c[i].r, x' = c[i].x + c[i].r；

这样对于每条扫描线，对于x'，我们在集合中删去这个圆，这很好理解。

对于x，我们将这个圆加入集合，这样我们只要找向上第一个交的点和向下第一个交的点即可。

不过问题来了，这个交点坐标随着扫描线的移动是在变化的，但我们注意到，这些点的相对位置并不变（即上面的还在上面，下面的还在下面）

这样我们可以拉个set来维护扫描线上交点纵坐标，这个没必要存这个纵坐标的具体值，因为相对位置不变，树的结构也不变。

只需要重载一下小于号在insert时候使用即可。

如果扫描线向上或向下没有点，那么这个圆的depth = 1;

如果上下两个点属于同一个圆id，那么这个圆的depth = depth[id]+1;

如果上下两个圆属于不同的圆id1，id2，那么这个圆的depth = max(depth[id1], depth[id2]);

AC代码：

 #include <bits/stdc++.h>

 using namespace std;
 const int maxn =  + ;

 typedef struct Circle{
   int id, x, y, r;

   Circle( int id = , int x = , int y = , int r =  ){
     this->id = id;
     this->x = x;
     this->y = y;
     this->r = r;
   }
 }Circle;

 Circle c[maxn];

 typedef struct Point{
   int id, ty;

   Point( int id = , int ty =  ){
     this->id = id;
     this->ty = ty;
   }
 }Point;

 set<Point> s;

 typedef struct Line{
   int id, x, ty;

   Line( int id = , int x = , int ty =  ){
     this->id = id;
     this->x = x;
     this->ty = ty;
   }

   bool operator < ( const Line& l )const{
     if( x == l.x )
       return id < l.id;
     return x < l.x;
   }
 }Line;

 Line l[maxn<<];

 int depth[maxn];

 int n, ans, xlog;

 double intersector( const Point& p ){
   int id = p.id;
   double r = 1.0*c[id].r;

   double x = 1.0*(xlog - c[id].x);
   double y = sqrt((r*r - x*x));

   if(p.ty == )
     return 1.0*c[id].y + y;
   else
     return 1.0*c[id].y - y;
 }

 bool operator < ( const Point& p1, const Point& p2 ){
   if(p1.id == p2.id)
     return p1.ty < p2.ty;
   return intersector(p1) < intersector(p2);
 }

 void solve( int nn ){
   memset(depth, , sizeof(depth));
   s.clear();
   ans = ;

   for( int i = ; i < nn; ++i ){
     int id = l[i].id, ty = l[i].ty;
     xlog = l[i].x;
     //cout << "id: " << id << "   ty: " << ty << endl;

     if( ty ==  ){
       s.erase(Point(id, ));
       s.erase(Point(id, ));
     }else{
       s.insert(Point(id, ));
       set<Point>::iterator it1 = s.find(Point(id, )), it2;
       it2 = it1;
       it2++;

       if( it1 == s.begin() || it2 == s.end() ){
         depth[id] = ;
         //cout << "id: " << id << "    depth[id]: " << depth[id] << endl;
       }else{
         it1--;
         if( it1->id == it2->id ){
           depth[id] = depth[it1->id]+;
         }else{
           depth[id] = max( depth[it1->id], depth[it2->id] );
         }
         //cout << "id: " << id << "    depth[id]: " << depth[id] << endl;
       }
       s.insert(Point(id, ));
     }
     ans = max( ans, depth[id]);
   }

   printf("%d\n", ans);
 }

 int main(void){
   while(scanf("%d", &n) != EOF){
     memset( c, , sizeof(c) );
     memset( l, , sizeof(l) );

     for( int i = ; i < n; ++i ){
       c[i].id = i;
       scanf("%d%d%d", &c[i].x, &c[i].y, &c[i].r);
       l[i*] = Line(i, c[i].x-c[i].r, );
       l[i*+] = Line(i, c[i].x+c[i].r, );
     }
     int nn = n * ;
     sort( l, l + nn );

     solve(nn);
   }

   return ;
 }

 /*
 5
 0 0 100
 0 0 1
 0 5 3
 3 0 2
 0 0 200
 6
 0 0 100
 0 0 1
 0 5 3
 0 5 2
 3 0 2
 0 0 200
 */