zoukankan      html  css  js  c++  java
  • 简单几何(点的位置) POJ 1584 A Round Peg in a Ground Hole

    题目传送门

    题意:判断给定的多边形是否为凸的,peg(pig?)是否在多边形内,且以其为圆心的圆不超出多边形(擦着边也不行)。

    分析:判断凸多边形就用凸包,看看点集的个数是否为n。在多边形内用叉积方向来判断,最后再用点到直线的距离和半径比大小(不是线段)

    /************************************************
    * Author        :Running_Time
    * Created Time  :2015/11/2 星期一 19:49:13
    * File Name     :POJ_1584.cpp
     ************************************************/
    
    #include <cstdio>
    #include <algorithm>
    #include <iostream>
    #include <sstream>
    #include <cstring>
    #include <cmath>
    #include <string>
    #include <vector>
    #include <queue>
    #include <deque>
    #include <stack>
    #include <list>
    #include <map>
    #include <set>
    #include <bitset>
    #include <cstdlib>
    #include <ctime>
    using namespace std;
    
    #define lson l, mid, rt << 1
    #define rson mid + 1, r, rt << 1 | 1
    typedef long long ll;
    const int N = 1e5 + 10;
    const int INF = 0x3f3f3f3f;
    const int MOD = 1e9 + 7;
    const double EPS = 1e-10;
    const double PI = acos (-1.0);
    int dcmp(double x)  {       //三态函数,减少精度问题
        if (fabs (x) < EPS) return 0;
        else    return x < 0 ? -1 : 1;
    }
    struct Point    {       //点的定义
        double x, y;
        Point () {}
        Point (double x, double y) : x (x), y (y) {}
        Point operator + (const Point &r) const {       //向量加法
            return Point (x + r.x, y + r.y);
        }
        Point operator - (const Point &r) const {       //向量减法
            return Point (x - r.x, y - r.y);
        }
        Point operator * (double p) const {       //向量乘以标量
            return Point (x * p, y * p);
        }
        Point operator / (double p) const {       //向量除以标量
            return Point (x / p, y / p);
        }
        bool operator < (const Point &r) const {       //点的坐标排序
            return x < r.x || (x == r.x && y < r.y);
        }
        bool operator == (const Point &r) const {       //判断同一个点
            return dcmp (x - r.x) == 0 && dcmp (y - r.y) == 0;
        }
    };
    typedef Point Vector;       //向量的定义
    Point read_point(void)   {      //点的读入
        double x, y;
        scanf ("%lf%lf", &x, &y);
        return Point (x, y);
    }
    double dot(Vector A, Vector B)  {       //向量点积
        return A.x * B.x + A.y * B.y;
    }
    double cross(Vector A, Vector B)    {       //向量叉积
        return A.x * B.y - A.y * B.x;
    }
    double polar_angle(Vector A)  {     //向量极角
        return atan2 (A.y, A.x);
    }
    double length(Vector A) {       //向量长度,点积
        return sqrt (dot (A, A));
    }
    double angle(Vector A, Vector B)    {       //向量转角,逆时针,点积
        return acos (dot (A, B) / length (A) / length (B));
    }
    Vector rotate(Vector A, double rad) {       //向量旋转,逆时针
        return Vector (A.x * cos (rad) - A.y * sin (rad), A.x * sin (rad) + A.y * cos (rad));
    }
    Vector nomal(Vector A)  {       //向量的单位法向量
        double len = length (A);
        return Vector (-A.y / len, A.x / len);
    }
    Point line_line_inter(Point p, Vector V, Point q, Vector W)    {        //两直线交点,参数方程
        Vector U = p - q;
        double t = cross (W, U) / cross (V, W);
        return p + V * t;
    }
    double point_to_line(Point p, Point a, Point b)   {       //点到直线的距离,两点式
        Vector V1 = b - a, V2 = p - a;
        return fabs (cross (V1, V2)) / length (V1);
    }
    double point_to_seg(Point p, Point a, Point b)    {       //点到线段的距离,两点式
        if (a == b) return length (p - a);
        Vector V1 = b - a, V2 = p - a, V3 = p - b;
        if (dcmp (dot (V1, V2)) < 0)    return length (V2);
        else if (dcmp (dot (V1, V3)) > 0)   return length (V3);
        else    return fabs (cross (V1, V2)) / length (V1);
    }
    Point point_line_proj(Point p, Point a, Point b)   {     //点在直线上的投影,两点式
        Vector V = b - a;
        return a + V * (dot (V, p - a) / dot (V, V));
    }
    bool can_seg_seg_inter(Point a1, Point a2, Point b1, Point b2)  {       //判断线段相交,两点式
        double c1 = cross (a2 - a1, b1 - a1), c2 = cross (a2 - a1, b2 - a1),
               c3 = cross (b2 - b1, a1 - b1), c4 = cross (b2 - b1, a2 - b1);
        return dcmp (c1) * dcmp (c2) < 0 && dcmp (c3) * dcmp (c4) < 0;
    }
    bool can_line_seg_inter(Point a1, Point a2, Point b1, Point b2)    {        //判断直线与线段相交,两点式
        double c1 = cross (a2 - a1, b1 - a1), c2 = cross (a2 - a1, b2 - a1);
        return dcmp (c1 * c2) <= 0;
    }
    bool on_seg(Point p, Point a1, Point a2)    {       //判断点在线段上,两点式
        return dcmp (cross (a1 - p, a2 - p)) == 0 && dcmp (dot (a1 - p, a2 - p)) < 0;
    }
    double area_triangle(Point a, Point b, Point c) {       //三角形面积,叉积
        return fabs (cross (b - a, c - a)) / 2.0;
    }
    double area_poly(Point *p, int n)   {       //多边形面积,叉积
        double ret = 0;
        for (int i=1; i<n-1; ++i)   {
            ret += fabs (cross (p[i] - p[0], p[i+1] - p[0]));
        }
        return ret / 2;
    }
    /*
        点集凸包,输入点的集合,返回凸包点的集合。
    	如果不希望在凸包的边上有输入点,把两个 <= 改成 <
    */
    vector<Point> convex_hull(vector<Point> ps) {
        sort (ps.begin (), ps.end ());		//x - y排序
        ps.erase (unique (ps.begin (), ps.end ()), ps.end ());	//删除重复点
        int n = ps.size (), k = 0;
        vector<Point> qs (n * 2);
        for (int i=0; i<n; ++i) {
            while (k > 1 && cross (qs[k-1] - qs[k-2], ps[i] - qs[k-1]) < 0)  k--;
            qs[k++] = ps[i];
        }
        for (int i=n-2, t=k; i>=0; --i)  {
            while (k > t && cross (qs[k-1] - qs[k-2], ps[i] - qs[k-1]) < 0)  k--;
            qs[k++] = ps[i];
        }
        qs.resize (k-1);
        return qs;
    }
    
    struct Circle   {
        Point c;
        double r;
        Circle () {}
        Circle (Point c, double r) : c (c), r (r) {}
        Point point(double a)   {
            return Point (c.x + cos (a) * r, c.y + sin (a) * r);
        }
    };
    struct Line {
        Point p;
        Vector v;
        double r;
        Line () {}
        Line (const Point &p, const Vector &v) : p (p), v (v) {
            r = polar_angle (v);
        }
        Point point(double a)   {
            return p + v * a;
        }
    };
    /*
        直线相交求交点,返回交点个数,交点保存在P中
    */
    int line_cir_inter(Line L, Circle C, double &t1, double &t2, vector<Point> &P)    {
        double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
        double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
        double delta = f * f - 4 * e * g;
        if (dcmp (delta) < 0)   return 0;
        if (dcmp (delta) == 0)  {
            t1 = t2 = -f / (2 * e); P.push_back (L.point (t1));
            return -1;
        }
        t1 = (-f - sqrt (delta)) / (2 * e); P.push_back (L.point (t1));
        t2 = (-f + sqrt (delta)) / (2 * e); P.push_back (L.point (t2));
        if (dcmp (t1) < 0 || dcmp (t2) < 0) return 0;
        return 2;
    }
    
    /*
        两圆相交求交点,返回交点个数。交点保存在P中
    */
    int cir_cir_inter(Circle C1, Circle C2, vector<Point> &P)    {
        double d = length (C1.c - C2.c);
        if (dcmp (d) == 0)  {
            if (dcmp (C1.r - C2.r) == 0)    return -1;      //两圆重叠
            else    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 = polar_angle (C2.c - C1.c);
        double da = acos ((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));        //C1C2到C1P1的角?
        Point p1 = C1.point (a - da), p2 = C2.point (a + da);
        P.push_back (p1);
        if (p1 == p2)   return 1;
        else    P.push_back (p2);
        return 2;
    }
    /*
        过点到圆的切线,返回切线条数,切线保存在V中
    */
    int point_cir_tan(Point p, Circle C, Vector *V) {
        Vector u = C.c - p;
        double dis = length (u);
        if (dis < C.r)  return 0;
        else if (dcmp (dis - C.r) == 0) {
            V[0] = rotate (u, PI / 2);  return 1;
        }
        else    {
            double ang = asin (C.r / dis);
            V[0] = rotate (u, -ang);
            V[1] = rotate (u, +ang);
            return 0;
        }
    }
    /*
        两圆的公切线,返回公切线条数,切线短点保存在a和b中
    */
    int cir_cir_tan(Circle A, Circle B, Point *a, Point *b) {
        int cnt = 0;
        if (A.r < B.r)  {
            swap (A, B);    swap (a, b);
        }
        double d = dot (A.c - B.c, A.c - B.c);
        double rsub = A.r - B.r, rsum = A.r + B.r;
        if (dcmp (d - rsub) < 0)   return 0;   //内含
        double base = polar_angle (B.c - A.c);
        if (dcmp (d) == 0 && dcmp (A.r - B.r) == 0) return -1;  //两圆重叠
        if (dcmp (d - rsub) == 0)   {       //内切,一条切线
            a[cnt] = A.point (base);    b[cnt] = B.point (base);    cnt++;
            return 1;
        }
        //有外公切线
        double ang = acos (rsub / d);
        a[cnt] = A.point (base + ang);  b[cnt] = B.point (base + ang);  cnt++;
        a[cnt] = A.point (base - ang);  b[cnt] = B.point (base - ang);  cnt++;
        if (d == rsum)  {
            a[cnt] = A.point (base);    b[cnt] = B.point (base + PI);   cnt++;
        }
        else if (dcmp (d - rsum) > 0)   {       //两条内公切线
            double ang2 = acos (rsum / d);
            a[cnt] = A.point (base + ang2); b[cnt] = B.point (base + ang2 + PI);    cnt++;
            a[cnt] = A.point (base - ang2); b[cnt] = B.point (base - ang2 + PI);    cnt++;
        }
        return cnt;
    }
    
    int main(void)    {
        int n;
        vector<Point> ps;
        double r;
        Point peg;
        while (scanf ("%d", &n) == 1)   {
            if (n < 3)  break;
            scanf ("%lf", &r);
            peg = read_point ();
            ps.clear ();
            for (int i=0; i<n; ++i) {
                ps.push_back (read_point ());
            }
            vector<Point> qs = convex_hull (ps);
            if (qs.size () < n) {
                puts ("HOLE IS ILL-FORMED");    continue;
            }
            qs.push_back (qs[0]);
            bool flag = true;
            for (int i=0; i<n; ++i) {
                if (dcmp (point_to_line (peg, qs[i], qs[i+1]) - r) < 0)  {
                    flag = false;   break;
                }
                if (cross (qs[i+1] - qs[i], peg - qs[i]) < 0) {
                    flag = false;   break;
                }
            }
            if (flag)   puts ("PEG WILL FIT");
            else    puts ("PEG WILL NOT FIT");
        }
    
       //cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.
    ";
    
        return 0;
    }
    

      

    编译人生,运行世界!
  • 相关阅读:
    (BFS 二叉树) leetcode 515. Find Largest Value in Each Tree Row
    (二叉树 BFS) leetcode513. Find Bottom Left Tree Value
    (二叉树 BFS DFS) leetcode 104. Maximum Depth of Binary Tree
    (二叉树 BFS DFS) leetcode 111. Minimum Depth of Binary Tree
    (BFS) leetcode 690. Employee Importance
    (BFS/DFS) leetcode 200. Number of Islands
    (最长回文子串 线性DP) 51nod 1088 最长回文子串
    (链表 importance) leetcode 2. Add Two Numbers
    (链表 set) leetcode 817. Linked List Components
    (链表 双指针) leetcode 142. Linked List Cycle II
  • 原文地址:https://www.cnblogs.com/Running-Time/p/4931452.html
Copyright © 2011-2022 走看看