计算几何基础 模板

最新推荐文章于 2024-10-03 06:30:00 发布
最新推荐文章于 2024-10-03 06:30:00 发布
阅读量89 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/SovietPower/p/10593432.html

目录

计算几何拖了这么久，终于拖到省选前了。
emm不求能A题，只求写暴力。

参考：
https://oi.men.ci/geometry-notes/
https://www.cnblogs.com/fly-in-milkyway/p/10569895.html
https://blog.youkuaiyun.com/clover_hxy/article/details/53966405
https://www.cnblogs.com/lstoi/p/9791654.html
https://blog.youkuaiyun.com/qq_34921856/article/details/80690822

ps: 刚开始写的代码，读入用的p[i]=(Point){read(),read()}，因为初始化了构造函数所以这么读进去横纵坐标可能是反的。。
有些题并没有影响所以以前的就不改了。

基础部分

#include <cmath>
#include <cstdio>
#include <cctype>
#include <vector>
#include <cstring>
#include <algorithm>
#define gc() getchar()
typedef long long LL;
const int N=1e5+5;

const double eps=1e-10;

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

struct Vec
{
    double x,y;
    Vec(double x=0,double y=0):x(x),y(y) {}
    Vec operator +(const Vec &a)const {return Vec(x+a.x, y+a.y);}
    Vec operator -(const Vec &a)const {return Vec(x-a.x, y-a.y);}
    Vec operator *(const double p)const {return Vec(x*p, y*p);}

    double operator *(const Vec &a)const {return x*a.y-y*a.x;}//cross product
    bool operator <(const Vec &a)const {return x<a.x||(x==a.x&&y<a.y);}
    bool operator ==(const Vec &a)const {return !dcmp(x-a.x)&&!dcmp(y-a.y);}

    double Norm() {return x*x+y*y;}//范数 
    double Length() {return sqrt(x*x+y*y);}//模长 
    double Dot(Vec a) {return x*a.x+y*a.y;}//dot product
    double Angle(Vec a) {return acos(Dot(a)/Length()/a.Length());}//两向量夹角 
    Vec Normal() {double t=Length(); return Vec(-y/t,x/t);}//单位法向量 
    Vec Rotate(double rad) {return Vec(x*cos(rad)-y*sin(rad),x*sin(rad)+y*cos(rad));}//顺时针旋转rad度 
};
typedef Vec Point;

struct Line
{
    Point a; Vec v;
    Line(Point a,Vec v):a(a),v(v) {}

    bool OnLine(const Point &p) {return !dcmp((a-p)*v);}//!dcmp((a-p)*(b-p))
    bool OnSegment(const Point &p) {return !dcmp((a-p)*v)&&dcmp((a-p).Dot(a+v-p))<=0;}//PA*PB<=0
    int Relation(const Line &l)//直线之间的关系 0:平行 1:相交 2:重合(无数个交点) 
    {
        return dcmp(v*l.v)?1:dcmp(v*(a-l.a))?0:2;
    }
    Point Intersection(const Line &l)//直线交点 
    {
        return a+v*((l.v*(a-l.a))/(v*l.v));//注意方向（叉积的正负） 
    }
};

inline bool cmp(const Point &a,const Point &b) {return a.x==b.x?a.y<b.y:a.x<b.x;}

struct Polygon
{
    int sk[N];
    std::vector<Point> ps;

    bool Include(const Point &p)//点在多边形内 
    {
        int cnt=0;
        for(int i=0,lim=ps.size(); i<lim; ++i)
        {
            const Point a=ps[i],b=ps[i+1==lim?0:i+1];
            if(Line(a,b-a).OnSegment(p)) return 1;
            double d1=a.y-p.y,d2=b.y-p.y,tmp=(a-p)*(b-p);
            if((tmp<0&&d1<0&&d2>=0)||(tmp>0&&d1>=0&&d2<0)) ++cnt;
        }
        return cnt&1;
    }
    double Area()//多边形有向面积（逆时针为正，顺时针为负） 
    {
        double res=0;
        for(int i=0,lim=ps.size(); i<lim; ++i)
            res+=ps[i]*ps[i+1==lim?0:i+1];
        return res*0.5;
    }
    int Convex()//求凸包 存在sk[]里 
    {
        std::sort(ps.begin(),ps.end(),cmp);
        int top=1,n=ps.size(); sk[1]=0;
        for(int i=1; i<n; ++i)
        {
            while(top>=2 && (ps[sk[top]]-ps[sk[top-1]])*(ps[i]-ps[sk[top-1]])<=0) --top;
            sk[++top]=i;
        }
        int k=top;
        for(int i=n-2; ~i; --i)
        {
            while(top>k && (ps[sk[top]]-ps[sk[top-1]])*(ps[i]-ps[sk[top-1]])<=0) --top;
            sk[++top]=i;
        }
        return top;
    }
};

int main()
{
    return 0;
}

凸包

洛谷.2742.[模板]二维凸包。

\(Granham's\ Scan\)：

  1. 选出所有点中横坐标最小（如果相同取纵坐标最小的）的点\(x\)，将所有点按与\(x\)的极角序排序。
  2. 将\(x\)放到栈里，跑一遍单调栈求凸包。

这个做法似乎精度不太好。

另一种做法是：

  1. 将所有点按横坐标为第一关键字，纵坐标为第二关键字排序。
  2. 将\(1\)号点放到栈里，单调栈求一遍下凸壳。
  3. 保留原先栈中的元素，单调栈求一遍上凸壳。

复杂度都是\(O(n\log n)\)。

#include <cmath>
#include <cstdio>
#include <cctype>
#include <algorithm>
//#define gc() getchar()
#define MAXIN 500000
#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
typedef long long LL;
const int N=1e4+6;

int sk[N];
char IN[MAXIN],*SS=IN,*TT=IN;
struct Vec
{
    double x,y;
    Vec(double x=0,double y=0):x(x),y(y) {}
    Vec operator +(const Vec &a)const {return Vec(x+a.x, y+a.y);}
    Vec operator -(const Vec &a)const {return Vec(x-a.x, y-a.y);}
    Vec operator *(const double a)const {return Vec(x*a, y*a);}
    bool operator <(const Vec &a)const {return x<a.x||(x==a.x&&y<a.y);}
    double operator *(const Vec &a)const {return x*a.y-y*a.x;}
    double Length() {return sqrt(x*x+y*y);}
}p[N];
typedef Vec Point;

inline double read()
{
    double x=0,y=0.1,f=1;register char c=gc();
    for(;!isdigit(c);c=='-'&&(f=-1),c=gc());
    for(;isdigit(c);x=x*10+c-48,c=gc());
    for(c=='.'&&(c=gc());isdigit(c);x+=y*(c-48),y*=0.1,c=gc());
    return x*f;
}
double Convex(int n)
{
    std::sort(p+1,p+1+n);
    int top=1; sk[1]=1;
    for(int i=2; i<=n; ++i)
    {
        while(top>1 && (p[sk[top]]-p[sk[top-1]])*(p[i]-p[sk[top-1]])<=0) --top;
        sk[++top]=i;
    }
    int m=top;
    for(int i=n-1; i; --i)
    {
        while(top>m && (p[sk[top]]-p[sk[top-1]])*(p[i]-p[sk[top-1]])<=0) --top;
        sk[++top]=i;
    }
    double ans=0;
    for(int i=1; i<top; ++i) ans+=(p[sk[i+1]]-p[sk[i]]).Length();
    return ans;
}

int main()
{
    int n=read();
    for(int i=1; i<=n; ++i) p[i]=(Point){read(),read()};
    printf("%.2f\n",Convex(n));

    return 0;
}

极角排序

一道例题。

旋转卡壳

BZOJ.1069.[SCOI2007]最大土地面积

求四边形最大面积，枚举一条对角线，求对角线两边最大三角形面积即可。
暴力是\(n^3\)的，容易发现固定对角线一个端点，另一个端点移动时两边最远点的移动也是单调的。所以用旋转卡壳优化一下就是\(O(n^2)\)啦。

旋转卡壳还有很多用途，见最上面的链接。
经常要找和当前直线平行的直线切在哪里，注意用底相同，平行线之间高也相同，以及叉积有正负的性质，求叉积。
求凸多边形最小面积外接矩形，找三个边界点时（枚举下边界点\(d\)），上边界点\(u\)可以如上所说用叉积判（判断\((p_u-p_d)*(p_{d+1}-p_d)\)与\((p_{u+1}-p_d)*(p_{d+1}-p_d)\)的大小关系，比它小则\(u+1\)）。
点积可以求向量在另一个向量上的映射长度，所以右边界点\(r\)可以用点积求（在\(p_{d+1}-p_d\)上映射长度最长的）。
同理，左边界点\(l\)也用点积求，不过注意刚开始要将\(l\)赋值为\(r\)。

[BZOJ1069]的代码：

//884kb 120ms
#include <cstdio>
#include <algorithm>
typedef long long LL;
const int N=2005;

struct Vec
{
    double x,y;
    Vec(double x=0,double y=0):x(x),y(y) {}
    Vec operator +(const Vec &a)const {return Vec(x+a.x, y+a.y);}
    Vec operator -(const Vec &a)const {return Vec(x-a.x, y-a.y);}
    double operator *(const Vec &a)const {return x*a.y-y*a.x;}
    bool operator <(const Vec &a)const {return x<a.x||(x==a.x&&y<a.y);}
}p[N],sk[N];


int main()
{
    int n; scanf("%d",&n);
    for(int i=1; i<=n; ++i) scanf("%lf%lf",&p[i].x,&p[i].y);
    std::sort(p+1,p+1+n);
    int top=1; sk[1]=p[1];
    for(int i=2; i<=n; ++i)
    {
        while(top>1 && (sk[top]-sk[top-1])*(p[i]-sk[top-1])<=0) --top;
        sk[++top]=p[i];
    }
    int k=top;
    for(int i=n-1; i>1; --i)
    {
        while(top>k && (sk[top]-sk[top-1])*(p[i]-sk[top-1])<=0) --top;
        sk[++top]=p[i];
    }
    double ans=0; sk[top+1]=sk[1];
    #define Inc(x) (x+1>top?1:x+1)
    for(int i=1; i+2<=top; ++i)
    {
        int x=i+1,y=i+3>top?1:i+3;
        for(int j=i+2; j<=top; ++j)
        {
            while((sk[x+1]-sk[i])*(sk[j]-sk[i])>(sk[x]-sk[i])*(sk[j]-sk[i])) x=Inc(x);
            while((sk[j]-sk[i])*(sk[y+1]-sk[i])>(sk[j]-sk[i])*(sk[y]-sk[i])) y=Inc(y);
            ans=std::max(ans,(sk[x]-sk[i])*(sk[j]-sk[i])+(sk[j]-sk[i])*(sk[y]-sk[i]));
        }
    }
    printf("%.3f\n",ans*0.5);

    return 0;
}

半平面交

咕咕了。

最小圆覆盖

具体见这里。

#include <cmath>
#include <cstdio>
#include <cctype>
#include <algorithm>
#define gc() getchar()
#define MAXIN 500000
//#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
typedef long long LL;
const int N=1e6+5;

char IN[MAXIN],*SS=IN,*TT=IN;
struct Vec
{
    double x,y;
    Vec(double x=0,double y=0):x(x),y(y) {}
    Vec operator +(const Vec &a)const {return Vec(x+a.x, y+a.y);}
    Vec operator -(const Vec &a)const {return Vec(x-a.x, y-a.y);}
    Vec operator *(const double a)const {return Vec(x*a, y*a);}
    double operator *(const Vec &a)const {return x*a.y-y*a.x;}
    Vec Rotate_90()const {return Vec(y,-x);}
    double len()const {return sqrt(x*x+y*y);}
    double len2()const {return x*x+y*y;}
}p[N];
typedef Vec Point;
struct Line
{
    Point p; Vec v;
    Line(Point p,Vec v):p(p),v(v) {}
    Line PerpendicularBisector()const//垂直平分线=-=
    {
        return Line((p+p+v)*0.5,v.Rotate_90());
    }
    Point Intersection(const Line &l)const
    {
        return p+v*((l.v*(p-l.p))/(v*l.v));
    }
};

inline double read()
{
    double x=0,y=0.1,f=1;register char c=gc();
    for(;!isdigit(c);c=='-'&&(f=-1),c=gc());
    for(;isdigit(c);x=x*10+c-48,c=gc());
    for(c=='.'&&(c=gc());isdigit(c);x+=y*(c-48),y*=0.1,c=gc());
    return x*f;
}
Point CalcCircle(const Point &a,const Point &b,const Point &c)
{
//  Line A=Line(a,b-a).PerpendicularBisector(),B=Line(a,c-a).PerpendicularBisector();
    Line A=Line((a+b)*0.5,(b-a).Rotate_90()),B=Line((a+c)*0.5,(c-a).Rotate_90());
    return A.Intersection(B);
}
void Solve(const int n)
{
    srand(330), std::random_shuffle(p+1,p+1+n);//话说这个srand不够随机啊= = 
    Point O=p[1]; double R=0;
    for(int i=2; i<=n; ++i)
        if((p[i]-O).len2()>R)
        {
            O=p[i], R=0;
            for(int j=1; j<i; ++j)
                if((p[j]-O).len2()>R)
                {
                    O=(p[i]+p[j])*0.5, R=(p[i]-O).len2();
                    for(int k=1; k<j; ++k)
                        if((p[k]-O).len2()>R)
                            O=CalcCircle(p[i],p[j],p[k]), R=(p[k]-O).len2();
                }
        }
    printf("%.2f %.2f %.2f\n",O.x,O.y,sqrt(R));
}

int main()
{
    int n=read();
    for(int i=1; i<=n; ++i) p[i].x=read(),p[i].y=read();
//  for(int i=1; i<=n; ++i) p[i]=(Point){read(),read()};//声明构造函数之后再这么用，貌似。。= = 不同编译器结果不同。。
    Solve(n);

    return 0;
}

转载于:https://www.cnblogs.com/SovietPower/p/10593432.html

ACM 计算几何基础模板
qq_39561693的博客
03-25 1404
在ACM计算几何中，我们常常重复用到许多方法，例如求点距，求直线方程，等等。不妨利用模板总结之。这些模板为我从网上学习后加入自己的理解糅合得来qwq，看了很多的博客，查了很多书籍，其中印象最深的是林夕林夕关于计算几何模板的总结，大家也可以去参考他的应该比我的更详细qwq（不过大佬最近好像出没比较少了） 所以我这个主要还是留着自己参考吧，能帮到他人再好不过了 为了不产生歧义，方便理解，本模板使用笛卡尔坐标系，封装的多是数学中常见的函数。 前置知识：高中数学 文章目录基础声明点向量直线 基础声明 首先，打acm
计算几何 - 二维几何基础 （模板）
Never say never
02-07 1158
这里总结一下二维几何基础知识！ 常用定义： //定义点的类型 struct Point { double x, y; Point(double x = 0, double y = 0) : x(x) , y(y) { } //构造函数，方便代码编写 }; typedef Point Vector; //从程序实现上，Vector只是Point的别名 //向量 + 向量
计算几何未整理模板
蒟蒻 lxw的博客
10-19 127
1.一个半径为r 的圆最多覆盖多少点
计算几何基础【用图来助你理解几何算法】
qq_45249273的博客
03-28 9881
计算几何基础 1.基本概念 1.1计算几何的引入 ​ 计算几何是几何学的一个重要分支，也是计算机科学的一个分支,研究解决几何问题的算法。在现代工程与数学、计算机图形学、机器人学、VLSI设计、计算机辅助设计等学科领域中,计算几何都有重要应用。 计算几何问题的输入一般是关于一组几何物体(如点、线)的描述;输出常常是有关这些物体相关问题的回答，如直线是否相交、点围成的面积等问题。 1.2 浮点数造成的误差 ​ 在学习计算几何之前，我们来回顾一下高中知识，我们求直线方程，或者是交点时，经常出现根号多少多少，以至我
计算几何基础知识整理大全 代码模板与证明过程 （直线、向量、多边形、三维计算几何、凸包、半平面交、最小圆覆盖）
harry12138小白的博客
03-08 3332
计算几何基础知识 1、求π\piπ的方法 我们在代码中一般把π\piπ记作PI，PI = acos(-1)。因为我们都知道cos(π\piπ) = -1，所以PI = arccos(-1)。 acos() 2、余弦定理 c^2 = a^2 + b^2 - 2acos(t); 3、向量 （1）向量的加、减、数乘运算 计算：坐标分别直接相加减乘。 对应几何意义：平行四边形法则。 （2）向量的内积 内积也称作点积：a⃗⋅b⃗=∣a⃗∣⋅∣b⃗∣⋅cosθ\vec a \cdot \vec b = |\vec a|
NOI数学：计算几何
青少年趣味编程
10-03 1647
NOI数学：计算几何
三维计算几何模版
idealism_xxm的专栏
05-08 2216
网上找了一个三维计算几何模版，完善了一下，使它能使用了...
【计算几何】 向量基础
这里是阿安的博客
03-25 1014
向量基础。
2021-07-10-计算几何总结
I_have_a_world的博客
07-10 1615
说明 1.以基础知识为主，尽量少用或不用模板。ps:其实挺简单的。 2. 基础知识 判断两线段的关系：相交，不相交，重合
计算几何总结——点,线,面,形的基本关系(重点叉积和点积)
mumei的博客
07-15 754
最近刷了一些计算几何入门的题，有一些小小的体会，便来做个小总结吧。这是我自己的个人总结，本身自身水平不是特别高，所以这篇文章主要讲的是怎么去学计算几何，以及一些好的学习资源。 首先分享一下计算几何的基础知识的学习资源: https://linxi99.gitee.io/20190211/ACM几何基础篇/ 大家也可以关注一下这位大佬——林夕林夕，他有很多关于计算几何的博文，讲的都挺不错。 下...
ACM计算几何基础模板，杭电老学长精心整理.pdf
03-25
标题中的“ACM计算几何基础模板，杭电老学长精心整理”指向了ACM（国际大学生程序设计竞赛）中计算几何领域的一个基础知识点集合。这些知识点是编程竞赛的参赛者在处理几何问题时的基本工具。计算几何是计算机科学的...
C++计算几何.docx
05-17
这些运算是计算几何的基础，它们可以用来实现更复杂的几何运算。 判断正负函数 (sgn) ------------------ 判断正负函数是计算几何中一个重要的函数，它可以判断一个数是否大于、等于或小于 0。该函数广泛应用于...
基于SVM算法的人民币面值识别系统：从图像处理到机器学习模型的实现与应用 · 数字图像处理
08-11
基于支持向量机(SVM)的人民币面值识别系统的设计与实现。该系统利用MATLAB GUI工具，结合数字图像处理技术和机器学习模型，能够高效识别多种面值的人民币。主要步骤包括数据集准备、图像灰度化、边缘检测、旋转矫正、形态学操作、ROI截取、加载SVM模型、面值识别及结果验证。系统目前可识别1元至100元面值，正确率达到90%以上，并可通过扩展训练数据集来提升识别精度和覆盖更多面值。 适合人群：从事图像处理、机器学习研究的技术人员，以及对人民币面值识别感兴趣的开发者。 使用场景及目标：适用于银行、自助设备、零售终端等需要快速准确识别人民币面值的场合。目标是提供一种高效、准确、易用的人民币面值识别解决方案。 其他说明：该系统不仅展示了SVM在图像分类任务中的强大能力，还通过MATLAB GUI实现了操作流程的可视化，便于用户理解和使用。未来可以通过优化算法和增加训练样本进一步提升系统性能。
ctkqiang-WangZhongZhi-62936-1753627160067.zip
08-11
点sun小白ctkqiang_WangZhongZhi_62936_1753627160067.zip
LabVIEW调用基恩士XGX8500相机实现高效画面嵌入的开源方案 权威版
08-11
如何使用LabVIEW调用基恩士XGX8500相机实现画面嵌入的技术方案。首先，文中强调了准备工作的重要性，包括安装LabVIEW及其相关驱动和SDK，获取基恩士XGX8500相机的接口文档。接着，阐述了通过调用基恩士提供的API控制相机的具体步骤，如初始化相机、设置参数、开启预览流、获取画面数据等。然后，讲解了如何将获取的画面数据嵌入到LabVIEW的程序中，通过图形界面设计使相机画面合理显示。最后，指出该方案不仅能够节省昂贵的HX软件授权费用，还因其源程序和方法的开放性，为用户提供更多定制化的可能。 适合人群：从事工业自动化、机器视觉领域的工程师和技术人员。 使用场景及目标：适用于需要集成高质量图像采集设备的工业生产和检测系统，旨在提升自动化水平和视觉信息丰富度，降低软件授权成本。 其他说明：文中附有简单代码片段，帮助读者更好地理解和实践该方案。
PANDA 真空泵 WV 1200 A、WV 1800 A 和 WV 2400 A 使用说明书.pdf
最新发布
08-11
PANDA 真空泵 WV 1200 A、WV 1800 A 和 WV 2400 A 使用说明书.pdf
基于Jenkins Pipeline实现Java项目自动化构建与发布
08-11
资源下载链接为： https://pan.quark.cn/s/22ca96b7bd39 在当今的软件开发领域，自动化构建与发布是提升开发效率和项目质量的关键环节。Jenkins Pipeline作为一种强大的自动化工具，能够有效助力Java项目的快速构建、测试及部署。本文将详细介绍如何利用Jenkins Pipeline实现Java项目的自动化构建与发布。 Jenkins Pipeline简介 Jenkins Pipeline是运行在Jenkins上的一套工作流框架，它将原本分散在单个或多个节点上独立运行的任务串联起来，实现复杂流程的编排与可视化。它是Jenkins 2.X的核心特性之一，推动了Jenkins从持续集成（CI）向持续交付（CD）及DevOps的转变。 创建Pipeline项目 要使用Jenkins Pipeline自动化构建发布Java项目，首先需要创建Pipeline项目。具体步骤如下： 登录Jenkins，点击“新建项”，选择“Pipeline”。 输入项目名称和描述，点击“确定”。 在Pipeline脚本中定义项目字典、发版脚本和预发布脚本。 编写Pipeline脚本 Pipeline脚本是Jenkins Pipeline的核心，用于定义自动化构建和发布的流程。以下是一个简单的Pipeline脚本示例： 在上述脚本中，定义了四个阶段：Checkout、Build、Push package和Deploy/Rollback。每个阶段都可以根据实际需求进行配置和调整。 通过Jenkins Pipeline自动化构建发布Java项目，可以显著提升开发效率和项目质量。借助Pipeline，我们能够轻松实现自动化构建、测试和部署，从而提高项目的整体质量和可靠性。
信捷PLC与HMI驱动的印刷机设备程序：四步进电机控制与汽缸印刷系统的开发与学习
08-11
信捷PLC与HMI驱动的印刷机设备程序，涵盖四个步进电机控制（X、Y、Z三向抓取定位放置系统）和分度转盘定位系统。程序包含详细的注释，便于理解和维护。信捷PLC采用标准工业编程语言，确保高稳定性和可靠性；HMI界面设计直观易用，增强了操作便捷性。该程序适用于表盘和电路板等印刷设备的开发，支持自动化生产和提高生产效率。 适合人群：工控爱好者、印刷设备开发者和技术人员。 使用场景及目标：①用于表盘和电路板等印刷设备的开发；②作为工控爱好者的学习参考资料；③提升自动化生产能力，优化生产流程，降低成本。 其他说明：该程序不仅为实际生产提供了技术支持，同时也帮助工控爱好者提高技术水平和实践能力。
小信号精密全波整流电路.doc
08-11
小信号精密全波整流电路.doc
计算几何基础：凸包模板与线段属性
此外，资料还提到了计算几何中的线段属性、多边形面积和重心等概念，强调了计算几何基础知识的重要性。" 在计算机几何中，凸包是包含所有给定点的最小凸多边形。这段代码提供的是一种叫做Graham扫描的算法来找到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值