2015baidu复赛 矩形面积（包凸 && ps:附quickhull模板）

矩形面积

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 168    Accepted Submission(s): 93

Problem Description

小度熊有一个桌面，小度熊剪了很多矩形放在桌面上，小度熊想知道能把这些矩形包围起来的面积最小的矩形的面积是多少。

 

Input

第一行一个正整数 T，代表测试数据组数(1≤T≤20)，接下来 T 组测试数据。

每组测试数据占若干行，第一行一个正整数 N(1≤N<≤1000)，代表矩形的数量。接下来 N 行，每行 8 个整数x1,y1,x2,y2,x3,y3,x4,y4，代表矩形的四个点坐标，坐标绝对值不会超过10000。

 

Output

对于每组测试数据，输出两行：

第一行输出"Case #i:"，i 代表第 i 组测试数据。
第二行包含1 个数字，代表面积最小的矩形的面积，结果保留到整数位。

 

Sample Input

2
2
5 10 5 8 3 10 3 8
8 8 8 6 7 8 7 6
1
0 0 2 2 2 0 0 2

 

Sample Output

Case #1:
17
Case #2:
4

 

Source

2015年百度之星程序设计大赛 - 初赛(1)

 #include<stdio.h>
 #include<set>
 #include<algorithm>
 #include<string.h>
 #define one first
 #define two second
 #define zero 1e-12
 #define sgn(x) (fabs(x)<zero?0:(x>0?1:-1))
 #define shadow(a,b,c)  ((b.one-a.one)*(c.one-a.one)+(b.two-a.two)*(c.two-a.two))/sqrt((b.one-a.one)*(b.one-a.one)+(b.two-a.two)*(b.two-a.two))
 #define cross(a,b,c) ((b.one-a.one)*(c.two-a.two)-(b.two-a.two)*(c.one-a.one))
 #define cmp(a,b) (a.one<b.one || sgn(a.one-b.one)==0 && a.two<b.two)
 const int M =  , inf = 0x3f3f3f3f ;
 int n ;
 std::pair<double , double > p[M] ;
 double s[M];
 std::pair<double , double > jk[M] ;
 int tot ;

 void hull(int l,int r, std::pair<double , double>a,std::pair<double , double> b){
     int x=l,i=l-,j=r+,k;
     for (k=l;k<=r;k++){
         double temp=sgn(s[x]-s[k]);
         if (temp< || temp== && cmp(p[x],p[k])) x=k;
     }
     std::pair<double , double> y=p[x];
     for (k=l;k<=r;k++){
         s[++i]=cross(p[k],a,y);
         if (sgn(s[i])>) std::swap(p[i],p[k]); else i--;
     }
     for (k=r;k>=l;k--){
         s[--j]=cross(p[k],y,b);
         if (sgn(s[j])>) std::swap(p[j],p[k]); else j++;
     }
     if (l<=i) hull(l,i,a,y);
     jk[tot ++] = y ;
     if (j<=r) hull(j,r,y,b);
 }

 void solve ()
 {
     double l , r , h , sum = inf ;
     double d =  ;
     for (int i =  ; i <= tot ; i ++) {
         d = (jk[i].one - jk[i - ].one) * (jk[i].one - jk[i - ].one) + (jk[i].two - jk[i - ].two) * (jk[i].two - jk[i - ].two) ;
         l =  , r = sqrt (d) ;
         h =  ;
         for (int j =  ; j <= n ; j ++) {
             if (p[j] != jk[i] && p[j] != jk[i - ]) {
                 h = std::max (h , fabs (cross (jk[i] , jk[i - ] , p[j])) / sqrt(d)) ;
                 l = std::min (l , shadow (jk[i] , jk[i - ] , p[j])) ;
                 r = std::max (r , shadow (jk[i] , jk[i - ] , p[j])) ;
             }
         }
         sum = std::min (sum , (r - l) * h) ;
     }
     printf ("%.0f\n" , sum) ;
 }

 int main(){
    //freopen ("a.txt" , "r" , stdin) ;
    int T , cas =  ;
    scanf ("%d" , &T) ;
    while (T --) {
         printf ("Case #%d:\n" , cas ++) ;
         memset (s ,  , sizeof(s)) ;
         int i , x= ;
         tot =  ;
         scanf("%d",&n);
         n *=  ;
         for (i=;i<=n;i++){
             scanf("%lf%lf",&p[i].one,&p[i].two);
             if (x== || cmp(p[i],p[x])) x=i;
         }
         std::swap(p[],p[x]);
         jk[tot ++] = p[] ;
         hull(,n,p[],p[]);
         jk[tot] = jk[] ;
         solve () ;
     }
     return ;
 }

用这种做法，首先要明白最小的覆盖矩形的其中一边必定是和壳重合。

所以我们只要求出壳，并枚举壳上的每条边，并计算出在它上生成的最小矩阵面积。然后找出其中最小的就好了。

复杂度((4*n)^2);

 #include<bits/stdc++.h>
 #define one first
 #define two second
 #define eps 1e-12
 #define sgn(x) (x<eps?0:(x>0?1:-1))
 #define cross(a,b,c) ((b.one-a.one)*(c.two-a.two)-(b.two-a.two)*(c.one-a.one))
 #define cmp(a,b) (a.one<b.one || sgn(a.one-b.one)==0 && a.two<b.two)
 const int M = 1e5 , inf = 0x3f3f3f3f ;
 int n ;
 std::pair<double , double> p [M] ;
 int s[M] ;
 std::pair<double , double> jk[M] ;
 int tot =  ;

 void hull (int l , int r , std::pair<double , double> a , std::pair<double , double> b)
 {
     //printf ("(%d , %d)\n" , l , r ) ;
     int x = l , _l = l -  , _r = r +  ;
     for (int i = l ; i <= r ; i ++) {
         int tmp = sgn(s[i]-s[x]) ;
         if (tmp >  || tmp ==  && cmp(p[x],p[i])) x = i ;
     }
     for (int i = l ; i <= r ; i ++) {
         s[++ _l] = cross(p[i],a,p[x]) ;
         if (sgn(s[_l]) > ) std::swap (p[i] , p[_l]) ; else _l -- ;
     }
     for (int i = r ; i >= l ; i --) {
         s[-- _r] = cross(p[i],p[x],b) ;
         if (sgn(s[_r]) > ) std::swap (p[i] , p[_r]) ; else _r ++ ;
     }
     if (l <= _l)hull (l , _l , a , p[x]) ;
     jk[tot ++] = p[x] ;
     if (_r <= r)hull (_r , r , p[x] , b) ;
 }

 int main ()
 {
    // freopen ("a.txt" , "r" , stdin ) ;
     memset (s ,  , sizeof(s)) ;
     scanf ("%d" , &n) ; //printf ("n = %d\n" , n ) ;
     int x = - ;
     for (int i =  ; i <= n ; i ++) {
         scanf ("%lf%lf" , &p[i].one , &p[i].two) ;
         if (x == - || cmp (p[i] , p[x])) x = i ;
     }
     std::swap (p[x] , p[]) ;
     jk[tot ++] = p[] ;
     hull ( , n , p[] , p[]) ;
     for (int i =  ; i < tot ; i ++) printf ("(%.4f , %.4f)\n" , jk[i].one , jk[i].two) ;
     return  ;
 }

92_quickhull

要了解这个算法的思路，先去维基上看看动态演示http://en.wikipedia.org/wiki/Quickhull

然后你需要知道叉积(叉积 "X" 表示)：已知两个向量 a = (x1 , y1) , b = (x2 , y2);

叉积：a X b = x1 * y2 - x2 * y1 ;

点积：a * b = x1 * x2 + y1 * y2 ;

两个向量间的的夹角：a * b = |a| * |b| * cosθ ;

那么这两个向量 构成的三角形面积 S = 1/2 * abs (a X b) ，

还有　a X b = - b X a ;

知道以上这两个概念，就看的动quickhull了。

就这道题而言，你还需要知道，  a 在 b 上的投影求法：a * b / | b | ;