扫描线题目汇总 （里面的题解和代码非原创）

hdu 3867 Light and Shadow （线段扫描  极角排序）

转载自：http://blog.csdn.net/accry/article/details/6676009

题意：

原子弹爆炸，一些互不相交的线段，求能辐射到的线段个数（可以将原子弹爆炸点视为泛光源）

分析：

以辐射源为中心对周围的点按照极坐标角度进行排序，然后在极坐标上使用扫描线方法。
维护一个集合，集合内的元素是与扫描线相交的线段，排序依据是线段与扫描线的交点到辐射源的距离。该集合中的最小元素就是被照射到的线段。

有关容器（set）排序依据的说明：

在扫描线运动前后，如果有两个线段存在于容器中，这两个线段与扫描线的交点到辐射源的距离远近关系不会发生变化。若发生变化，表示扫描线运动范围内两个线段有交点，与题目提供的已知条件不符。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <algorithm>
using namespace std;
#define EPS 1e-8
#define LS0(a) (a << 1)
#define LS1(a) ((a << 1) | 1)

const int MAXN = 20010;
struct Point { 
    double x, y;
    Point(double _x = 0.0, double _y = 0.0): x(_x), y(_y) {}
    Point operator + (const Point &b) const {
        return Point(x + b.x, y + b.y);
    }
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
    bool operator < (const Point &b) const {  //逆时针
        return x * b.y < y * b.x;
    }
    void input() {
        scanf("%lf%lf", &x, &y);
    }
    double diso() {
        return sqrt(x * x + y * y);
    }

}cur,ps[MAXN];

Point lnlncross_pt(Point aa, Point ad, Point ba, Point bd) { // 求直线交点
    ad = ad - aa;
    bd = bd - ba;
    double tmp = bd ^ ad;
    return Point(
        (ad.x * bd.x * (ba.y - aa.y) + aa.x * bd.x * ad.y - ba.x * ad.x * bd.y) / tmp,
        (ad.y * bd.y * (aa.x - ba.x) + ba.y * ad.y * bd.x - aa.y * bd.y * ad.x) / tmp);
}

struct Item { // 扫描线的点类型
    Point *u, *v;
    int type; // 1: 线段起点; 0: 线段终点;
    int sgid; // 线段序号
    Item(Point *_u = NULL, Point *_v = NULL, int _ty = 0, int _id = 0)
        : u(_u), v(_v), type(_ty), sgid(_id) {}
    bool operator < (const Item &b) const {
        if(u == b.u && v == b.v)
            return false;
        Point au = lnlncross_pt(Point(0.0, 0.0), cur, *u, *v);
        Point bu = lnlncross_pt(Point(0.0, 0.0), cur, *b.u, *b.v);
        return au.diso() < bu.diso();
    }

}item[MAXN];

bool flag[MAXN];
set<Item> Scan;

                    
bool cmp(const Item &a, const Item &b) { //极角排序 从-PI到-PI内 
        return atan2(a.u->y, a.u->x) < atan2(b.u->y, b.u->x);

}

void inputps(int n) {
    Point src, a, b;
    src.input();
    for(int i = 0; i < n; ++i) {
        // 读取线段并求得相对于光源的坐标
        a.input(); a = a - src;
        b.input(); b = b - src;
        // 保证线段的极角序
        if(b < a) swap(a, b);
        ps[LS0(i)] = a;
        ps[LS1(i)] = b;
        item[LS0(i)] = Item(&ps[LS0(i)], &ps[LS1(i)], 0, i);
        item[LS1(i)] = Item(&ps[LS1(i)], &ps[LS0(i)], 1, i);
    }
    sort(item, item + 2 * n, cmp);
}



bool sgcross_with_ax(Item &a) {   //与射线相交判断   good 以前不知道的东西
    Point tmp(-1.0, 0.0);
    return (*a.u ^ *a.v) * (*a.u ^ tmp) > 0.0
        && (*a.u ^ tmp) * (tmp ^ *a.v) > 0.0;
}



int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        inputps(n);
        memset(flag,0,sizeof(flag));
        // 初始化极角扫描器  初始射线向量为（-1.0，0)
        Scan.clear();
        for(int i = 0; i < 2 * n; ++i) {
                cur = *item[i].u;
            if(item[i].type == 1 && sgcross_with_ax(item[i]))
                Scan.insert(item[i]);
        }
        // 极角扫描
        for(int i = 0; i < 2 * n; ++i) {
                cur = *item[i].u;
            if(item[i].type == 1)
                Scan.insert(item[i]);
            else
                Scan.erase(Item(item[i].v, item[i].u, 1, item[i].sgid));
            if(!Scan.empty())
                flag[Scan.begin()->sgid] = true;
        }
        int ans = 0;
        for(int i = 0; i < n; ++i)
            if(flag[i])ans ++;
        printf("%d
", ans);
    }
    return 0;

}

hdu 3124 Moonmist  （圆的扫描）

转自：http://blog.sina.com.cn/s/blog_64675f540100o02x.html

题目描述：

给你n（50000）个不相交的圆，告诉你各个圆的xy坐标和半径，问你最近的两个圆之间的距离（两圆心之间的距离减去各自的半径）

解题报告：

         暴力的做法扫描任意两圆之间的最近距离，取最小值，n^2复杂度，超时。

         正解为：

二分枚举每个圆半径的增量mid。

         那么此时的每个圆i的半径为R[i] + mid（R[i]为这个圆原来的半径），对于这组新的半径，如果在n个圆中存在两个圆相交，那么就说明mid偏大，反之，如果不存在，则mid偏小。这样就可以达到二分的目的。

         二分的复杂度可以在此近似为logn，那么问题转化为：怎样在O(n)或者O(nlogn)的时间内检测出n个圆内是否存在相交的情况，答案是“扫描线”。

         常见的扫描线通常利用在正方形的各种检测和求和：在x方向从左到右扫描，y方向用set或者线段树维护当前的线段位置即可，如果覆盖相同的线段即相交。

         如下：

    

从左到右依次扫描竖直的四条线段ABCD，

A：插入1~3的线段

B：插入0~2的线段，和现存的1~3线段冲突，所以存在相交情况。

C：删除1~3线段

D：删除0~2线段

         但是现在是圆形，从左到右扫描，一个圆的开始位置和结束位置之间，这个圆的纵向线段长度是在不断变化的，需要另外的一种方法。

         这里采用两条扫描线，均是从左向右，每次检测的是这两条扫描线之间的圆的碰撞情况。

如图：

         第一条扫描线从左往右依次是每个圆的左边界，即竖直线L1，L2，L3。

         第二条扫描线从左往右依次是每个圆的右边界，即竖直线R1，R2，R3。

         两条扫描线均是从最左边的L1和R1开始，保证L扫描线的x坐标永远小于R扫描线的x坐标即可。扫描流程如下，假设有n个圆，i为Li，j为Rj：

         i = j = 1

         while(i <= n or j <= n)

         {

                   if(i == n + 1) 删除圆j，j++;

                   else if (j == n + 1) 插入圆i，检测圆i的圆心和y方向相邻两圆的碰撞情况。i++。

                   else if (i <= n and Li 在Ri的左边)

                            插入圆i，检测圆i的圆心和y方向相邻两圆的碰撞情况。i++。

                   else 删除圆j，j++;

         }

简要解释如下：

While中有4个分支

前两个是边界情况，很容易理解。

第三个是L扫描线的推进，即插入圆。

第四个条件：由于只需检测Li 和 Rj两条扫描线之间的圆的相交情况，所以，Li之前的圆都需要删除

当扫描线为Li和Rj时，已经插入的圆都是x方向起点小于等于Li，x方向终点大于等于Rj，即在Li和Rj之间是连续不间断的，所以只需检测插入圆的圆心的上下相邻的两个即可，不可能跳跃。即假设圆心位置从下到上一次编号1~m，那么插入圆x后，不可能出现x和x+2相交而不和x+1相交的情况（应为在Li和Rj之间是连续的）。

至于检测的方法就是线段树或者set了。

上图的扫描线过程是：

初始为L1,R1

L1 < R1, 插入圆A，检测无碰撞，变为L2，R1

L2 < R1, 插入圆B，检测无碰撞，变为L3, R1

L3 > R1, 删除圆B，变为L3，R2

L3 < R2，插入圆C，检测到碰撞，结束

#include<iostream>
#include<cstdio>
#include<cstring>
#include<set>
#include<algorithm>
#include<cmath>
using namespace std;
#define size 50000
#define eps 1e-8
#define sqr(x) ((double)(x) * (x))
int Left[size], Right[size], Up[size], up_rank[size];
int X[size], Y[size], R[size];
int t, n;
double mid;
set<int> mytree;
typedef set<int>::iterator it;
bool cmp_left(const int &a, const int &b){return (X[a] - R[a] < X[b] - R[b]);}
bool cmp_right(const int &a, const int &b){return (X[a] + R[a] < X[b] + R[b]);}
bool cmp_up(const int &a, const int &b){if (Y[a] == Y[b]) return X[a] < X[b]; else return Y[a] < Y[b];}
bool collid(int a, int b)
{
    a = Up[a];
    b = Up[b];
    return (sqr(X[a] - X[b]) + sqr(Y[a] - Y[b]) - sqr(R[a] + R[b] + mid + mid) <= 0);
}
bool insert(int &id)
{
    it i = mytree.insert(id).first;
    if (i != mytree.begin())
    {
        if (collid(id, *--i))
            return false;
        ++i;
    }
    if (++i != mytree.end())
    {
        if (collid(id, *i))
            return false;
    }
    return true;
}
bool remove(int v) {
    it i = mytree.find(v);
    if (i != mytree.begin() && i != --mytree.end()) {
        int a = *--i;
        ++i;
        int b = *++i;
        if (collid(a, b)) {
            return false;
        }
    }
    mytree.erase(v);
    return true;
}

bool judge()
{
    mytree.clear();
    int l = 0, r = 0;
    while(l < n || r < n)
    {
        if (r == n
        ||l != n && (X[Right[r]] + R[Right[r]] + mid) - (X[Left[l]] - R[Left[l]] - mid) >= 0)
        {
            if (!insert(up_rank[Left[l++]])) return true;
        }
        else if (!remove(up_rank[Right[r++]]))
            return true;
    }
    return false;
}
double jeogia()
{
    for(int i = 0; i < n; i++)
        Left[i] = Right[i] = Up[i] = i;
    sort(Left, Left + n, cmp_left);
    sort(Right, Right + n, cmp_right);
    sort(Up, Up + n, cmp_up);
    for(int i = 0; i < n; i++)
        up_rank[Up[i]] = i;
    double s = 0, t = sqrt(sqr(X[0] - X[1]) + sqr(Y[0] - Y[1])) - R[0] - R[1];
    while(t - s >= eps)
    {
        mid = (s + t) * 0.5; //mid 为各个圆需要加上的半径长度
        if (judge()) t = mid;//是否有圆相交
        else s = mid;
    }
    return t + s;
}
int main()
{
    scanf("%d", &t);
    while(t-- && scanf("%d", &n))
    {
        for(int i = 0; i < n; i++)
            scanf("%d%d%d", &X[i], &Y[i], &R[i]);
        printf("%.6f
", jeogia());
    }
    return 0;
}

hdu 4629 Burning  （覆盖次数1——n的面积）

转载自：http://www.cnblogs.com/Rlemon/archive/2013/07/31/3227729.html

求平面的n个三角形的不同覆盖次数(1 - n)的面积 。

题意：给你n个三角形，问覆盖1~n次的面积各是多少，n < 50;

分析：取出所有端点和交点的x坐标，排序，然后对于每一段xi~xi+1的范围的线段都是不相交的，所以组成的

面积要么是三角形，要么是梯形，可以直接用公式算面积，然后对于每一个三角形的线段都标记该段对于

从下往上的扫描线来说是入边还是出边，然后就可以直接计算出这块面积被覆盖了几次；如入边加1，出边减一

下图，黄色表示覆盖次数；

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<cstdlib>
#define pbk push_back
using namespace std;
const int N = 25050+10;
const double eps = 1e-10;
inline double sqr(double x){
    return x * x;
}
inline int dcmp(double x){
    return x < -eps ? -1 : x > eps;
}
struct Point{
    double x,y;
    int kind;
    Point(){}
    Point(double x,double y,int kind = 0):x(x),y(y),kind(kind){}
    bool operator < (const Point &p)const{
        return dcmp(x - p.x) < 0 || ( dcmp(x - p.x) == 0 && dcmp(y - p.y) < 0 );
    }
    Point operator - (const Point &p)const{
        return Point(x - p.x, y - p.y);
    }
    Point operator + (const Point &p)const{
        return Point(x + p.x, y + p.y);
    }
    Point operator * (const double &k)const{
        return Point (x*k , y*k);
    }
    Point operator / (const double &k)const{
        return Point (x/k, y/k);
    }
    double operator * (const Point &p)const{
        return x * p.y - y * p.x;
    }
    double operator / (const Point &p)const{
        return x * p.x + y * p.y;
    }
    void input(){
        scanf("%lf%lf",&x,&y);
    }
    void ot(){
        printf("%lf %lf
",x,y);
    }
};
struct Line{
    Point a,b;
    int kind;
    Line (){}
    Line (Point a,Point b,int kind = 0):a(a),b(b),kind(kind){}
    double operator * (const Point &p)const{
        return ( b - a ) * ( p - a );
    }
    double operator / (const Point &p)const{
        return ( p - a) / ( p - b);
    }
    bool parallel(const Line &v){
        return !dcmp( ( b - a ) * ( v.b - v.a ) ); 
    }
    int LineCrossLine(const Line &v){
        if ( (*this).parallel(v) ){
            return ( dcmp( v * a ) == 0);
        }return 2;
    }
    int SegCrossSeg(const Line &v){
        int d1 = dcmp( (*this) * v.a);
        int d2 = dcmp( (*this) * v.b);
        int d3 = dcmp( v * a);
        int d4 = dcmp( v * b);
        if ( ( d1 ^ d2 ) == -2 && ( d3 ^ d4 ) == -2 ) return 2;
        return ( ( d1 == 0 && dcmp( (*this) / v.a ) <= 0 )
            ||   ( d2 == 0 && dcmp( (*this) / v.b ) <= 0 )
            ||   ( d3 == 0 && dcmp( v / a ) <= 0 )
            ||   ( d4 == 0 && dcmp( v / b ) <= 0 )
            );
    }
    Point CrossPoint(const Line &v){
        double s1 = v * a, s2 = v * b;
        return ( a * s2 - b * s1) / (s2 - s1);
    }
    void input(){
        a.input(); b.input();
    }
    void ot(){
        a.ot(); b.ot();
    }

};

int n,poly_n,xn;
vector<double> lx;
vector<Line> line;
double ans[N];
void init(){
    int sz = line.size();
    for (int i = 0; i < sz; i++){
        for (int j = i+1; j < sz; j++){
            if (line[i].SegCrossSeg(line[j]) == 2){
                Point p = line[i].CrossPoint(line[j]);
                lx.pbk(p.x);
            }
        }
    }
    
    sort(lx.begin(),lx.end());
    xn = unique(lx.begin(),lx.end()) - lx.begin();
}
vector<Point> qu[N];
void work(){
    for (int i = 0; i <= n; i++) ans[i] = 0;
    for (int i = 0; i < xn-1; i++){
        int k = 0;
        for (int j = 0; j+1 < qu[i].size(); j++){
            k += qu[i][j].kind;
            ans[ k ] += (lx[i+1] - lx[i]) * (qu[i][j+1].x+qu[i][j+1].y - qu[i][j].x - qu[i][j].y) / 2;        
        }
    }
    for (int i = 1; i <= n; i++) printf("%.10lf
",ans[i]);
}
void check(){
    for (int i = 0; i < xn - 1; i++){
        cout<<qu[i].size()<<" >.<"<<endl;
        for (int j = 0; j < qu[i].size(); j++){
            qu[i][j].ot(); cout<<qu[i][j].kind<<endl;
        }
    }
}
void solve(){
    for (int i = 0; i < xn; i++) qu[i].clear();
    for (int i = 0; i < line.size(); i++){
        int j = lower_bound(lx.begin(),lx.begin()+xn,line[i].a.x) - lx.begin();
        for (; j+1 < xn; j++ ){
            double l = lx[j], r = lx[j+1];
            if (dcmp(r - line[i].b.x) > 0) break;
            Point p1 = line[i].CrossPoint(Line(Point(l,0), Point(l,1)));
            Point p2 = line[i].CrossPoint(Line(Point(r,0), Point(r,1)));
            qu[j].pbk(Point(p1.y, p2.y,line[i].kind));
        }
    }
    for (int i = 0; i < xn - 1; i++) sort(qu[i].begin(), qu[i].end());
//    check();
    work();
}
int main(){
    int T; scanf("%d",&T);
    while (T--){
        scanf("%d",&n);
        lx.clear(); line.clear();;
        for (int i = 0; i < n ;i++){
            Point t[4];
            for (int j = 0; j < 3; j++ ){
                t[j].input(); 
            }
            t[3] = t[0];
            int flag = 1;
            if (dcmp( (t[1] - t[0])*(t[2] - t[0]) ) == 0) flag = 0;
        
            for (int i = 0; i < 3 && flag; i++ ){
                lx.pbk(t[i].x);
                for (int j = i+1; j < 3; j++){
                    Line tmp; tmp.a = t[i]; tmp.b = t[j];
                    if (dcmp( tmp.a.x - tmp.b.x ) > 0) swap(tmp.a, tmp.b);
                    
                    Line tmp2 = Line(t[3-i-j], Point(t[3-i-j].x, t[3-i-j].y - 1));
                    if (tmp.LineCrossLine(tmp2) != 2) continue;
                    Point tp = tmp.CrossPoint(tmp2);
                    if (dcmp(tp.y - t[3-i-j].y) < 0) tmp.kind = 1;
                        else tmp.kind = -1;    
                    line.pbk(tmp);
                }
            }
        }
        init();
        solve();    
    }
    return 0;
}

hdu 3255 Farming  （矩形体积并）

转载自：http://blog.csdn.net/ivan_zjj/article/details/7741133

题意：

有N块农田，每块农田中种一种作物，每种作物都有一个价格，当在同一区域内种植了两种不同的作物时，作物价格大的生存下来，生命值小的死亡。求最后的所有作物的能买的总钱数。

思路：

扫描线求体积并，和前面的一个求体积交差不多。 我们可以将作物的价格看作是立体的高，这样就可以直接枚举Z轴求二维矩形面积并了。本题关键是转化，思路很好。

先将蔬菜价值（即高度）从小到大排序，然后一层一层地开始扫描，计算每层中的面积并，这个就同二维扫描一样。
 　　  然后再用面积乘以这层的高度，即得到该层的体积并。然后所有层的体积加起来，即为所求。

把价值等价成高，从价格高的开始枚举

假如i的价格>j的价格，先把价格为i的矩形更新到线段树中，然后价格为i的总价值就是面积（S1）*价格i

然后对于价格j，把i和j价格的矩形都更新到线段树中，然后此时属于j的总价值就是现在的(总面积(S2)-S1)*j；

想象一下长方体，交错在一次，有高有低，怎么求出整个立体形的体积）

#include<stdio.h>
#include<string.h>
#include<algorithm>
int N , M ;
int h[5] ;
const int MAXN = 30010 ;
struct point{
    int x, y ;
    void get(){
        scanf("%d %d",&x,&y) ;
    }
};
struct Node{
    point p1 , p2 ;
    int h;
}p[MAXN] ;

struct Seg{
    int l ,r , h , s ;
    Seg(){}
    Seg(int a, int b ,int c, int d)
    :l(a) , r(b) , h(c) , s(d){}
    bool operator<(const Seg& cmp) const{
        return h < cmp.h ;
    }
}pp[MAXN<<1] ;

int x[MAXN<<1] ;

int find(int val , int l, int r){
    while( l<r ) {
        int mid = (l + r)>> 1;
        if( x[mid] < val )  l = mid + 1 ;
        else        r = mid ;
    }
    return l ;
}

int col[MAXN<<3] , sum[MAXN<<3] ;

void pushup(int l, int r, int idx){
    if( col[idx] )  sum[idx] = x[r+1] - x[l] ;
    else if( l == r )  sum[idx] = 0 ;
    else{
        sum[idx] = sum[idx<<1] + sum[idx<<1|1] ;
    }
}

void update(int l, int r, int idx, int a , int b , int v){
    if(l==a && b==r){
        col[idx] += v ;
        pushup(l , r , idx);
        return ;
    }
    int mid = (l + r)>> 1;
    int ls = idx<<1 , rs = idx<<1|1 ;
    if( b<=mid )    update(l , mid ,ls , a , b, v);
    else if( mid<a )    update(mid+1, r, rs ,a ,b , v );
    else{
        update( l ,mid , ls , a, mid,  v );
        update( mid+1,  r, rs, mid+1, b , v );
    }
    pushup(l ,r, idx);
}

void solve(){
    std::sort(h+1, h+M+1) ;
    h[0] = 0 ;
    __int64 res = 0 ;
    for(int i=1;i<=M;i++){
        int hh = h[i] ;
        int m = 0 ;
        for(int j=1;j<=N;j++){
            if( p[j].h >= hh ){
                pp[m] = Seg( p[j].p1.x , p[j].p2.x ,p[j].p1.y , 1 ) ;
                x[m++] = p[j].p1.x ;
                pp[m] = Seg( p[j].p1.x , p[j].p2.x ,p[j].p2.y , -1 );
                x[m++] = p[j].p2.x ;
            }
        }
        std::sort( x , x+m );
        std::sort(pp ,pp+m );
        int n = 1 ;
        for(int j=1;j<m;j++){
            if( x[j-1] != x[j] )    x[n++] = x[j] ;
        }
        n-- ;
        memset(col, 0, sizeof(col) );
        memset(sum, 0 ,sizeof(sum) );
        __int64 ans = 0 ;

        for(int j=0;j<m-1;j++){
            int s = find( pp[j].l, 0 ,n );
            int e = find( pp[j].r , 0 , n ) - 1 ;
            if(s <= e)  update(0, MAXN<<1 ,1 , s, e ,pp[j].s );
            ans += (__int64)(sum[1])*(__int64)( pp[j+1].h - pp[j].h );
        }
        res += ans*(__int64)( h[i] - h[i-1] ) ;
    }
    printf("%I64d
",res);
}

int main(){
    int ncas , cas ;
    scanf("%d",&ncas);
    for(cas=1 ;cas<=ncas ; cas++){
        scanf("%d %d",&N, &M );
        for(int i=1;i<=M;i++){
            scanf("%d",&h[i]);
        }
        for(int i=1;i<=N;i++){
            p[i].p1.get() ;
            p[i].p2.get() ;
            int a ;
            scanf("%d",&a);
            p[i].h = h[a] ;
        }
        printf("Case %d: ",cas);
        solve() ;
    }
    return 0 ;
}

pOj 2932 Coneology  （圆的包含关系）

转载自：http://blog.csdn.net/ch2010091/article/details/7795171

给出了n个互不相交的圆。 各个圆之间有可能一个完全包含了另一个。这里包含就是一个圆整个都被另一个圆圈再里面。

现在求那些没有被包含的圆的序号。 没有圆存在相交关系。

分析：

因为题目内的圆不存在相交的情况， 直接把储存每个圆的左端点和右端点的x坐标。然后从左扫到右，如果满足是最外面的圆，就储存在set里面。如何判断满足，就是对每一个x，如果是左端点的x坐标就来判断其对应的圆，是否是在set中储存的圆内，如果不是 ，就存到set中。如果是右端点的x坐标，就pop出该圆。

考虑扫描线,选择一个圆的最左点和最右点作为事件点.然后用一条竖直线从左到右扫一遍.
    维护一个数据结构,里面保存着和扫描线相交的powerful 圆.
    如果一个事件是某圆的最右点,并且该圆在数据结构中,就意味着要把这个圆删掉.
    如果一个事件是某圆的最左点,当它不被其他圆包含时,就意味着可能要把它加入到我们的数据结构中,
怎么检查它有没有被其他圆包含呢?我们的数据结 构里的圆都是一些 powerful 圆,他们互不相交,也就是
说他们在当前的扫描线上占的区间也互不相交, 如果我们只是记录圆心在扫描线的投影, 把高的投影称为前,
把低的投影低称为后,那么可能与当前圆发生关系的只是它的前一个圆,后一个圆.

加入set的集合的元素是.额.是不相互包含的圆.也就是说两两关系是相离.那么一个圆只要和它上下两圆无关系，自然也不会和这之外的圆有关系了.

然后这里判断一个圆的上下，就没有那么麻烦了.按圆心位置高下来就行.即能和当前圆发生关系的就只有它上下的圆。毕竟加入set的集合的圆都是没有关系的.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<set>
#include <cmath>
#include<algorithm>
using namespace std;
const int L=50001;
const double eps=0.0;
struct point
{
    double x,y,r;
    int va,id;
}cir[L];
struct node
{
    double x;
    int id,flag;
}lr[L*2];
set<int> seg;
typedef set<int>::iterator it;
bool cmp(point a,point b)
{
    return a.y<b.y || a.y==b.y && a.x<b.x;
}
bool cmp1(node a,node b)
{
    return a.x<b.x;
}
bool pr(point a,point b)
{
    return a.x==b.x && a.y==b.y;
}
double dis(point a,point b)
{
    a.x-=b.x;a.y-=b.y;
    return sqrt(a.x*a.x+a.y*a.y);
}
int check(point a,point b)
{
    if(pr(a,b))
        if(a.r>b.r-eps) return 1;
    if(a.r<b.r) return 0;
    double d=dis(a,b);
    if(d<a.r-b.r-eps) return 1;
    return 0;
}
void slove(int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        if(lr[i].flag==0)
        {
            it idx=seg.insert(lr[i].id).first;
            it be=idx,ed=idx;
            if(seg.size()>=2)
            {
                if(be==seg.begin())
                {
                    j=*++be;
                   if(check(cir[j],cir[lr[i].id]))
                        {   
                            cir[lr[i].id].va=1;
                            seg.erase(lr[i].id);
                        }
                }
                else if(++ed==seg.end())
                {
                    j=*--be;
                    if(check(cir[j],cir[lr[i].id]))
                        {
                            cir[lr[i].id].va=1;
                            seg.erase(lr[i].id);
                        }
                }
                else
                {
                    ed--;
                    if((check(cir[*--be],cir[lr[i].id])) || (check(cir[*++ed],cir[lr[i].id])))
                        {
                            cir[lr[i].id].va=1;
                            seg.erase(lr[i].id);
                        }
                }
            }
        }
        else
            seg.erase(lr[i].id);
    }
}
int ans[L];
int main()
{
    int i,j,n,m;
    while(~scanf("%d",&n))
    {
        j=0;
        for(i=0;i<n;i++)
        {
            scanf("%lf %lf %lf",&cir[i].r,&cir[i].x,&cir[i].y);
            cir[i].id=i;
            cir[i].va=0;
        }
        sort(cir,cir+n,cmp);
        for(i=0;i<n;i++)
        {
            lr[j].id=i;lr[j].x=cir[i].x-cir[i].r;lr[j++].flag=0;
            lr[j].id=i;lr[j].x=cir[i].x+cir[i].r;lr[j++].flag=1;
        }
        sort(lr,lr+j,cmp1);
        slove(j);
        j=0;
        for(i=0;i<n;i++)
            if(cir[i].va==0) ans[j++]=cir[i].id+1;
        printf("%d
",j);
        sort(ans,ans+j);
        for(i=0;i<j;i++)
            printf("%d%c",ans[i],i==j-1?'
':' ');
    }
    return 0;
}