计算几何 val.2

目录

  • 计算几何 val.2
    • 几何单位结构体板子
    • 旋转卡壳
      • 基础概念
      • 求法
      • 模板
    • 半平面交
      • 前置芝士:线段交
      • S&I算法
      • 模板
    • 最小圆覆盖
      • 随机增量法
      • 时间复杂度
      • 模板
    • 后记

计算几何 val.2

前置芝士:基础操作以及凸包

本文主要写旋转卡壳、半平面交、最小圆覆盖要注意的内容

几何单位结构体板子

不全(我知道

struct point{
    double x,y;
    point(double x=0,double y=0): x(x),y(y){} //构造函数,非常方便
    double operator*(point b){ //叉积 
        return x*b.y-y*b.x;
    }
    double operator^(point b){ //点积 
        return x*b.x+y*b.y;
    }
    point operator-(point b){
        return point(x-b.x,y-b.y);
    } 
    point operator+(point b){
        return point(x+b.x,y+b.y);
    }//向量运算
    point operator*(double b){ //数乘 
        return point(x*b,y*b);
    }
    db dis(){ //模长
        return sqrt(x*x+y*y);
    }
}b[N];
int comp0(double x){
    return fabs(x)<=eps?0:(x>0?1:-1);
}//判0,防止精度误差
struct line{
    point p,v;//p起点,v终点 ,表示线段
    double theta;
    bool operator <(line y){
        return comp0(theta-y.theta)==0?comp0((y.v-p)*(v-p))<0:comp0(theta-y.theta)<0;
    }//排序,保证第一关键字是极角,第二关键字是与右边的距离(用叉积判相对关系,在左边的放后面) 
};
point inter(line a,line b){//交点  intersection 
    point v1=a.v-a.p,v2=b.v-b.p;
    return b.p+v2*(((b.p-a.p)*v1)/(v1*v2));
}//此处默认了没有平行的情况 , 判断线段有没有交点就是判断点是否在线段上,但是半平面交是直线(只是用线段表示)

旋转卡壳

\[ \Large{\text{旋↗转↘↗卡↘↗壳(ko↗)}} \]
对,非常正确

此算法用来求凸多边形直径

基础概念

  1. 切线

    过顶点的一条线,这个多边形都在这条线的一侧

  2. 对踵点

    多边形上两个点作一对平行线,整个多边形都在这两条线之间

求法

考虑逆时针枚举每条边并找到距离这条边最远的点,那么这个点和这条边的一个顶点构成的直径是可能的答案

我们惊奇地发现,点出现的顺序也是逆时针的,那么就可以\(O(n)\)求出了

(当然求凸包还要\(n\log n\)

补充:如果要求单独一条边的最远点的话,可以三分求(单峰函数)

模板

#include
#include
#include
#include
#include
#define db double
using namespace std;
struct point{
    double x,y;
    point(double x=0,double y=0): x(x),y(y){}
    double operator*(point b){
        return x*b.y-y*b.x;
    }
    point operator-(point b){
        return point(x-b.x,y-b.y);
    } 
    point operator+(point b){
        return point(x+b.x,y+b.y);
    }
    db dis(){
        return sqrt(x*x+y*y);
    }
}; 
const int N = 50021;
point p[N],h[N];
int tp=0,stk[N],usd[N];
int cmp(point a,point b){
    return a.x==b.x?a.y0?a:-a;
}
db disl(point a,point b,point x){
    return Fabs((a-x)*(b-x)/(a-b).dis());
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lf%lf",&p[i].x,&p[i].y);
    }
    sort(p+1,p+n+1,cmp);
    stk[++tp]=1;
    for(int i=2;i<=n;i++){
        while(tp>1&&(p[stk[tp]]-p[stk[tp-1]])*(p[i]-p[stk[tp]])<=0) usd[stk[tp--]]=0;
        usd[i]=1;stk[++tp]=i;
    }
    int ntp=tp;
    for(int i=n-1;i>=1;i--){
        if(!usd[i]){
            while(tp>ntp&&(p[stk[tp]]-p[stk[tp-1]])*(p[i]-p[stk[tp]])<=0) usd[stk[tp--]]=0; 
            usd[i]=1;stk[++tp]=i;           
        }
    }
    for(int i=1;i<=tp;i++){
        h[i]=p[stk[i]];
    }
    if(tp<=2){ //只有一个点 
        puts("0");
        return 0;
    }
    if(tp==3){  
        printf("%.0lf\n",(h[1]-h[2]).dis()*(h[1]-h[2]).dis());
        return 0;
    }
    db ans=0;
    int t=1;
    //注意最后一个点(就是1号点)要保留,因为后面有h[i+1],[t+1],方便操作 
    for(int i=1;i

半平面交

半平面此处我们用向量表示,以左侧或右侧为半平面

前置芝士:线段交

画图吧,用相似得出
\[ h_1=\frac{fabs((v_2-p_1)*(p_2-p_1))}{dis(v_2-p_2)},h_2=\frac{fabs((v_2-v_1)*(p_2-v_1))}{dis(v_2-p_2)} \]

\[ line(p_1,v_1) \cap line(p_2,v_2)=p_1+(v_1-p_1)*\frac{h_1}{h_1+h_2} \]

S&I算法

极角排序

\(\theta=arctan\frac y x\),以其从小到大排序,得到新的向量集

算法流程

  1. 以逆时针为正方向,建边(线段)

  2. 对线段根据极角排序

  3. 去除极角相同的情况下,位置在右边的边(如果求的是左半平面交(逆时针凸多边形)的话)

  4. 双端队列储存线段集合 \(L\),遍历所有线段

  5. 判断该线段加入后对半平面交的影响,(对双端队列的头部和尾部进行判断,因为线段加入是有序的,有影响是指交点在这条线的另一边(不需要的一边)),即判断之前的交点是否在次线段右侧
  6. 上一步一定要先删尾部再删头部,具体见wjyyy大佬的博客,后文会附上

  7. 最后判断形成环的影响(尾部再更新头部一次,头部再更新尾部一次)

  8. 最后剩下的线段集合 \(L\),即使最后要求的半平面交
  9. 全程都可以用叉积判方向

模板

#include
#include
#include
#include
#include
#define db double
const double eps=1e-9;
using namespace std;
const int N = 10001;
struct point{
    double x,y;
    point(double x=0,double y=0): x(x),y(y){}
    double operator*(point b){ //叉积 
        return x*b.y-y*b.x;
    }
    double operator^(point b){ //点积 
        return x*b.x+y*b.y;
    }
    point operator-(point b){
        return point(x-b.x,y-b.y);
    } 
    point operator+(point b){
        return point(x+b.x,y+b.y);
    }
    point operator*(double b){ //数乘 
        return point(x*b,y*b);
    }
    db dis(){ //模长
        return sqrt(x*x+y*y);
    }
}b[N];
int comp0(double x){
    return fabs(x)<=eps?0:(x>0?1:-1);
}
struct line{
    point p,v;//p起点,v终点 ,表示线段 
    double theta;
    bool operator <(line y){
        return comp0(theta-y.theta)==0?comp0((y.v-p)*(v-p))<0:comp0(theta-y.theta)<0;
    }//排序,保证第一关键字是极角,第二关键字是与右边的距离(用叉积判相对关系,在左边的放后面) 
};
point inter(line a,line b){//交点  intersection 
    point v1=a.v-a.p,v2=b.v-b.p;
    return b.p+v2*(((b.p-a.p)*v1)/(v1*v2));
}//此处默认了没有平行的情况 , 判断线段有没有交点就是判断点是否在线段上,但是半平面交是直线(只是用线段表示)
int out(line a,line b,line k){
    point ins=inter(a,b); //此处要判断的是ins是否在k的右边,画个图 
    return comp0((k.v-k.p)*(ins-k.p))<0;
} 
int n;
line a[N],q[N];int top;
void work(){
    sort(a+1,a+top+1);
    int cnt=0;
    for(int i=1;i<=top;i++){
        if(comp0(a[i].theta-a[i-1].theta)!=0) cnt++;
        a[cnt]=a[i];//极角相同时,右边的更优(排序保证了在左边) 
    }
    int h=1,t=0;
    q[++t]=a[1],q[++t]=a[2];//既然是交,至少包含两个元素
    for(int i=3;i<=cnt;i++){
        while(h

最小圆覆盖

使用随机增量法

随机增量法

考虑钦定\(i,j\)一定在圆上,\(j < i\)

对于\(\forall k,考虑构造覆盖\(i,j,k\)的圆

如果当前\(k\)在圆内,计算\(k+1\)

否则更新为\(i,j,k\) 的外接圆(三点确定圆)

对于前面两层,如果某个点在圆内,直接跳过

否则枚举\(j\in [1,i)\) ,重新计算

时间复杂度

看起来是三层循环啊QwQ,在圆内的点再多也优化不了多少吧?

但是我们最开始 \(\text{random_suffle}\) 了一下,于是复杂度变成了期望意义下的

那么是多少呢?男默女泪的是,它达到了惊人的\(O(n)\)

分析:

  1. 对于过\(P_i,P_j\)的圆,每个点至少循环了一遍,为\(O(j)\)
  2. 对于过\(P_i\)的圆,考虑覆盖前\(i\)个点的圆是由3个点确定的,于是在前\(i-1\)个点中,期望有2个点计算了下一层
  3. 对于所有点的最小圆覆盖,期望有三个点能做出贡献
  4. 总复杂度:\(O\left(\sum_{i=1}^{n} \frac{3}{i} \sum_{j=1}^{i} \frac{2}{j} \cdot j\right)=O(6\cdot n)=O(n)\)

模板

#include
#include
#include
#include
#include
#define db double
#include
#include
const double eps=1e-17;
using namespace std;
const int N = 100001;
struct point{
    double x,y;
    point(double x=0,double y=0): x(x),y(y){}
    double operator*(point b){ //叉积 
        return x*b.y-y*b.x;
    }
    double operator^(point b){ //点积 
        return x*b.x+y*b.y;
    }
    point operator-(point b){
        return point(x-b.x,y-b.y);
    } 
    point operator+(point b){
        return point(x+b.x,y+b.y);
    }
    point operator*(double b){ //数乘 
        return point(x*b,y*b);
    }
    db dis(){ //模长
        return sqrt(x*x+y*y);
    }
}p[N];
int comp0(double x){
    return fabs(x)<=eps?0:(x>0?1:-1);
}
struct line{
    point p,v;//p起点,v终点 ,表示线段 
    line(point a,point b): p(a),v(b){}
    double theta;
    bool operator <(line y){
        return comp0(theta-y.theta)==0?comp0((y.v-p)*(v-p))<0:comp0(theta-y.theta)<0;
    }//排序,保证第一关键字是极角,第二关键字是与右边的距离(用叉积判相对关系,在左边的放后面) 
};
point inter(line a,line b){//交点  intersection 
    point v1=a.v-a.p,v2=b.v-b.p;
    return b.p+v2*(((b.p-a.p)*v1)/(v1*v2));
}//此处默认了没有平行的情况 , 判断线段有没有交点就是判断点是否在线段上,但是半平面交是直线(只是用线段表示)
int out(line a,line b,line k){
    point ins=inter(a,b); //此处要判断的是ins是否在k的右边,画个图 
    return comp0((k.v-k.p)*(ins-k.p))<0;
} 
int n;
int in(point k,point c,double r){
    return comp0(r-(k-c).dis())>=0;
}
point chrt(point a){
    return point(-a.y,a.x);
} 
void randomShuffle(){
    srand(19260817+time(0)); //知道为什么不用STL的吗? 
    for (int i=1;i<=n;i++){
        int j=(rand()%n+1926)%n+1;//这里随便rand()%n就行了,但我们要把玄学发扬光大【滑稽】
        swap(p[i],p[j]);
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lf%lf",&p[i].x,&p[i].y);
    }
    randomShuffle(); //这句很重要
    point c;
    db r=0.0;
    for(int i=1;i<=n;i++){
        if(in(p[i],c,r)) continue;
        c=p[i],r=0;//重新计算
        for(int j=1;j

后记

我是看这个DALAO的博客学的

应该还有val.3 (学习nekopara

就写一写 定积分基础 / 闵可夫斯基和 / 辛普森积分 (自适应辛普森) 啥的

你可能感兴趣的:(计算几何 val.2)