模板--二维凸包（1）

最新推荐文章于 2022-01-26 19:01:25 发布
最新推荐文章于 2022-01-26 19:01:25 发布
阅读量630 收藏 2
点赞数
分类专栏： ACM模板 文章标签： poj 模板 凸包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ramay7/article/details/51187038
版权

二维凸包模板：

  • 1.求凸包顶点
  • 2.Graham扫描法
  • 3.判断稳定凸包
  • 4.凸包直径
  • 5.凸包周长及面积
  • 6.凸包内最大三角形面积
  • 7.凸包最小外接矩形面积
  • 8.凸包最小外接平行四边形面积
//向量的叉积:A * B =|A|*|B|*sin(alpha),alpha是向量A和向量B之间的夹角
//向量的点积 A · B =|A|*|B|*cos(alpha)
//向量A和B的叉积小于0，说明向量B在向量A右侧
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <climits>
#include <iostream>
using namespace std;
const int MAX_N=1010;
const double INF=1e90;
const double eps=1e-10;
const double PI=acos(-1.0);

int T,n,cases=0;

struct Point{
    double x,y;

    Point () {}
    Point (double x,double y) : x(x),y(y) {
    }
    Point operator + (const Point& rhs) const {
        return Point(x+rhs.x,y+rhs.y);
    }
    Point operator - (const Point& rhs) const {
        return Point(x-rhs.x,y-rhs.y);
    }
    Point operator * (const double d) const {
        return Point(d*x,d*y);
    }
    double dis(const Point& rhs) const { //两点距离
        return sqrt((x-rhs.x)*(x-rhs.x)+(y-rhs.y)*(y-rhs.y));
    }
    double dot(const Point& rhs) const { //点积、内积
        return (x*rhs.x+y*rhs.y);
    }
    double cross(const Point& rhs) const { //叉积、外积
        return (x*rhs.y-y*rhs.x);
    }
}point[MAX_N],vertex[MAX_N];

inline bool cmp_x(const Point a,const Point b)
{//优先x升序，其次y升序排序
    if(a.x==b.x) return a.y<b.y;
    return a.x<b.x;
}

//Graham扫描法
inline int Andrew()
{
    sort(point,point+n,cmp_x);
    int k=0;
    //构造下凸包
    for(int i=0;i<n;i++){
        while(k>1&&(vertex[k-1]-vertex[k-2]).cross(point[i]-vertex[k-1])<=0){
            k--;
        }
        //因为存凸包的顶点是从0开始的，而最左下的点一定是凸包顶点，所以k>1
        //因为如果k=1仍然继续执行的话,k-2就小于0了
        //当然如果凸包顶点是从1开始存储的话，那么这里就应该是k>2
        vertex[k++]=point[i];
    }
    //构造上凸包
    int m=k; //m是下凸包顶点数目，且最后一个顶点是point[n-1]
    for(int i=n-2;i>=0;i--){    //注意是从point[n-2]开始，避免重复point[n-1]
        while(k>m&&(vertex[k-1]-vertex[k-2]).cross(point[i]-vertex[k-1])<=0){
            k--;
        }
        vertex[k++]=point[i];
    }
    if(k>1) k--; //point[0]重复
    return k;
}

//给出一个凸包，判断凸包是否唯一确定(稳定凸包)，即判断凸包每条边上是否存在至少三个点
inline bool JudgeStableConvexHull()
{
    if(n<6) {
        return false;
    }
    int total=Andrew();
    vertex[total]=vertex[0];
    /*
    将边上的点也存进凸包顶点里，在判断的时候只需要判断凸包顶点中是否一定存在相邻向量叉积为0即可
    上面Andrew（）函数中需要将(vertex[k-1]-vertex[k-2]).cross(point[i]-vertex[k-1])<=0改为
    (vertex[k-1]-vertex[k-2]).cross(point[i]-vertex[k-1])<0
    for(int i=1;i<total;i++){
        if((vertex[i-1]-vertex[i]).cross(vertexi+1]-vertex[i])!=0
        &&(vertex[i]-vertex[i+1]).cross(vertex[i+2]-vertex[i+1])!=0){
            return false;
        }
    }
    return true;
    */

    for(int i=0;i<total;i++){ //遍历凸包边
        Point a=vertex[i],b=vertex[i+1];//该边端点是a和b
        int cnt=0;
        for(int j=0;j<n;j++){ //检查该边上点的个数
            if((point[j]-a).cross(b-point[j])==0){// 在这条边上的点
                cnt++;
                if(cnt>=3) break;
            }
        }
        if(cnt<3){ //少于三个点
            return false;
        }
    }
    return true;
}

//旋转卡壳求凸包直径(最远点距离)
inline double GetMostFarDistance()
{
    int total=Andrew();
    if(total==2){ //处理凸包退化的情况,只有两个顶点
        return vertex[0].dis(vertex[1]);
    }

    int i=0,j=0;//在某个方向上的对踵点
    //求出x轴方向上的对踵点对
    for(int k=0;k<total;k++){
        if(!cmp_x(vertex[i],vertex[k])) i=k;
        if(cmp_x(vertex[j],vertex[k])) j=k;
    }
    double ans=0;
    int si=i,sj=j;
    while(i!=sj||j!=si){ //将方向逐步旋转180度
        ans=max(ans,vertex[i].dis(vertex[j]));
        //判断先转到边i-(i+1)的法线方向还是边j-(j+1)的法线方向
        int nexti=(i+1)%total,nextj=(j+1)%total;
        if((vertex[nexti]-vertex[i]).cross(vertex[nextj]-vertex[j])<0){
            i=nexti; //先转到边i-(i+1)的法线方向
        }else {
            j=nextj; //先转到边j-(j+1)的法线方向
        }
    }
    return ans;
}

//计算凸包面积
//将凸包看成一个个以凸包最左下顶点为顶点的凸包边为对边的三角形。 
//那么依次扫个条边，计算三角形面积累加即可。 
//已知三角形三条边计算三角形面积，可用海伦–秦九韶公式
inline double GetConvexHullArea()
{
    int total=Andrew();
    if(total<=2){
        return 0.0;
    }
    double area=0;
    for(int i=2;i<total;i++){
        double a=vertex[i-1].dis(vertex[0]);
        double b=vertex[i].dis(vertex[0]);
        double c=vertex[i].dis(vertex[i-1]);
        double p=(a+b+c)/2;
        area+=sqrt(p*(p-a)*(p-b)*(p-c));
    }
    return area;
}

//计算凸包周长
inline double GetConvexHullPerimeter()
{
    int total=Andrew();
    vertex[total]=vertex[0];
    double ans=0;
    for(int i=0;i<total;i++){
        ans+=vertex[i].dis(vertex[i+1]);
    }
    return ans;
}

inline double GetArea(Point a,Point b,Point c)//计算顶点为a,b,c的三角形面积
{
    double len1=a.dis(b);
    double len2=a.dis(c);
    double len3=b.dis(c);
    double p=(len1+len2+len3)/2;
    return sqrt(p*(p-len1)*(p-len2)*(p-len3));
}

//旋转卡壳求凸包最大三角形面积，时间复杂度O(total^2),total是凸包顶点数
inline double GetBiggestTriangleAreaInConvexHull()
{
    int total=Andrew();
    vertex[total]=vertex[0];
    double ans=0.0;
    for(int i=0;i<total;i++){
        int j=(i+1)%total;
        int k=(j+1)%total;
        while(j!=i&&k!=i){
            ans=max(ans,fabs((vertex[j]-vertex[i]).cross(vertex[k]-vertex[i])/2.0)); 
            //已知三角形三顶点，利用叉积计算面积或者海伦-秦九韶公式
            //ans=max(ans,GetArea(vertex[i],vertex[j],vertex[k]));        
            while(k!=i&&(vertex[j]-vertex[i]).cross((vertex[k+1]-vertex[k]))<0){
                k=(k+1)%total;
            }
            j=(j+1)%total;
        }
    }
    return ans;
}

//最小覆盖矩形面积
inline double MinimalRetangleCover()
{
    int total=Andrew();
    if(total<=2){
        return 0.0;
    }
    double ans=INF;
    // O(total)算法
    vertex[total]=vertex[0];
    int r=1,p=1,q;
    for(int i=0;i<total;i++){
        double edge=vertex[i].dis(vertex[i+1]);
        double tmp1,tmp2;
        while(1){ //卡出离边vertex[i]--vertex[i+1]最远的点
            tmp1=(vertex[i+1]-vertex[i]).cross(vertex[r+1]-vertex[i]); //叉积
            tmp2=(vertex[i+1]-vertex[i]).cross(vertex[r]-vertex[i]);
            if(tmp2>tmp1) break;
            r=(r+1)%total;
        }
        double height=tmp2/edge;

        while(1){ //卡出在vertex[i]--vertex[i+1]方向上正向最远的点
            tmp1=(vertex[i+1]-vertex[i]).dot(vertex[p+1]-vertex[i]); //点积
            tmp2=(vertex[i+1]-vertex[i]).dot(vertex[p]-vertex[i]);
            if(tmp2>tmp1) break;
            p=(p+1)%total;
        }
        double len1=tmp2/edge;
        //len1是从vertex[i]出发沿vertex[i]--vertex[i+1]正方向能达到的最大距离

        if(i==0) q=p;
        while(1){ //卡出在vertex[i]--vertex[i+1]方向上负方向最远的点
            tmp1=(vertex[i+1]-vertex[i]).dot(vertex[q+1]-vertex[i]); //点积
            tmp2=(vertex[i+1]-vertex[i]).dot(vertex[q]-vertex[i]);
            if(tmp2<tmp1) break; //和上面的不一样
            q=(q+1)%total;
        }
        double len2=tmp2/edge;
        //len2是从vertex[i]出发沿vertex[i]--vertex[i+1]负方向能达到的最大距离

        double len=len1-len2;
        ans=min(ans,len*height);
    }

    /* O(total^2)算法 
    for(int i=0;i<total;i++){ //遍历每一条边
        Point A,B;
        A=vertex[i],B=vertex[(i+1)%total];
        double AB=A.dis(B);
        double leftA,rightA,leftB,rightB,height;
        leftA=rightA=leftB=rightB=height=0.0;
        for(int j=0;j<total;j++){ //遍历凸包每一个顶点
            Point C=vertex[j];
            double d=(B-A).cross(C-A)/AB;
            height=max(height,d); //更新高

            double tmp=(B-A).dot(C-A)/AB;//更新A点左右最大距离
            if(tmp>0) rightA=max(rightA,tmp);
            else leftA=max(leftA,-tmp);

            tmp=(A-B).dot(C-B)/AB; //更新B点左右最大距离
            if(tmp<0) rightB=max(rightB,-tmp);
            else leftB=max(leftB,tmp);
        //  printf("i=%d j=%d rihgtA=%.2f rightB=%.2f\n",i,j,rightA,rightB);
        }
        double len1=max(leftA,leftB-AB); //左端最大超出
        double len2=max(rightB,rightA-AB); //右端最大超出
        double len=len1+len2+AB; //len即是长
        //printf("len1=%.2f len2=%.2f len=%.2f height=%.2f\n",len1,len2,len,height);
        ans=min(ans,len*height); //更新最小外接矩形
    }
    */
    return ans;
}


//计算凸包最小外接平行四边形面积[一定有两条边是凸包的边]
double height[MAX_N];//用于存储凸包每条边上最远顶点到这条边的距离
double edge[MAX_N];//存储边长度

inline double MinimalParallelogramCover()
{
    int total=Andrew();
    if(total<=2){
        return 0.0;
    }
    vertex[total]=vertex[0];
    //求每条边最远顶点距离，即是这条边上对应的高
    for(int i=0;i<total;i++){
        height[i]=-1.0; 
        edge[i]=vertex[i].dis(vertex[i+1]);
        for(int j=0;j<total;j++){
            double tmp=((vertex[i+1]-vertex[i]).cross(vertex[j]-vertex[i]));
            //edge;顶点vertex[j]到边i--(i+1)的距离
            height[i]=max(height[i],fabs(tmp/edge[i]));
        }
    }
    double ans=INF;
    //枚举两条边计算以这两条边为平行四边形边的平行四边形
    for(int i=0;i<total;i++){
        Point tmp1=vertex[i+1]-vertex[i];
        for(int j=0;j<total;j++){
            Point tmp2=vertex[j+1]-vertex[j];
            double angle=(tmp1.cross(tmp2))/edge[i]/edge[j];    //计算向量夹角的正弦值
            if(fabs(angle)<eps) continue;
            ans=min(ans,height[i]*height[j]/fabs(angle));
            //已知平行四边形两组对边上的高及一个内角的正弦值求平行四边形的面积
        }
    }
    return ans;
}

int main()
{
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            scanf("%lf%lf",&point[i].x,&point[i].y);
        }
        .........
    }
    return 0;
}
ramay7
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
三维凸包模板
10-19
三维凸包模板 三维凸包模板是计算机科学和几何学中一个重要的概念，它是一种三维几何形体的表达方式。在这个模板中，我们将讨论三维凸包的定义、特点、判断方法和应用。 一、定义 三维凸包是一种三维几何形体，它...
Matlab最小面积包围四边形
仰望天空45度
04-12 6475
对于存在透视变换的物体，提取时最小面积包围矩形不能满足要求，google到一个求最小面积包围四边形的算法，虽然速度较慢。以提取书本为例，实验结果和代码如下。booktest.mI = imread('book1.jpg'); figure(1); imshow(I); Ir = I(:,:,1); Ismall = imresize(Ir,0.25); bw =~imbinarize(Ismall)
python计算凸包并绘制凸包曲线
呆萌的代Ma
01-26 4651
凸包就是用一个凸（内角不大于180°）的闭合曲线，刚好包住了所有的样本点 主要使用的工具：scipy的ConvexHull scipy.spatial.ConvexHull文档：https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.ConvexHull.html 简易使用的示例： from scipy.spatial import ConvexHull import numpy as np points = np.array(
二维凸包模板
weixin_30443813的博客
07-02 53
double cross(Point a,Point b) { return a.x*b.y-a.y*b.x; } double mul(Point p0,Point p1,Point p2) { return cross(p1-p0,p2-p0); } double dis(Point a) { return sqrt(a.x*a.x+a.y*a....
二维凸包详解
tylon2006的博客
07-18 1662
凸包大意：给一堆点，让你求一个最小的多边形使得其囊括所有点。 实际上就是拿条绳子在一堆钉子外面绕一圈，绕成的图形就是所求多边形，即绕绳法。 但这里并不讨论绕绳法，而是介绍一种叫Graham的算法。 前置芝士：叉积（a×b=a.x·b.y+a.y·b.x） 叉积不同于点积，叉积的结果是向量，而点积的结果是标量。 设平面直角坐标系有三点A(x0,y0)，B(x1,y1)，C(x2,y2)。 有共起点...
[模板]二维凸包(纯代码)
huhao的博客
07-22 273
#define eps 1e-7 struct point { double x,y; }f[100010]; bool cmp1(point a,point b) { rt a.y<b.y; } bool cmp2(point a,point b) { rt a.x*b.y<a.y*b.x; } bool check(point a,point b,point c) {
最小球覆盖 与 三维凸包
10-18
计算几何模板代码：最小球覆盖与三维凸包 计算几何是计算机科学和数学的一个分支，研究如何使用计算机来解决几何问题。计算几何主要关心的是研究几何对象的计算表示、几何算法和几何数据结构等。 在计算几何中，一...
ACM计算几何模板大全 几何 多边形 凸包 三维 圆
05-22
本模板大全旨在为参赛者提供一个全面的参考框架，涵盖了从二维到三维的几何概念、算法和技巧。 首先，我们关注的是计算几何的基础——几何公式。这包括点、线、面之间的基本关系，如距离、角度和交点的计算。在二维...
Dounm模板1
08-03
增量法求三维凸包是一种高效的方法，用于找出一组点在三维空间中的凸壳。这种方法通常比暴力求解更快，适用于处理大量点集的情况。 判断8个点是否为立方体的问题，实质上是检验这些点是否满足立方体的几何特性，即...
ＡＣＭ模板
08-07
1. `qsort()`函数： - `qsort()`的声明位于`<stdlib.h>`头文件中。 - 函数原型：`void qsort(void *base, size_t num, size_t width, int (*cmp)(const void *, const void *))`。 - 参数说明： - `base`：指向...
凸包法求任意多边形的面积
07-11
自己编的，用凸包算多边形的面积，输入由文件输入
二维凸包模板 【Graham扫描算法】
世界很大
12-23 1563
推荐链接：讲的很好 模板： #include #include #include #include #define eps 1e-8 using namespace std; struct Point { double x, y; Point(){} Point(double X, double Y){ x = X; y = Y;
凸包Graham模板
zezzezzez的博客
07-12 1834
参考博客：http://blog.csdn.net/yangkunpengd/article/details/51336453 http://www.yalewoo.com/in_triangle_test.html 先说我对找凸包上的点时的理解： P,A,B三个点，通过叉乘可以得知P,A,B的位置关系 AB × AP = |AB| * |AP| * sin∠PAB. 方向是A到B，A到P
二维凸包模版——旋转卡壳法
Join Hands
07-18 918
#include #include #include #include const int MAXN = 109; const double eps = 1e-6; struct point{ double x,y; }p[MAXN],h[MAXN]; inli
模板：二维凸包（计算几何）
BUG_Creater_jie的博客
01-02 691
计算几何的基础
二维凸包模板——kuangbin版
weixin_33874713的博客
03-23 98
简洁明了，转自kuangbin神~#include<stdio.h> #include<math.h> #include<algorithm> #include<iostream> using namespace std; const int MAXN=1000; struct point { int x,y; }; ...
平面（二维）凸包&&luoguP2742 【模板】二维凸包
guapi2333的博客
01-11 211
凸包、Andew算法介绍及一个求凸包周长模板题的Code
凸包模板
Black—Horse的专栏
01-14 2652
转自这位大神 http://www.cnblogs.com/kuangbin/archive/2012/09/29/2707961.html #include #include #include #include using namespace std; const int MAXN=105; struct point { int x,y; }; point list[M
K-MEANS聚类遇上凸包
最新发布
05-27
如果我们将K-MEANS聚类算法和凸包算法结合起来，可以实现一个称为凸包K-MEANS的算法。 凸包K-MEANS算法的基本思路是，对于给定的数据集，首先使用K-MEANS算法进行聚类，得到K个类别的数据点集合。然后，对于每个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值