COJ1107 UVA12296 Pieces and Discs 2011湖南省赛H题

把每个交点映射为单独的id，map去重。对每个点建立相邻点的链表。枚举点，用相邻点链表找最左点，迭代绕出凸包，枚举圆判凸包与圆相交。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
using namespace std;
const int maxn = 41;
const int maxm = maxn * maxn;
const double eps = 1e-8;
const double pi = acos(-1.0);
int dcmp(double x)
{
    if(x < -eps) return -1;
    return x > eps;
}
struct Point
{
    double x, y, r;
    bool operator <(const Point &b)const
    {
        if(dcmp(x - b.x) == 0)
            return y < b.y;
        return x < b.x;
    }
};
typedef struct
{
    Point s, e;
    double ang, d;
} Line;

inline double det(double x1, double y1, double x2, double y2)
{
    return x1 * y2 - x2 * y1;
}
double cross(Point a, Point b, Point c)
{
    return det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}
Point MakePoint(double xx, double yy)
{
    Point res;
    res.x = xx, res.y = yy;
    return res;
}


int n, m, L, W, pnum;
vector<Point> ap;
vector<int> lp[maxn], adjp[maxm];
vector<Line> l;
vector<double> ans[maxn];
map<Point, int> M;
Point c[maxn];
bool visp[maxm];

Line SetLine(Point a, Point b)
{
    Line l;
    l.s = a;
    l.e = b;
    l.ang = atan2(b.y - a.y, b.x - a.x);
    if(dcmp(a.x - b.x)) l.d = (a.x * b.y - b.x * a.y) / fabs(a.x - b.x);
    else l.d = (a.x * b.y - b.x * a.y) / fabs(a.y - b.y);
    return l;
}
double dotdet(double x1, double y1, double x2, double y2)
{
    return x1 * x2 + y1 * y2;
}
double dot(Point a, Point b, Point c)
{
    return dotdet(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}
int betweenCmp(Point a, Point b, Point c)
{
    return dcmp(dot(a, b, c));
}
bool segcross(Point a, Point b, Point c, Point d, Point &p)
{
    double s1, s2, s3, s4;
    int d1, d2, d3, d4;
    d1 = dcmp(s1 = cross(a, b, c));
    d2 = dcmp(s2 = cross(a, b, d));
    d3 = dcmp(s3 = cross(c, d, a));
    d4 = dcmp(s4 = cross(c, d, b));
    if((d1 ^ d2) == -2 && (d3 ^ d4 == -2))
    {
        p.x = (c.x * s2 - d.x * s1) / (s2 - s1);
        p.y = (c.y * s2 - d.y * s1) / (s2 - s1);
        return true;
    }
    if(d1 == 0 && betweenCmp(c, a, b) <= 0)
    {
        p = c;
        return true;
    }
    if(d2 == 0 && betweenCmp(d, a, b) <= 0)
    {
        p = d;
        return true;
    }
    if(d3 == 0 && betweenCmp(a, c, d) <= 0)
    {
        p = a;
        return true;
    }
    if(d4 == 0 && betweenCmp(b, c, d) <= 0)
    {
        p = b;
        return true;
    }
    return false;
}

bool CrossPoint(const Line &la, const Line &lb, Point &p)
{
    return segcross(la.s, la.e, lb.s, lb.e, p);
}
bool Parallel(const Line &la, const Line &lb)
{
    return !dcmp( (la.e.x - la.s.x) * (lb.e.y - lb.s.y) -
                  (la.e.y - la.s.y) * (lb.e.x - lb.s.x) );
}
double PolygonArea(vector<int> p)
{
    if(p.size() < 4) return 0.0;
    double s = ap[p[0]].y * (ap[p[p.size() - 2]].x - ap[p[1]].x);
    for(int i = 1; i < p.size() - 1; ++ i)
        s += ap[p[i]].y * (ap[p[i - 1]].x - ap[p[i + 1]].x);
    return fabs(s * 0.5);
}
inline double CalLen(double a, double b)
{
    return sqrt(a * a + b * b);
}
inline double CalDis(Point a, Point b)
{
    return CalLen(a.x - b.x, a.y - b.y);
}
inline bool InCir(Point a, Point b)
{
    return dcmp(CalDis(a, b) - b.r) < 0;
}
inline bool OnCir(Point a, Point b)
{
    return dcmp(CalDis(a, b) - b.r) == 0;
}
double DisPtoL(Point p, Point a, Point b)
{
    return fabs(cross(p, a, b)) / CalDis(a, b);
}
bool EqualPoint(Point a, Point b)
{
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
bool SegIntersCircle(Point a, Point b, Point c)
{
    Point t = c;
    t.x += a.y - b.y;
    t.y += b.x - a.x;
    return cross(a, c, t) * cross(b, c, t) < eps &&
           DisPtoL(c, a, b) - c.r < -eps;
}
bool JudgePiece(int i, vector<int> ps)
{
    int j, k, cnt = 0;
    for(j = 1; j < ps.size(); ++ j)
    {
        if(InCir(ap[ps[j]], c[i])) return true;
        else if(OnCir(ap[ps[j]], c[i])) ++ cnt;
    }
    if(cnt >= 2) return true;
    for(j = 1; j < ps.size(); ++ j)
        for(k = j + 1; k < ps.size(); ++ k)
        {
            if(SegIntersCircle(ap[ps[j]], ap[ps[k]], c[i]))
                return true;
        }
    for(j = 1; j < ps.size(); ++ j)
        if(cross(ap[ps[j - 1]], ap[ps[j]], c[i]) < -eps) return false;
    return true;
}
void FindPiece(int s0, int s1)
{
    vector<int> ps;
    int i, j, nex = s1, ori = s0;
    double s;
    ps.push_back(s0);
    ps.push_back(s1);
    while(nex != ori)
    {
        nex = -1;
        for(i = 0; i < adjp[s1].size(); ++ i)
        {
            if(EqualPoint(ap[adjp[s1][i]], ap[s0])) continue;
            if(cross(ap[s0], ap[s1], ap[adjp[s1][i]]) > -eps &&
                    (nex == -1 || cross(ap[s1], ap[nex], ap[adjp[s1][i]]) > eps))
                nex = adjp[s1][i];
        }
        if(nex != -1 && (!visp[nex] || nex == ori))
            ps.push_back(nex);
        else return;
        s0 = s1, s1 = nex;
    }
    s = PolygonArea(ps);
    if(!dcmp(s)) return;
    for(i = 0; i < m; ++ i)
        if(JudgePiece(i, ps))
            ans[i].push_back(s);
}

bool cmp(const int &a, const int &b)
{
    if(dcmp(ap[a].x - ap[b].x) == 0)
        return ap[a].y < ap[b].y;
    return ap[a].x < ap[b].x;
}
int main()
{
    int i, j, pnum;
    double sx, sy, ex, ey;
    while(scanf("%d%d%d%d", &n, &m , &L, &W), n | m | L | W)
    {
        l.clear();
        n += 4;
        M.clear();
        ap.clear();
        memset(visp, 0, sizeof(visp));
        l.push_back(SetLine(MakePoint(0, 0), MakePoint(L, 0)));
        l.push_back(SetLine(MakePoint(L, 0), MakePoint(L, W)));
        l.push_back(SetLine(MakePoint(L, W), MakePoint(0, W)));
        l.push_back(SetLine(MakePoint(0, W), MakePoint(0, 0)));
        for(i = 4; i < n; ++ i)
        {
            scanf("%lf%lf%lf%lf", &sx, &sy, &ex, &ey);
            l.push_back(SetLine(MakePoint(sx, sy), MakePoint(ex, ey)));
        }
        for(i = 0; i < m; ++ i)
            scanf("%lf%lf%lf", &c[i].x, &c[i].y, &c[i].r), ans[i].clear();
        for(i = 0; i < n; ++ i) lp[i].clear();
        for(i = pnum = 0; i < n; ++ i)
            for(j = i + 1; j < n; ++ j)
            {
                Point tmp;
                if(CrossPoint(l[i], l[j], tmp))
                {
                    if(!M.count(tmp))
                        adjp[pnum].clear(), M[tmp] = pnum ++, ap.push_back(tmp);
                    lp[i].push_back(M[tmp]);
                    lp[j].push_back(M[tmp]);
                }
            }
        for(i = 0; i < n; ++ i)
        {
            sort(lp[i].begin(), lp[i].end(), cmp);
            for(j = 1; j < lp[i].size(); ++ j)
            {
                if(!EqualPoint(ap[lp[i][j]], ap[lp[i][j - 1]]))
                {
                    adjp[lp[i][j]].push_back(lp[i][j - 1]);
                    adjp[lp[i][j - 1]].push_back(lp[i][j]);
                }
            }
        }
        for(i = 0; i < pnum; ++ i)
        {
            if(!visp[i])
            {
                visp[i] = true;
                for(j = 0; j < adjp[i].size(); ++ j)
                    if(!visp[adjp[i][j]])FindPiece(i, adjp[i][j]);
            }
        }
        for(i = 0; i < m; ++ i)
        {
            sort(ans[i].begin(), ans[i].end());
            printf("%d", ans[i].size());
            for(j = 0; j < ans[i].size(); ++ j)
                printf(" %.2f", ans[i][j]);
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}