HDU3644 2010 Asia Regional Hangzhou Site Online Contest D A Chocolate Manufacturer's Problem

1、判断多边形有向边顺、逆时针：

取最右点p[i]，p[i-1]->p[i]与p[i]->p[i+1]成右手关系则为逆时针。

2、判断点与简单多边形位置关系：

参考文献：王学军,沈连婠,朱绍源等.基于左边的点在简单多边形内的判别算法[J].机械工程师,2006,(2):53-54.

给定一个简单多边形，判别点u在多边形G内外的判断算法步骤：
Step1：过u作一水平射线；

Step2：求出射线与简单多边形G的交点；

Step3：若交点为0，则u在G外，结束；

Step4：若交点数大于0，求出与u点距离最近交点v；

Step5：找到交点v所在边的两顶点，记p1为p[i]，p2为p[i+1]；

Step6：判断交点v是否是顶点，若v与p[i]重合，则p1为p[i-1]，若v与p[i+1]重合，则p2为p[i+2]；

Step7：判断 vu 到 vp1 沿逆时针方向的角度是否小于 vp2到vp1沿逆时针方向的角度，若是，则u在G内，否则在外，结束。

 

3、模拟退火，在边上选采样点可避免直接采样到多边形外，其他方面在方法上没有特别之处。参数调整比较纠结，改天编译器变了或者HDU数据变了这代码就不一定能AC了。

 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
const int maxn = 55;
const double eps = 1e-8;
const double pi = acos(-1.0);
int dcmp(double x)
{
    if(x > eps) return 1;
    return x < -eps ? -1 : 0;
}
inline double min(double a, double b)
{return a < b ? a : b;}
inline double max(double a, double b)
{return a > b ? a : b;}
inline double Sqr(double x)
{return x * x;}
/**************************************************/
//点及关于点、线的操作 
struct Point
{
    double x, y;
    Point(){x = y = 0;}
    Point(double a, double b)
    {x = a, y = b;}
    inline Point operator-(const Point &b)const
    {return Point(x - b.x, y - b.y);}
    inline Point operator+(const Point &b)const
    {return Point(x + b.x, y + b.y);}
    inline Point operator-()
    {return Point(-x, -y);}
    inline Point operator*(const double &b)const
    {return Point(x * b, y * b);}
    inline double dot(const Point &b)const
    {return x * b.x + y * b.y;}
    inline double cross(const Point &b, const Point &c)const
    {return (b.x - x) * (c.y - y) - (c.x - x) * (b.y - y);}
    inline double Dis(const Point &b)const
    {return sqrt((*this - b).dot(*this - b));}
    inline bool operator<(const Point &b)const
    {
        if(!dcmp(x - b.x)) return y < b.y;
        return x < b.x;
    }
    inline bool operator>(const Point &b)const
    {return b < *this;}
    inline bool operator==(const Point &b)const
    {return !dcmp(x - b.x) && !dcmp(y - b.y);}
    inline bool InLine(const Point &b, const Point &c)const
    {return !dcmp(cross(b, c));}
    inline bool OnSeg(const Point &b, const Point &c)const//包括端点
    {return InLine(b, c) && (*this - c).dot(*this - b) < eps;}
    inline bool InSeg(const Point &b, const Point &c)const//不包括端点
    {return InLine(b, c) && (*this - c).dot(*this - b) < -eps;}
    double ToSeg(const Point&, const Point&)const;
};
/**************************************************/
bool Parallel(const Point &a, const Point &b, const Point &c, const Point &d)
{return !dcmp(a.cross(b, a + d - c));}
Point LineCross(const Point &a, const Point &b, const Point &c, const Point &d)
{
    double u = a.cross(b, c), v = b.cross(a, d);
    return Point((c.x * v + d.x * u) / (u + v), (c.y * v + d.y * u) / (u + v));
}
double Point::ToSeg(const Point &b, const Point &c)const
{
    Point t(x + b.y - c.y, y + c.x - b.x);
    if(cross(t, b) * cross(t, c) > eps)
        return min(Dis(b), Dis(c));
    return Dis(LineCross(*this, t, b, c));
}
bool SegCross(const Point &a, const Point &b, 
        const Point &c, const Point &d, Point &p)//包括端点
{
    if(Parallel(a, b, c, d)) return false;
    if(a.cross(b, c) * a.cross(b, d) <= 0 && c.cross(d, a) * c.cross(d, b) <= 0)
    {
        p = LineCross(a, b, c, d);
        return true;
    }
    return false;
}
/**************************************************/
Point p[maxn];
int n;
double r;
/**************************************************/
double AngCounterClock(double start, double end)
{return end - start + (end > start - eps ? 2 * pi : 0);}
bool InSimplePolygon(Point u, Point p[], int n/*double neg_inf*/)
//判断点在简单多边形内，不包括边界，多边形点为逆时针
{
    double neg_inf = -1e20, angvu, angvp1, angvp2;
    Point v(0, u.y), p1, p2, tmp;
    int i, id;//距离u最近交点对应线段起始点id
    bool flag = false;
    p[n] = p[0];
    //设u->v为水平负向射线
/*    for(i = 0, neg_inf = 0; i < n; ++ i) neg_inf = min(neg_inf, p[i].x);
    neg_inf -= 100.0;    */
    v.x = neg_inf;
    for(i = 0; i < n; ++ i)
    {
        if(u.OnSeg(p[i], p[i + 1])) return false;
        if(!SegCross(u, v, p[i], p[i + 1], tmp)) continue;
        flag = true;
        if(tmp.x - v.x > eps) v.x = tmp.x, id = i;
    }
    if(!flag) return false;
    p1 = v == p[id] ? p[(id + n - 1) % n] : p[id];
    p2 = v == p[id + 1] ? p[(id + 2) % n] : p[id + 1];
    angvu = atan2(u.y - v.y, u.x - v.x);
    angvp1 = atan2(p1.y - v.y, p1.x - v.x);
    angvp2 = atan2(p2.y - v.y, p2.x - v.x);
    return AngCounterClock(angvu, angvp1) < 
        AngCounterClock(angvp2, angvp1) - eps;
}
/**************************************************/
double PtoPolygon(Point u, Point p[], int n)//点到多边形边、点的最近距离 
{
    int i;
    double res = 1e120;
    p[n] = p[0];
    for(i = 0; i < n; ++ i)
        res = min(res, u.ToSeg(p[i], p[i + 1]));
    return res;
}
/**************************************************/
//模拟退火
const int maxsam = 20;
const int pacelen = 5;
const double depace = 0.57;
const double endeps = 1e-3;
Point sam[maxsam];
double mindis[maxsam];
bool SA(double r)
{
    int i, j, samnum;
    Point tmp;
    double tmpdis;
    double maxx = -1e30, maxy = -1e30, minx = 1e30, miny = 1e30;
    for(i = 0; i < n; ++ i)
    {
        maxx = max(p[i].x, maxx);
        maxy = max(p[i].y, maxy);
        minx = min(p[i].x, minx);
        miny = min(p[i].y, miny);
    }
    samnum = maxsam < n ? maxsam : n;
    double pace = sqrt(Sqr(maxx - minx) + Sqr(maxy - miny));
    for(i = 0; i < samnum; ++ i)//随机选边，随机比例选择边上的点作为采样点 
    {
        j = rand() % n;
        sam[i] = p[j] + (p[j + 1] - p[j]) * (rand() / 32767.0);
        mindis[i] = 0;
    }
    for(; pace > endeps; pace *= depace)
        for(i = 0; i < samnum; ++ i)
            for(j = 0; j < pacelen; ++ j)
            {
                tmp.x = sam[i].x + cos((double)rand()) * pace;
                tmp.y = sam[i].y + cos((double)rand()) * pace;
                if(!InSimplePolygon(tmp, p, n)) continue;
                tmpdis = PtoPolygon(tmp, p, n);
                if(tmpdis > r - endeps) return true;
                if(tmpdis > mindis[i])
                {
                    sam[i] = tmp;
                    mindis[i] = tmpdis;
                }
            }
    return false;
}
/**************************************************/
void MakeCounterClock(Point p[], int n)//顺时针则反转多边形的有向边 
{
    int i, id = 0;
    p[n] = p[0];
    for(i = 0; i < n; ++ i) if(p[i].x > p[id].x) id = i;
    if(p[id].cross(p[id + 1], p[(id + n - 1) % n]) > eps) return;
    Point tmp;
    for(i = n - 1 >> 1; i >= 0; -- i)
        tmp = p[i], p[i] = p[n - i - 1], p[n - i - 1] = tmp;
}
int main()
{
    srand(419);
    while(scanf("%d", &n) && n)
    {
        for(int i = 0; i < n; ++ i)
            scanf("%lf%lf", &p[i].x, &p[i].y);
        MakeCounterClock(p, n);
        scanf("%lf", &r);
        printf(SA(r) ? "Yes\n" : "No\n");
    }
    return 0;
}