Problem Description

To save Sara, Michael Scofield was captured by evil policemen and he was arrested in Prison again. As is known to all, nothing can stop Michael, so Prison Break continues.
The prison consists of many circular walls. These walls won't intersect or tangent to each other.

Now Michael is arrested in one of the deepest rooms, and he wants to know how many walls he has to break at least for running out. In figure 1, Michael has to break 3 walls at least and in figure 2, 2 walls are needed.

 

Input

There will be multiple test cases (no more than 10) in a test data.
For each test case, the first line contains one number: n (1<=n<=50,000) indicating the total number of circular walls.
Then n lines follow, each line contains three integers x, y, r. (x,y) indicates the center of circular wall and r indicates the radius of the wall.
-100,000<=x,y<=100,000 
1 <= r <= 100,000
The input ends up with EOF.

 

Output

The least number of walls to break for running out.

 

Sample Input

 

Sample Output

 

Source

 #include <bits/stdc++.h>

 #define MP make_pair

 using namespace std;

 const double eps = 1e-;

 const int N = 1e5+;

 int n,cnt[N];

 int cr[N][],r[N];

 pair<int,int>pt[N];

 double curx;

 struct node

 {

     int id,f;

     bool operator < (const node &ta) const

     {

         double y1 = cr[id][] + f * sqrt(1.0 *r[id]*r[id]-1.0*(curx-cr[id][])*(curx-cr[id][]));

         double y2 = cr[ta.id][] + ta.f * sqrt(1.0 *r[ta.id]*r[ta.id]-1.0*(curx-cr[ta.id][])*(curx-cr[ta.id][]));

         if(fabs(y1-y2)<eps)

             return f<ta.f;

         return y1<y2;

     }

 };

 set<node >st;

 int main(void)

 {

     int n;

     while(~scanf("%d",&n))

     {

         st.clear();

         int tot=,ans=;

         for(int i=;i<=n;i++)

         {

             scanf("%d%d%d",&cr[i][],&cr[i][],r+i);

             pt[tot++]=MP(cr[i][]-r[i],i);

             pt[tot++]=MP(cr[i][]+r[i],i-n);

             cnt[i]=;

         }

         sort(pt,pt+tot);

         for(int i=;i<tot;i++)

         {

             int k=pt[i].second,up=,dw=;

             curx = pt[i].first;

             if(k<=)

                 k+=n,st.erase((node){k,-}),st.erase((node){k,});

             else

             {

                 auto it=st.insert((node){k,-}).first;

                 it++;

                 if(it!=st.end())    up = it->id;

                 it--;

                 if(it!=st.begin())  dw = (--it)->id;

                 if(up==dw&&up)

                     ans=max(ans,cnt[k]=cnt[up]+);

                 else if(up&&dw)

                     ans=max(ans,cnt[k]=max(cnt[up],cnt[dw]));

                 else

                     cnt[k]=;

                 st.insert((node){k,});

             }

         }

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

     }

     return ;

 }