POJ 1228 Grandpa's Estate(凸包)

最新推荐文章于 2022-07-06 15:02:28 发布

原创最新推荐文章于 2022-07-06 15:02:28 发布 · 559 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

338 篇文章

订阅专栏

本文介绍了一种算法，用于判断给定的点集是否能够确定一个唯一的凸包。通过分析点集并应用凸包模板，该算法能够处理点集中的特殊情况，并最终确定凸包是否存在不确定性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：POJ 1228 Grandpa's Estate

看了别人的题解才知道这道题是什么意思，给了一些凸包上的点，问是否能根据这些点得出一个确定的凸包。

如果题目给出的那些点构成的凸包的一条边上只有两个点，那么这个凸包是不确定的，因为这条边的外侧可能还有一个点，而如果一条边上有三个或者三个以上的点，那么这条边就是确定的，如果所有边上的点数都大于等于3，这个凸包就是确定的。

如果所有点共线这个凸包模版会出错，所以需要先判断一下。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

const double eps = 1e-10;
const double PI = acos(-1);
const int MAX_N = 1000 + 10;

struct Point
{
	double x, y;
	Point(double x=0, double y=0):x(x),y(y) { }
};

typedef Point Vector;

Point p[MAX_N];

Vector operator + (const Vector& A, const Vector& B)
{
    return Vector(A.x+B.x, A.y+B.y);
}

Vector operator - (const Point& A, const Point& B)
{
    return Vector(A.x-B.x, A.y-B.y);
}

Vector operator * (const Vector& A, double p)
{
    return Vector(A.x*p, A.y*p);
}

bool operator < (const Point& a, const Point& b)
{
	return a.x < b.x || (a.x == b.x && a.y < b.y);
}

int dcmp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else
        return x < 0 ? -1 : 1;
}

bool operator == (const Point& a, const Point &b)
{
	return dcmp(a.x-b.x) == 0 && dcmp(a.y-b.y) == 0;
}

double Cross(const Vector& A, const Vector& B)
{
    return A.x*B.y - A.y*B.x;
}

double Dot(const Vector& A, const Vector& B)
{
    return A.x*B.x + A.y*B.y;
}

double Length(const Vector& A)
{
    return sqrt(Dot(A, A));
}

// 点集凸包
// 如果不希望在凸包的边上有输入点，把两个 <= 改成 <
// 如果不介意点集被修改，可以改成传递引用
vector<Point> ConvexHull(vector<Point> p)
{
  // 预处理，删除重复点
      sort(p.begin(), p.end());
      p.erase(unique(p.begin(), p.end()), p.end());

      int n = p.size();
      int m = 0;
      vector<Point> ch(n+1);
      for(int i = 0; i < n; i++) {
        while(m > 1 && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) < 0) m--;
        ch[m++] = p[i];
      }
      int k = m;
      for(int i = n-2; i >= 0; i--) {
        while(m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) < 0) m--;
        ch[m++] = p[i];
      }
      if(n > 1) m--;
      ch.resize(m);
      return ch;
}

// 多边形的有向面积
double PolygonArea(vector<Point> p)
{
      double area = 0;
      int n = p.size();
      for(int i = 1; i < n-1; i++)
        area += Cross(p[i]-p[0], p[i+1]-p[0]);
      return area/2;
}

bool get_it(vector<Point> p)
{
    p.push_back(p[0]);
    int n = p.size();
    for(int i = 0; i < n - 2; i++)
    {
        if(Cross(p[i + 1] - p[i], p[i + 2] - p[i]) == 0)
        {
            for(int j = i + 3; j < n - 1; j++)
            {
                if(Cross(p[i + 1] - p[i], p[j] - p[i]) != 0)
                {
                    i = j - 2;
                    break;
                }
            }
        }
        else
            return false;
    }
    return true;
}
double torad(double deg)
{
    return deg/180 * PI;
}
Vector Rotate(const Vector& A, double rad)
{
    return Vector(A.x*cos(rad)-A.y*sin(rad), A.x*sin(rad)+A.y*cos(rad));
}

bool is_online(vector<Point> p)
{
    int n = p.size();
    for(int i = 2; i < n; i++)
    {
        if(dcmp(Cross(p[0] -  p[1], p[0] - p[i])) != 0)
            return false;
    }
    return true;
}
int main()
{
    int T, n;
    scanf("%d", &T);
    while(T--)
    {
        vector <Point> P;
        scanf("%d", &n);
        double x, y;
        for(int i = 0; i < n; i++)
        {
            scanf("%lf%lf", &x, &y);
            P.push_back(Point(x, y));
        }
        if(n <= 5 || is_online(P))
        {
            printf("NO\n");
            continue;
        }
        if(get_it(ConvexHull(P)))
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}