二维下计算几何程序头 （模板）

  
    

   
     
   
     #include
   
     <
   
     iostream
   
     >
   
     
#include
   
     <
   
     cmath
   
     >
   
     

   
     using
   
      
   
     namespace
   
      std;

   
     const
   
      
   
     double
   
      epoints 
   
     =
   
      1e
   
     -
   
     9
   
     ;

   
     int
   
      sgn(
   
     double
   
      a) {
 
   
     return
   
      (a 
   
     >
   
      epoints) 
   
     -
   
      (a 
   
     <
   
      
   
     -
   
     epoints);
}

   
     const
   
      
   
     double
   
      pointi 
   
     =
   
      acos(
   
     -
   
     1.0
   
     );

   
     struct
   
      point{
 
   
     double
   
      x, y;
 point(
   
     double
   
      xx
   
     =
   
     0
   
     , 
   
     double
   
      yy
   
     =
   
     0
   
     ){
 x
   
     =
   
     xx; y
   
     =
   
     yy;
 }
 
   
     bool
   
      
   
     operator
   
      
   
     ==
   
      (
   
     const
   
      point 
   
     &
   
     a) 
   
     const
   
      {
 
   
     return
   
      sgn(x 
   
     -
   
      a.x) 
   
     ==
   
      
   
     0
   
      
   
     &&
   
      sgn(y 
   
     -
   
      a.y) 
   
     ==
   
      
   
     0
   
     ;
 }
 
   
     bool
   
      
   
     operator
   
      
   
     !=
   
      (
   
     const
   
      point 
   
     &
   
     a) 
   
     const
   
      {
 
   
     return
   
      sgn(x 
   
     -
   
      a.x) 
   
     !=
   
      
   
     0
   
      
   
     ||
   
      sgn(y 
   
     -
   
      a.y) 
   
     !=
   
      
   
     0
   
     ;
 }
 
   
     bool
   
      
   
     operator
   
      
   
     <
   
      (
   
     const
   
      point 
   
     &
   
     a) 
   
     const
   
      {
 
   
     return
   
      sgn(y 
   
     -
   
      a.y) 
   
     <
   
      
   
     0
   
      
   
     ||
   
      sgn(y 
   
     -
   
      a.y) 
   
     ==
   
      
   
     0
   
      
   
     &&
   
      sgn(x 
   
     -
   
      a.x) 
   
     <
   
      
   
     0
   
     ;
 }

 point 
   
     operator
   
      
   
     +
   
      (
   
     const
   
      point 
   
     &
   
     a) 
   
     const
   
      {
 
   
     return
   
      point(x 
   
     +
   
      a.x, y 
   
     +
   
      a.y);
 }
 point 
   
     operator
   
      
   
     -
   
      (
   
     const
   
      point 
   
     &
   
     a) 
   
     const
   
      {
 
   
     return
   
      point(x 
   
     -
   
      a.x, y 
   
     -
   
      a.y);
 }
 point 
   
     operator
   
      
   
     ^
   
      (
   
     const
   
      
   
     double
   
      
   
     &
   
     a) 
   
     const
   
      {
 
   
     return
   
      point(x 
   
     *
   
      a, y 
   
     *
   
      a);
 }
 
   
     double
   
      
   
     operator
   
      
   
     ^
   
      (
   
     const
   
      point 
   
     &
   
     a) 
   
     const
   
      { 
   
     //
   
     点积
   
     

   
      
   
     return
   
      x 
   
     *
   
      a.x 
   
     +
   
      y 
   
     *
   
      a.y;
 }
 
   
     double
   
      
   
     operator
   
      
   
     *
   
      (
   
     const
   
      point 
   
     &
   
     a) 
   
     const
   
      { 
   
     //
   
     叉积
   
     

   
      
   
     return
   
      x 
   
     *
   
      a.y 
   
     -
   
      y 
   
     *
   
      a.x;
 }

 point trunlen(
   
     double
   
      a) 
   
     const
   
      {
 a 
   
     /=
   
      sqrt(x 
   
     *
   
      x 
   
     +
   
      y 
   
     *
   
      y);
 
   
     return
   
      point(x 
   
     *
   
      a, y 
   
     *
   
      a);
 }
 point turn_left() 
   
     const
   
      {
 
   
     return
   
      point(
   
     -
   
     y, x);
 }
 point turn_right() 
   
     const
   
      {
 
   
     return
   
      point(y, 
   
     -
   
     x);
 }
 
   
     double
   
      cross(
   
     const
   
      point 
   
     &
   
     a, 
   
     const
   
      point 
   
     &
   
     b) 
   
     const
   
      { 
   
     //
   
     以this为起点两向量叉积
   
     

   
      
   
     return
   
      (a.x 
   
     -
   
      x) 
   
     *
   
      (b.y 
   
     -
   
      y) 
   
     -
   
      (a.y 
   
     -
   
      y) 
   
     *
   
      (b.x 
   
     -
   
      x);
 }
 
   
     double
   
      dot(
   
     const
   
      point 
   
     &
   
     a, 
   
     const
   
      point 
   
     &
   
     b) 
   
     const
   
      { 
   
     //
   
     以this为起点两向量点积
   
     

   
      
   
     return
   
      (a.x 
   
     -
   
      x) 
   
     *
   
      (b.x 
   
     -
   
      x) 
   
     +
   
      (a.y 
   
     -
   
      y) 
   
     *
   
      (b.y 
   
     -
   
      y);
 }
 
 
   
     double
   
      len2(){
 
   
     return
   
      x 
   
     *
   
      x 
   
     +
   
      y 
   
     *
   
      y;
 }
 
   
     double
   
      len()
 {
 
   
     return
   
      sqrt (len2());
 }

 
   
     void
   
      input() {
 scanf(
   
     "
   
     %lf %lf
   
     "
   
     , 
   
     &
   
     x, 
   
     &
   
     y);
 }
 
   
     void
   
      output() 
   
     const
   
      {
 printf(
   
     "
   
     %lf %lf\n
   
     "
   
     , x, y);
 }
};

   
     int
   
      main()
{
 
   
     return
   
      
   
     0
   
     ;
}
  
    

 

 

参考ACM武汉大学wiki之算法介绍