zoj 2107寻找最近点对。

计算几何的题很少做，感觉太难了。。

不过这个分治感觉用处很多，所以就看了下，，，昨天晚上就写好了代码，只不过在hdu一直tle上， 直到刚刚，在zoj上过了，在hdu的还是tle。。

对hdu很是失望，同是oj，差别怎么这样大呢。。。

要不是发现zoj上也有相同的题目，不知道还要调试多长时间。。

不过应该还有某个地方出问题了，要不然也不可能在hdu上一直不过。

看出来的，给留个言，当万分感激。。

题目的意思就是寻找最近点对，然后输出最近点对距离的一半！

  
    

   
     # include
   
     <
   
     stdio.h
   
     >
   
     
# include
   
     <
   
     math.h
   
     >
   
     
#include
   
     <
   
     stdlib.h
   
     >
   
     

   
     #define
   
      PI 0xfffffff
   
     
typedef 
   
     struct
   
      node{
 
   
     double
   
      x,y;
}Point;
Point v[
   
     100005
   
     ],X[
   
     100005
   
     ];

   
     int
   
      n;

   
     int
   
      cmp(
   
     const
   
      
   
     void
   
      
   
     *
   
     a,
   
     const
   
      
   
     void
   
      
   
     *
   
     b)
{
 
   
     return
   
      ((Point 
   
     *
   
     )a)
   
     ->
   
     x 
   
     >
   
      ((Point 
   
     *
   
     )b)
   
     ->
   
     x 
   
     ?
   
      
   
     1
   
      : 
   
     -
   
     1
   
     ;
}

   
     int
   
      cm(
   
     const
   
      
   
     void
   
      
   
     *
   
     a,
   
     const
   
      
   
     void
   
      
   
     *
   
     b)
{
 
   
     return
   
      ((Point 
   
     *
   
     )a)
   
     ->
   
     y 
   
     >
   
      ((Point 
   
     *
   
     )b)
   
     ->
   
     y 
   
     ?
   
      
   
     1
   
      : 
   
     -
   
     1
   
     ;
}

   
     double
   
      dist(Point s1, Point s2)
{
 
   
     return
   
      sqrt((s1.x 
   
     -
   
      s2.x)
   
     *
   
     (s1.x 
   
     -
   
      s2.x) 
   
     +
   
      (s1.y 
   
     -
   
      s2.y)
   
     *
   
     (s1.y 
   
     -
   
      s2.y));
}

   
     double
   
      min(
   
     double
   
      a,
   
     double
   
      b)
{
 
   
     return
   
      a 
   
     >
   
      b 
   
     ?
   
      b : a;
}

   
     int
   
      min1(
   
     int
   
      a,
   
     int
   
      b)
{
 
   
     return
   
      a 
   
     >
   
      b 
   
     ?
   
      b : a;
}

   
     double
   
      Find_min(
   
     int
   
      i,
   
     int
   
      j)
{
 
   
     int
   
      t,k,h;
 
   
     double
   
      xx,delta;
 
   
     if
   
     (j
   
     -
   
     i
   
     ==
   
     1
   
     ) 
   
     return
   
      dist(X[j],X[i]);
 
   
     else
   
      
   
     if
   
     (j
   
     -
   
     i
   
     ==
   
     2
   
     )
 {
 delta
   
     =
   
     PI;
 xx
   
     =
   
     dist(X[i],X[i
   
     +
   
     1
   
     ]);
 
   
     if
   
     (xx
   
     <
   
     delta)
 {
 delta
   
     =
   
     xx;
 }
 xx
   
     =
   
     dist(X[i],X[j]);
 
   
     if
   
     (xx
   
     <
   
     delta)
 {
 delta
   
     =
   
     xx;
 }
 xx
   
     =
   
     dist(X[i
   
     +
   
     1
   
     ],X[j]);
 
   
     if
   
     (xx
   
     <
   
     delta)
 {
 delta
   
     =
   
     xx;
 }
 
   
     return
   
      delta;
 }
 k
   
     =
   
     (i
   
     +
   
     j)
   
     /
   
     2
   
     ;
 delta
   
     =
   
     min(Find_min(i,k),Find_min(k
   
     +
   
     1
   
     ,j));
 t
   
     =
   
     0
   
     ;
 
   
     for
   
     (h
   
     =
   
     k;h
   
     >=
   
     i;h
   
     --
   
     )
 {
 
   
     if
   
     (X[k
   
     +
   
     1
   
     ].x 
   
     -
   
      X[h].x 
   
     <
   
      delta )
 {
 t
   
     ++
   
     ;
 v[t]
   
     =
   
     X[h];
 }
 
   
     else
   
      
   
     break
   
     ;
 }
 
   
     for
   
     (h
   
     =
   
     k
   
     +
   
     1
   
     ;h
   
     <=
   
     j;h
   
     ++
   
     )
 {
 
   
     if
   
     (X[h].x 
   
     -
   
      X[k].x 
   
     <
   
      delta)
 {
 t
   
     ++
   
     ;
 v[t]
   
     =
   
     X[h];
 }
 
   
     else
   
      
   
     break
   
     ;
 }
 qsort(v
   
     +
   
     1
   
     ,t,
   
     sizeof
   
     (v[
   
     1
   
     ]),cm);
 
   
     for
   
     (k
   
     =
   
     1
   
     ;k
   
     <
   
     t;k
   
     ++
   
     )
 {
 
   
     for
   
     (h
   
     =
   
     k
   
     +
   
     1
   
     ;h
   
     <=
   
     min1(t,k
   
     +
   
     6
   
     );h
   
     ++
   
     )
 {
 
   
     if
   
     (v[h].y 
   
     -
   
      v[k].y 
   
     >
   
      delta) 
   
     break
   
     ;
 xx
   
     =
   
     dist(v[k],v[h]);
 
   
     if
   
     (xx
   
     <
   
     delta)
 {
 delta
   
     =
   
     xx;
 }
 }
 }
 
   
     return
   
      delta;
}

   
     double
   
      closepoint()
{
 
   
     if
   
     (n
   
     ==
   
     1
   
     ) 
   
     return
   
      
   
     0
   
     ;
 qsort(X
   
     +
   
     1
   
     ,n,
   
     sizeof
   
     (X[
   
     1
   
     ]),cmp);
 
   
     return
   
      Find_min(
   
     1
   
     ,n);
}

   
     int
   
      main()
{
 
   
     int
   
      i;
 
   
     double
   
      ans;
 
   
     while
   
     (scanf(
   
     "
   
     %d
   
     "
   
     ,
   
     &
   
     n)
   
     !=
   
     EOF)
 {
 
   
     if
   
     (n
   
     ==
   
     0
   
     ) 
   
     break
   
     ;
 
   
     for
   
     (i
   
     =
   
     1
   
     ;i
   
     <=
   
     n;i
   
     ++
   
     )
 scanf(
   
     "
   
     %lf%lf
   
     "
   
     ,
   
     &
   
     X[i].x,
   
     &
   
     X[i].y);
 ans
   
     =
   
     closepoint();
 printf(
   
     "
   
     %.2lf\n
   
     "
   
     ,ans
   
     /
   
     2
   
     );
 }
 
   
     return
   
      
   
     0
   
     ;
}
  
    

本来程序还可以求出最近的两个点，不过在hdu上tle了那么多次，让我没信心保证它是对的了，所以就给delete了。。