bzoj 1185 旋转卡壳 最小矩形覆盖

题目大意 就是求一个最小矩形覆盖,逆时针输出其上面的点

这里可以看出,那个最小的矩形覆盖必然有一条边经过其中凸包上的两个点,另外三条边必然至少经过其中一个点,而这样的每一个点逆时针走一遍都满足单调性

所以可以利用旋转卡壳的思想找到这样的三个点

以每一条边作为基础,循环n次得到n个这样的矩形,找到其中面积最小的即可

然后自己画画图,作出矩形对应的两条边的单位向量,那么这四个点就非常好求了

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <cmath>
  5 #include <algorithm>
  6 using namespace std;
  7 #define N 50010
  8 #define eps 1e-9
  9 const double PI = acos(-1.0);
 10 int n , top;
 11
 12 int dcmp(double x)
 13 {
 14     if(fabs(x)<eps) return 0;
 15     return x<0?-1:1;
 16 }
 17
 18 struct Point{
 19     double x , y;
 20     Point(double x=0 , double y=0):x(x),y(y){}
 21     void input(){scanf("%lf%lf" , &x , &y);}
 22     void output(){printf("%.5f %.5f\n" , x , y);}
 23     bool operator<(const Point &m)const{
 24         return x<m.x||(x==m.x&&y<m.y);
 25     }
 26 }po[N] , rec[N] , p[4];
 27
 28 typedef Point Vector;
 29
 30 Vector operator+(Vector a , Vector b){return Vector(a.x+b.x , a.y+b.y);}
 31 Vector operator-(Vector a , Vector b){return Vector(a.x-b.x , a.y-b.y);}
 32 Vector operator*(Vector a , double b){return Vector(a.x*b , a.y*b);}
 33 Vector operator/(Vector a , double b){return Vector(a.x/b , a.y/b);}
 34 double operator*(Vector a , Vector b){return a.x*b.y-a.y*b.x;}
 35
 36 double Dot(Vector a , Vector b){return a.x*b.x+a.y*b.y;}
 37 double Len(Vector a){return sqrt(Dot(a,a));}
 38 int Polxy()
 39 {
 40     sort(po , po+n);
 41     rec[0]=po[0] , rec[1]=po[1];
 42     top=2;
 43     for(int i=2 ; i<n ; i++){
 44         while(top>=2&&(rec[top-1]-rec[top-2])*(po[i]-rec[top-2])<=0)
 45             top--;
 46         rec[top++] = po[i];
 47     }
 48     int tmp=top;
 49     for(int i=n-2 ; i>=0 ; i--){
 50         while(top>=tmp&&(rec[top-1]-rec[top-2])*(po[i]-rec[top-2])<=0)
 51             top--;
 52         rec[top++] = po[i];
 53     }
 54     top--;
 55     return top;
 56 }
 57
 58 Vector Normal(Vector a)
 59 {
 60     double l = Len(a);
 61     return Vector(-a.y/l , a.x/l);
 62 }
 63
 64 double calCalip()
 65 {
 66   //  for(int i=0 ; i<top ; i++) rec[i].output();
 67     Point ch[2];
 68     ch[0] = rec[0] , ch[1] = rec[1];
 69     int i1=0 , i2=0 , i3=0;
 70     double maxn = 1e18;
 71     ch[0] = rec[0] , ch[1] = rec[1];
 72     while(dcmp(fabs((rec[(i1+1)%top]-ch[0])*(ch[1]-ch[0]))-fabs((rec[i1]-ch[0])*(ch[1]-ch[0])))>=0) i1=(i1+1)%top;
 73     while(dcmp(Dot(rec[(i2+1)%top]-ch[0] , ch[1]-ch[0])-Dot(rec[i2]-ch[0] , ch[1]-ch[0]))>=0) i2=(i2+1)%top;
 74     while(dcmp(Dot(rec[(i3-1+top)%top]-ch[1] , ch[0]-ch[1])-Dot(rec[i3]-ch[1] , ch[0]-ch[1]))>=0) i3=(i3-1+top)%top;
 75     for(int i=0 ; i<top ; i++){
 76         ch[0] = rec[i] , ch[1] = rec[(i+1)%top];
 77         while(dcmp(fabs((rec[(i1+1)%top]-ch[0])*(ch[1]-ch[0]))-fabs((rec[i1]-ch[0])*(ch[1]-ch[0])))>=0) i1=(i1+1)%top;
 78         while(dcmp(Dot(rec[(i2+1)%top]-ch[0] , ch[1]-ch[0])-Dot(rec[i2]-ch[0] , ch[1]-ch[0]))>=0) i2=(i2+1)%top;
 79         while(dcmp(Dot(rec[(i3+1)%top]-ch[1] , ch[0]-ch[1])-Dot(rec[i3]-ch[1] , ch[0]-ch[1]))>=0) i3=(i3+1)%top;
 80         double l = Len(ch[1]-ch[0]);
 81         double h = fabs((rec[i1]-ch[0])*(ch[1]-ch[0]))/l;
 82         double len1 = Dot(rec[i2]-ch[1] , ch[1]-ch[0])/l; //右侧长度
 83         double len2 = Dot(rec[i3]-ch[0] , ch[0]-ch[1])/l; //左侧长度
 84         double suml = l+len1+len2;
 85        // cout<<i<<" "<<l<<" "<<h<<" "<<len1<<" "<<len2<<" "<<suml*h<<endl;
 86         if(dcmp(suml*h-maxn)<0){
 87             Vector unit1 = (ch[1]-ch[0])/l;
 88             Vector unit2 = Normal(unit1);
 89             maxn = suml*h;
 90             p[0] = ch[1]+unit1*len1;
 91             p[1] = p[0]+unit2*h;
 92             p[2] = p[1]-unit1*suml;
 93             p[3] = p[2]-unit2*h;
 94         }
 95     }
 96     return maxn;
 97 }
 98
 99 int main()
100 {
101    // freopen("in.txt" , "r" , stdin);
102     while(scanf("%d" , &n)!=EOF)
103     {
104         for(int i=0 ; i<n ; i++) po[i].input();
105         Polxy();
106         double ret = calCalip();
107         printf("%.5f\n" , ret);
108         int st = 0;
109         for(int i=1 ; i<4 ; i++){
110             if(p[i].y<p[st].y || (p[i].y==p[st].y&&p[i].x<p[st].x)) st = i;
111         }
112         for(int i=0;i<4;i++){
113             p[st].output();
114             st = (st+1)%4;
115         }
116     }
117     return 0;
118 }
时间: 2024-10-05 15:05:23

bzoj 1185 旋转卡壳 最小矩形覆盖的相关文章

BZOJ 1185 HNOI 2007 最小矩形覆盖 旋转卡壳

题目大意:给出平面上的一些点,问面积最小的矩形满足覆盖所有的点. 思路:覆盖问题和不是凸包上的点没关系,先做凸包.根据贪心的思想,这个覆盖了所有点的矩形肯定至少有一条边与凸包上的边重合,那么我们枚举凸包上的每一条边,对于这个已经确定了一条边的矩形,不难确定其他三个边.注意到已知当前直线的向量,就可以求出两侧和对面的向量,而这三个向量随着枚举的边的移动是单调的,所以就可以用旋转卡壳来卡住剩下的三条边. 但是旋转卡壳时的初值会出问题,如果按照逆时针的顺序求出剩下的三条边的时候,要想通过向量直接卡第三

HDU 5251 矩形面积(二维凸包旋转卡壳最小矩形覆盖问题) --2015百度之星题目

B - 矩形面积 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description 小度熊有一个桌面,小度熊剪了很多矩形放在桌面上,小度熊想知道能把这些矩形包围起来的面积最小的矩形的面积是多少. Input 第一行一个正整数 T,代表测试数据组数(),接下来 T 组测试数据. 每组测试数据占若干行,第一行一个正整数 ,代表矩形的数量.接下来 N 行,每行 8

BZOJ 1185 HNOI2007 最小矩形覆盖 旋转卡壳

题目大意:最小矩形覆盖 首先有一个结论:凸包上一定有一条边与矩形的一条边重合 证明:如果不存在一条边与矩形的一条边重合,那么我将这个矩形旋转一下一定会比之前更小 于是我们枚举其中一条边,对其余三个点卡壳即可 这旋转卡壳写的真叫一个卡壳- - 还好1A掉了- - #include <cmath> #include <cstdio> #include <cstring> #include <iostream> #include <algorithm>

bzoj1185 [HNOI2007]最小矩形覆盖 旋转卡壳求凸包

[HNOI2007]最小矩形覆盖 Time Limit: 10 Sec  Memory Limit: 162 MBSec  Special JudgeSubmit: 2081  Solved: 920[Submit][Status][Discuss] Description 给定一些点的坐标,要求求能够覆盖所有点的最小面积的矩形, 输出所求矩形的面积和四个顶点坐标 Input 第一行为一个整数n(3<=n<=50000) 从第2至第n+1行每行有两个浮点数,表示一个顶点的x和y坐标,不用科学计

1185: [HNOI2007]最小矩形覆盖

1185: [HNOI2007]最小矩形覆盖 Time Limit: 10 Sec  Memory Limit: 162 MBSec  Special JudgeSubmit: 1426  Solved: 648[Submit][Status][Discuss] Description Input Output Sample Input Sample Output HINT Source 计算几何 vfleaking提供Spj #include<cstdio> #include<cmat

bzoj1185【HNOI2007】最小矩形覆盖

1185: [HNOI2007]最小矩形覆盖 Time Limit: 10 Sec  Memory Limit: 162 MBSec  Special Judge Submit: 1114  Solved: 505 [Submit][Status][Discuss] Description 凸包+旋转卡壳 首先有一个结论:矩形一定有一条边在凸包上,否则我们旋转之后一定会得到一个更小的矩形,脑补一下. 然后枚举凸包上的边,用旋转卡壳维护矩形的另外三条边,同时更新答案即可. #include<ios

【bzoj_1185】[HNOI2007]最小矩形覆盖

咳咳..这会来总结一下1185的解题思路(这么一道破题调了一整天我会乱说? 首先做凸包,这个谁都知道我就不说了 然后问题转化为了凸多边形的最小矩形覆盖 有一个结论是 一个凸包的最小矩形覆盖一定有矩形的一条边在凸包上 请注意是结论..不是猜想.这个结论的正确性嘛..wys神犇给出的解释是这样的 好吧.. 然后我们可以以逆时针的顺序枚举每条边,作为矩形的一条边所在的直线.显然,矩形与这条边平行的边一定过这条边的对踵点.这一步骤旋转卡壳就可以在均摊O(1)的时间下完成. 然后问题来了,如何在快速找到最

BZOJ 1185 [HNOI2007]最小矩形覆盖:凸包 + 旋转卡壳

题目链接:https://www.lydsy.com/JudgeOnline/problem.php?id=1185 题意: 给出二维平面上的n个点,问你将所有点覆盖的最小矩形面积. 题解: 先找出凸包,然后旋转卡壳. 在旋转卡壳中有一个结论:最小覆盖矩形一定有一条边在凸包上. 所以先枚举矩形在凸包上的那条边(p[i],p[i+1]),然后利用单调性找出p[i]的对踵点p[u]. 至于左右两侧的切点p[l]和p[r],要利用它们连线在直线(p[i],p[i+1])上投影长度的单调性求出. 最后将

BZOJ1185: [HNOI2007]最小矩形覆盖

传送门 旋转卡壳. 首先求凸包没什么好商量的. 然后有一个结论,如果存在一个最小的矩形覆盖,那么凸包里必定存在一条边和矩形的边重合. 自己yy一下就好啦,很容易想明白. 然后枚举每条边,移动另外三条边即可. 注意点积,叉积的结合运用什么的. //BZOJ 1185 //by Cydiater //2017.1.29 #include <iostream> #include <map> #include <ctime> #include <cmath> #in