旋转卡壳

最新推荐文章于 2021-12-21 13:13:16 发布
最新推荐文章于 2021-12-21 13:13:16 发布
阅读量100 收藏
点赞数 1
分类专栏： 计算几何
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/drywwltu/article/details/118001645
版权 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <utility>
#include <climits>
#include <cstring>
#include <vector>
#include <algorithm>
#define eps 1e-8
#define N_MAX 300005
using std::pair;
using std::vector;
int n;
int sign(double x){ //符号
    if(fabs(x) < eps)return 0;
    if(x < 0)return -1;
    return 1;
}
struct Point{
    double x,y;
    Point(double x = 0,double y = 0):x(x),y(y){}
    Point operator+(Point a){
        return Point(x + a.x,y + a.y);
    }
    Point operator-(Point a){
        return Point(x - a.x,y - a.y);
    }
    Point operator*(double t){
        return Point(x * t,y * t);
    }
    Point operator/(double t){
        return Point(x / t,y / t);
    }
    bool operator==(Point a){
        return x == a.x && y == a.y;
    }
    double lenth(){ //向量的模
        return x * x + y * y;
    }
}point[N_MAX];
vector<Point> up,down;
bool cmp(Point p1,Point p2){
    if(sign(p1.x - p2.x) == 0)return p1.y < p2.y;
    return p1.x < p2.x;
}
typedef Point Vector;
double cross(Vector A,Vector B){  // 向量外积
    return A.x * B.y - B.x * A.y;
}
double dot(Vector A,Vector B){ //向量内积
        return B.x * A.x + B.y * A.y;
}
int isclock(Vector v1,Vector v2){ // 判断v2是否在v1的顺时针方向
    if(cross(v1,v2) < 0)return -1;
    if(cross(v1,v2) == 0)return 0;
    return 1;
}
bool used[N_MAX];
int sta[N_MAX],top;
void GetConvex(){ //凸包
    std::sort(point + 1,point + n + 1,cmp);
    for(int i = 1;i <= n;i++){
        while(top >= 2 && isclock(point[sta[top - 1]] - point[sta[top - 2]],point[i] - point[sta[top - 2]]) <= 0){
            if(isclock(point[sta[top - 1]] - point[sta[top - 2]],point[i] - point[sta[top - 2]]) == -1)used[sta[--top]] = false;
            else top--;
        }
        sta[top++] = i;
        used[i] = true;
    }
    used[1] = false;
    for(int i = n;i >= 1;i--){
        if(used[i])continue;
        while(top >= 2 && isclock(point[sta[top - 1]] - point[sta[top - 2]],point[i] - point[sta[top - 2]]) <= 0)top--;
        sta[top++] = i;
    }
    top--;
}
double RotatingCalipers(){ //旋转卡壳
    if(top <= 2)return (point[1] - point[n]).lenth();
    double res = 0;
    for(int i = 0,j = 2;i < top;i++){
        Point a = point[sta[i]],b = point[sta[i + 1]];
        while(sign(cross(b - a,point[sta[j]] - a) - cross(b - a,point[sta[j + 1]] - a)) < 0)j = (j + 1) % top;
        res = std::max(res,std::max((point[sta[j]] - a).lenth(),(point[sta[j]] - b).lenth()));
    }
    return res;
}
int main(int argc,char *argv[]){
    scanf("%d",&n);
    for(int i = 1;i <= n;i++){
        double x,y;
        scanf("%lf %lf",&x,&y);
        point[i] = Point(x,y);
    }
    GetConvex();
    printf("%.0lf\n",RotatingCalipers());
    return 0;
}



#include <cstdio>
#include <iostream>
#include <cmath>
#include <utility>
#include <climits>
#include <cstring>
#include <vector>
#include <algorithm>
#define eps 1e-12
#define N_MAX 300005
#define pi acos(-1)
using std::pair;
using std::vector;
int n;
int sign(double x){ //符号
    if(fabs(x) < eps)return 0;
    if(x < 0)return -1;
    return 1;
}
struct Point{
    double x,y;
    Point(double x = 0,double y = 0):x(x),y(y){}
    Point operator+(Point a){
        return Point(x + a.x,y + a.y);
    }
    Point operator-(Point a){
        return Point(x - a.x,y - a.y);
    }
    Point operator*(double t){
        return Point(x * t,y * t);
    }
    Point operator/(double t){
        return Point(x / t,y / t);
    }
    bool operator==(Point a){
        return x == a.x && y == a.y;
    }
    double lenth(){ //向量的模
        return sqrt(x * x + y * y);
    }
}point[N_MAX];
vector<Point> up,down;
bool cmp(Point p1,Point p2){
    if(sign(p1.x - p2.x) == 0)return p1.y < p2.y;
    return p1.x < p2.x;
}
typedef Point Vector;
struct Line{
    Point a,b;
    Line(){}
    Line(Point a,Point b){
        this->a = a;
        this->b = b;
    }
}line[N_MAX];
double cross(Vector A,Vector B){  // 向量外积
    return A.x * B.y - B.x * A.y;
}
double dot(Vector A,Vector B){ //向量内积
        return B.x * A.x + B.y * A.y;
}
int isclock(Vector v1,Vector v2){ // 判断v2是否在v1的顺时针方向
    if(cross(v1,v2) < 0)return -1;
    if(cross(v1,v2) == 0)return 0;
    return 1;
}
double GetAngle(Vector v1,Vector v2){ // 算两向量夹角
    return acos(dot(v1,v2) / v1.lenth() / v2.lenth());
}
Vector rotate(Vector v,double angle){
    return Vector(v.x * cos(angle) + v.y * sin(angle),-v.x * sin(angle) + v.y * cos(angle));
}
Point GetPointForLine(Line X,Line Y){ // 算直线交点
    Vector v = X.a - X.b;
    Vector w = Y.a - Y.b;
    Vector u = X.a - Y.a;
    double base = (cross(w,u)) / (cross(v,w));
    return X.a + v * base;
}
double DistanceForLine(Point P,Line X){ // 算点到直线的距离
    Vector vp = X.b - X.a,vq = P - X.a;
    return fabs(cross(vp,vq))/vp.lenth();
}
double DistanceForSegment(Point P,Line X){ //点到线段的距离
    if(X.a == X.b)return (P - X.a).lenth();
    Vector v1 = X.b - X.a,v2 = P - X.a,v3 = P - X.b;
    if(sign(dot(v1,v2)) < 0) return v2.lenth();
    if(sign(dot(v1,v3)) > 0) return v3.lenth();
    return DistanceForLine(P,X);
}
Point GetProjectionInLine(Point P,Line X){ //点到直线上的投影
    Vector v = X.b - X.a;
    return X.a + v * (dot(v,P - X.a) / dot(v,v));
}
bool SegmentIntersection(Line X,Line Y){ //两线段是否相交
    double c1 = cross(X.b - X.a,Y.a - Y.b),c2 = cross(X.b - X.a,Y.b - X.a);
    double c3 = cross(Y.b - Y.a,X.b - Y.a),c4 = cross(Y.b - Y.a,X.a - Y.a);
    return sign(c1) * sign(c2) <= 0 && sign(c3) * sign(c4) <= 0;
}
pair<Point,Point> PointWithCircleAndLine(Point o,Line X,double r){ // 求圆与直线的交点
    Point o2 = o;
    o2.x += X.a.y - X.b.y;
    o2.y += X.b.x - X.a.x;
    o2 = GetPointForLine(Line(o,o2),X);
    double base = sqrt(r * r - (o2 - o).lenth() * (o2 - o).lenth());
    Vector e = (X.b - X.a) / (X.b - X.a).lenth();
    return std::make_pair(o2 - e * base,o2 + e * base);
}
bool used[N_MAX];
int sta[N_MAX],top;
void GetConvex(){
    std::sort(point + 1,point + n + 1,cmp);
    for(int i = 1;i <= n;i++){
        while(top >= 2 && isclock(point[sta[top - 1]] - point[sta[top - 2]],point[i] - point[sta[top - 2]]) <= 0){
            if(isclock(point[sta[top - 1]] - point[sta[top - 2]],point[i] - point[sta[top - 2]]) == -1)used[sta[--top]] = false;
            else top--;
        }
        sta[top++] = i;
        used[i] = true;
    }
    used[1] = false;
    for(int i = n;i >= 1;i--){
        if(used[i])continue;
        while(top >= 2 && isclock(point[sta[top - 1]] - point[sta[top - 2]],point[i] - point[sta[top - 2]]) <= 0)top--;
        sta[top++] = i;
    }
    top--;
}
Point ans[5];
double S = 1e20;
void RotatingCalipers(){
    for(int i = 0,a = 2,b = 2,c = 2;i < top;i++){
        Point d = point[sta[i]],e = point[sta[i + 1]];
        while(sign(cross(e - d,point[sta[a]] - d) - cross(e - d,point[sta[a + 1]] - d)) < 0)a = (a + 1) % top;
        while(sign(dot(e - d,point[sta[b]] - d) / (e - d).lenth() - dot(e - d,point[sta[b + 1]] - d) / (e - d).lenth()) < 0)b = (b + 1) % top;
        if(!i) c = a;
        while(sign(dot(e - d,point[sta[c]] - d) / (e - d).lenth() - dot(e - d,point[sta[c + 1]] - d) / (e - d).lenth()) > 0)c = (c + 1) % top;
        Point x = point[sta[a]],y = point[sta[b]],z = point[sta[c]];
        //std::cout << a << " " << b << " " << c << std::endl;
        double h = cross(e - d,x - d) / (e - d).lenth();
        double w = dot(y - z,e - d) / (e - d).lenth();
        if(h * w < S){
            S = h * w;
            ans[0] = d + ((e - d) / (e - d).lenth()) * (dot(e - d,y - d) / (e - d).lenth());
            ans[3] = d + ((e - d) / (e - d).lenth()) * (dot(e - d,z - d) / (e - d).lenth());
            Vector u = rotate(e - d,-pi / 2);
            ans[1] = ans[0] + (u / u.lenth()) * h;
            ans[2] = ans[3] + (u / u.lenth()) * h;
        }
    }
}
int main(int argc,char *argv[]){
    scanf("%d",&n);
    for(int i = 1;i <= n;i++){
        double x,y;
        scanf("%lf %lf",&x,&y);
        point[i] = Point(x,y);
    }
    GetConvex();
    RotatingCalipers();
    int k = 0;
    for(int i = 1;i < 4;i++){
        if(sign(ans[i].y - ans[k].y) < 0 || (sign(ans[i].y - ans[k].y) == 0 && sign(ans[i].x - ans[k].x) < 0)){
            k = i;
        }
    }
    printf("%.5lf\n",S);
    for(int i = 0;i < 4;i++,k++){
        double x = ans[k % 4].x;
        double y = ans[k % 4].y;
        if(sign(x) == 0)x = 0;
        if(sign(y) == 0)y = 0;
        printf("%.5lf %.5lf\n",x,y);
    }
    return 0;
}
drywwltu
关注
专栏目录
旋转卡壳，三种实现方式。
Dch19990825的博客
05-16 1093
上述中说的三种是方式分别是 kuangbin的-容易理解 挑战书上的-容易实现 我的-我的理解 第一种kuangbin板子 class Point { public: double x,y; Point() {} Point(double x,double y):x(x),y(y) { } Point operator+ (Point p)...
旋转卡壳算法
HumveeA6的博客
05-08 607
讲解见：http://www.cnblogs.com/Booble/archive/2011/04/03/2004865.html 实现：（在原有求凸包的基础上增加即可） double cross(Pt a,Pt b,Pt c)//求叉积 { return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x); } double dist2(Pt a,P...
旋转卡壳卡卡
我叫MK
12-12 3217
关于旋转卡壳的比较详细的介绍，这里有两篇文章（支持原创，拒绝转载） http://blog.sina.com.cn/s/blog_4afd4f7c010004y4.htmlhttp://www.cppblog.com/staryjy/archive/2010/09/25/101412.html 这两篇适合于不知道旋转卡壳为何物时入门用。另外，这里有关于旋转卡壳详尽的解释与应用说明（包括点集的直径，凸多边形的宽，两凸包的最远距离，两凸包的最近距离等）http://cgm.cs.mcgill.ca/~orm
旋转卡壳法总结
天亮说晚安
08-20 2118
以下所有文章均转载（ http://blog.csdn.net/acmaker/article/details/3176910） 转载请注明出处！  1、旋转卡壳——翻译说明文档   前一段时间看了一位国外大牛的网站，是关于旋转卡壳技术的，内容很不错，就尝试着翻译一下。      关于旋转卡壳技术，最早是在刘汝佳、黄亮的《算法艺术与信息学竞赛》上看到的，是计算几何相关的技术，开始觉得很神奇，
[Poj 2187]计算几何之凸包(三) {旋转卡壳初步}
weixin_34400525的博客
04-03 184
{ 上一节介绍了凸包的高效算法 和一个最远点对的应用 这一段将更好的解决最远点对问题 } (若不做特殊说明 下文讨论的问题均是在欧氏空间 若不做特殊说明 下文中距离均是指空间中欧氏距离) ============================== 一.简单枚举算法的不足 上一次介绍了一个基本的求平面最远点对的算法 即先求点集的凸包 然后枚举凸包上的点来求最远点集 这是利用...
20200226 专题：旋转卡壳
hongkongreporter
02-26 171
总览： 读法：共242^424种读法 旋：xuan 二声； xuan 四声； 转：zhuan 三声；zhuan 四声； 卡：ka 三声 ；qia 三声； 壳：ke 三声 ；qiao 四声； 再乘法原理跑一跑… 用于找凸包直径（在凸包上各种骚…） 固定一条边，使一个点在凸包上移动，发现点到边两端点（任意一个）的距离是一个单峰函数（于是我们可以三分 ） 当固定边顺时针移动到下一条边时，最远点必定顺时...
旋转卡壳算法讲解
12-01
1978年， M.I. Shamos's Ph.D. 的论文"Computational ... 因此就有了术语“旋转卡壳”。 1983年， Toussaint发表了一篇论文， 其中用同样的技术来解决许多问题。 从此， 基于此模型的新算法就确立了， 解决了许多问题。
凸包+旋转卡壳专题
Qianyri的博客
07-28 1102
洛谷P2742 求凸包周长 #include&lt;bits/stdc++.h&gt; using namespace std; const int MAX=1e4+1; const double eps=1e-8; struct point { double x,y; point(){} point(double a,double b) { ...
最小圆覆盖算法（C#）
07-09
C#实现的最小圆覆盖算法。给定一个点(x,y)的列表，返回圆心坐标和半径。
[USACO03FALL]Beauty Contest G /【模板】旋转卡壳
hbhcchen的博客
12-21 373
题目描述 给定平面上n个点，求凸包直径。 输入格式 第一行一个正整数n。 接下来n行，每行两个整数x,y，表示一个点的坐标。 输出格式 输出一行一个整数，表示答案的平方。 输入输出样例 输入 #1 4 0 0 0 1 1 1 1 0 输出 #1 2 说明/提示 【数据范围】 对于100\%100%的数据，2≤n≤50000，10^4∣x∣,∣y∣≤104。 实现 首先我们求出来一个凸包（绿色），然后才能找直径（红色） 找直径的方式：找两个点，做一条平行...
【精】【旋转卡壳】讲的太好了！！！
Jiangzh_MZOI
04-14 792
[Poj 2187]计算几何之凸包(三) {旋转卡壳初步} ============================== 一.简单枚举算法的不足 上一次介绍了一个基本的求平面最远点对的算法 即先求点集的凸包 然后枚举凸包上的点来求最远点集 这是利用了凸包上的点相比 点集中的点 一般是很少的 平均情况很好 并且我们也能AC这个问题 但是这是有局限性的 当凸包上的点达到O(N)的级
Bridge Across Islands（计算几何，两多边形之间的最小距离，旋转卡壳）
0k-ok
08-05 1206
总在不经意的年生，回首彼岸，纵然发现光景绵长。 Thousands of thousands years ago there was a small kingdom located in the middle of the Pacific Ocean. The territory of the kingdom consists two separated islands. Due to the ...
POJ 3608 Bridge Across Islands(旋转卡壳 求不相交凸包之间的最短距离)
sunrain的专栏
08-01 713
题目链接：http://poj.org/problem?id=3608 表示旋转卡壳这个算法看起来比较好懂（虽然证明起来还是有一点难度的，但是只观的看还是比较好理解的）但是代码实现起来还是不怎么好理解的 关键在计算几何这里面要求尽量不涉及到角度的计算，基本上都是点积和差积，因为这样能避免调用系统的三角函数，所以能最大限度的减少精度 损失 这个题目可以用枚举方法，可以用凸包的单调性来
【凸包】poj 2187 Beauty Contest (旋转卡壳求平面最远点对)
Hi_jiaxinwei的博客
07-16 1058
旋转卡壳算法原理讲解：点击打开链接 旋转卡壳算法的使用范围很广，我只学习了求平面最远点对的方法； 旋转卡壳求平面最远点对方法： 如果qa，qb是凸包上最远两点，必然可以分别过qa，qb画出一对平行线。通过旋转这对平行线，我们可以让它和凸包上的一条边重合,如图中蓝色直线，可以注意到，qa是凸包上离p和qb所在直线最远的点。 于是我们的思路就是枚举凸包上的所有边，对每一条边找出凸包上离
旋转卡壳——目录页
ACMaker的专栏
10-29 7700
一些历史：1978年， M.I. Shamoss Ph.D. 的论文"Computational Geometry"标志着计算机科学的这一领域的诞生。 当时他发表成果的是一个寻找凸多边形直径的一个非常简单的算法， 即根据多边形的一对点距离的最大值来确定。 后来直径演化为由一对对踵点对来确定。 Shamos提出了一个简单的 O(n) 时间的算法来确定一个凸 n 角形的对踵点对。 因为他们最多只有
旋转卡壳python
最新发布
09-11
旋转卡壳是一种用于解决计算凸多边形直径和其他相关问题的算法。旋转卡壳算法的思想是通过旋转两条卡壳边来逐步逼近问题的解。下面是一个使用Python实现旋转卡壳算法的代码： def get_dist(a, b): dx = a - b dy ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值