LA2572计算几何+离散化+面的覆盖

/*
  后来看到的极角排序，值得一看：http://blog.csdn.net/zxy_snow/article/details/6700847

LA2572计算几何

解题思路：
1、小圆面是由小圆弧围成。那么找出每条小圆弧，如果小圆弧，在小圆弧中点上下左右进行微小位移的所得的点一定在一个小圆面内。
找到最后覆盖这个小点的圆一定是可见的。
2、圆上的点按照相邻依次排序的关键量为极角（0,2PI）
3、用中心点代替圆弧本身是否被圆覆盖


感悟：
这道题是一道计算几何思维非常综合的题目，如下：
1、离散化和按顺序扫描：
因为几何图形是连续的，而计算机只能处理一些离散的测试点。所以找到关键的离散化方法很重要。
就像这道题：关键问题：可见的这些小圆面是属于哪个圆的？
离散测试点找到所有小圆面中至少一个点。所以我们离散的过程要保证找到所有的情况，所以枚举了所有的圆弧。
类似的问题：
LA4127山的轮廓线，离散点是直线与直线的交点
UVA10969美梦，离散点是圆的交点
UVA11177多边形怪兽，离散点是直线与圆的交点
2、添加首尾测试点（离散边界）
例如这道的：
Arf[0]=0.0;
Arf[1]=2*M_PI；
3、放大法保留精度
例：
cin>>x>>y>>r;
x=1e10*x;y=1e10*y;r=1e10*r;//这里非常重要，因为我们是进行点的微小移动，这样等于将整张图放大了，保留了精度

*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <list>
#include <set>
#include <algorithm>
#define rec(i,n) for(int i=1;i<=n;i++)
#define INF 0x3f3f3f3f
#define eps 1e-7
#define eps2 1e-3
using namespace std;

double move[5][2]= {{0,eps2},{0,-eps2},{eps2,0},{-eps2,0}};
//微小偏移量，至少是3个不同的方向，这里取上下左右四个比较方便,记住偏移量的数量就比eps本身要大，不然等于无效
struct Point
{
    double x,y;
    Point() {}
    Point(double xx,double yy)
    {
        x=xx;
        y=yy;
    }
};
struct Circle
{
    Point O;
    double r;
    Circle() {}
    Circle(Point O1,double r1)
    {
        O=O1;
        r=r1;
    }
    Point point(double a)
    {
        return Point(O.x+cos(a)*r,O.y+sin(a)*r);
    }
};
typedef Point Vector;

bool operator==(Point A,Point B)
{
    if ((fabs(A.x-B.x)<1e-10) && (fabs(A.y-B.y)<1e-10)) return true;
    else return false;
}
Vector operator-(Point A,Point B)//表示A指向B
{
    return Vector(A.x-B.x,A.y-B.y);
}
Vector operator*(Vector A,double k)
{
    return Vector(A.x*k,A.y*k);
}
Vector operator+(Point A,Point B)//表示A指向B
{
    return Vector(B.x+A.x,B.y+A.y);
}
double Dot(Vector A,Vector B)
{
    return A.x*B.x+A.y*B.y;
}
double Length(Vector A)
{
    return sqrt(Dot(A,A));
}
double Cross(Vector A,Vector B)
{
    return A.x*B.y-A.y*B.x;
}
int dcmp(double x)
{
    if(fabs(x)<1e-10) return 0;
    else if(x>0) return 1;
    else return -1;
}
double angle(Vector v)
{
    return atan2(v.y,v.x);
}
int getCircleInter(Circle c1, Circle c2,vector<Point>& sol1,vector<Point>& sol2)
{
    double d=Length(c1.O-c2.O);
    if(dcmp(d)==0)
    {
        if(dcmp(c1.r-c2.r)==0) return -1;//两圆重合
        return 0;
    }
    if(dcmp(c1.r+c2.r-d)<0) return 0;
    if(dcmp(fabs(c1.r-c2.r)-d)>0) return 0;

    double a=angle(c2.O-c1.O);
    double da=acos((c1.r*c1.r+d*d-c2.r*c2.r)/(2*c1.r*d));

    Point p1=c1.point(a-da),p2=c1.point(a+da);

    if (p1==p2) return 1;
    sol1.push_back(p1),sol2.push_back(p1);
    sol1.push_back(p2);
    sol2.push_back(p2);
    return 2;
}
int n;
Circle CC[110];//圆
vector<Point> CP[110];//每个圆上的交点
double Arf[410];//圆心角
double getangle(Vector v)//核心函数，返回向量的极角
{
    double x=v.x;
    double y=v.y;
    if(fabs(y)<eps) if(x>0) return 0;
        else return M_PI;
    if(fabs(x)<eps) if(y>0) return 0.5*M_PI;
        else return 1.5*M_PI;
    double arf=acos(fabs(x)/(sqrt(x*x+y*y)));
    if(x>0) if(y>0) return arf;
        else return 2*M_PI-arf;
    if(y>0) return M_PI-arf;
    else return M_PI+arf;
}
Point GetMid(double a,double b,double r,double x,double y)//圆上两点，获得中点的坐标
{
    double arf=(b+a)/2;
    double xx=r*cos(arf)+x;
    double xy=r*sin(arf)+y;
    Point P=Point(xx,xy);
//    P.print();
    return P;
}
bool PInCircle(Point P,Circle C)//判断点在圆内
{
    double dis=Length(P-C.O);
    if (dis-C.r>1e-10) return false;
    else return true;
}
bool see[410];//圆是否可见
int main()
{
    while(cin>>n && n>0)
    {
        memset(see,0,sizeof(see));
        see[n]=true;//最后一个圆一定可见，不必判断
        for(int i=1; i<=n; i++)//读取信息
        {
            double x,y,r;
            cin>>x>>y>>r;
            x=1e10*x;y=1e10*y;r=1e10*r;//这里非常重要，因为我们是进行点的微小移动，这样等于将整张图放大了，保留了精度
            CC[i]=Circle(Point(x,y),r);
        }
        for(int i=1; i<=n; i++) CP[i].clear();
        for(int i=1; i<n; i++)//获得圆上的交点
            for(int j=i+1; j<=n; j++)
                getCircleInter(CC[i],CC[j],CP[i],CP[j]);
        for(int i=1; i<=n; i++) //枚举前n-1个圆上的圆弧
        {//当CP[i].size()为0时要特判，这是和其他圆的关系要么包含，要么被包含，比较半径即可
            int k=CP[i].size();
            Arf[0]=0.0;
            Arf[1]=2*M_PI;//添加两个点，局部细分：这里也是重点：图形离散化解决了穷举的难题，同时也意味着可加上一些特殊的点
            //上面两个点的加入，也解决了圆上0和1个点的问题
            for(int j=0; j<k; j++)
            {
                double arf=getangle(CP[i][j]-CC[i].O);//重点：角度的计算，其实就是圆心指向圆上的点的向量的角度啊
                Arf[j+2]=arf;
            }
            sort(Arf,Arf+k+2);
            k=unique(Arf,Arf+k+2)-Arf;//去除重复点

            for(int j=0; j<k; j++) //枚举每条弧
            {
                Point Mid=GetMid(Arf[j],Arf[(j+1)%k],CC[i].r,CC[i].O.x,CC[i].O.y);

                bool ok=true;//表示这条圆弧可见
                for(int l=i+1; l<=n; l++) //判断中点是否可见
                    if (PInCircle(Mid,CC[l])) ok=false;
                if(ok)//这条弧可见
                {
                    int num[5]= {-1,-1,-1,-1};
                    Point M[5];
                    for(int l=0; l<4; l++)//向四个方向上枚举微小的位移点
                    {
                        M[l].x=Mid.x+move[l][0];
                        M[l].y=Mid.y+move[l][1];
                    }
                    for(int ll=0; ll<4; ll++)
                        for(int l=1; l<=n; l++) //判断最终覆盖可见点的圆的序号
                            if(PInCircle(M[ll],CC[l])) num[ll]=l;
                    for(int ll=0; ll<4; ll++)
                        if(num[ll]!=-1) see[num[ll]]=true;
                }
            }
        }

        int ans=0;
        for(int i=1; i<=n; i++) if(see[i]) ans++;
        cout<<ans<<endl;
    }
    return 0;
}