1. #include<iostream> 
    2.  
         
  2. #include<algorithm> 
    3.  
         
  3. #include<cmath> 
    4.  
         
  4. using namespace std; 
    5.  
         
  5.  
    6.  
         
  6. static const int MAXNUM = 100000; 
    7.  
         
  7.  
    8.  
         
  8. struct Point{ 
    9.  
         
  9.     double x,y; 
    10.  
         
  10. }arrP[MAXNUM],arrX[MAXNUM],arrY[MAXNUM]; 
    11.  
         
  11.  
    12.  
         
  12. bool CompX(Point a, Point b) 
    13.  
         
  13. { 
    14.  
         
  14.     if(a.x == b.x) 
    15.  
         
  15.         return a.y < b.y; 
    16.  
         
  16.     return a.x < b.x; 
    17.  
         
  17. } 
    18.  
         
  18.  
    19.  
         
  19. bool CompY(Point a, Point b) 
    20.  
         
  20. { 
    21.  
         
  21.     if(a.y == b.y) 
    22.  
         
  22.         return a.x < b.x; 
    23.  
         
  23.     return a.y < b.y; 
    24.  
         
  24. } 
    25.  
         
  25.  
    26.  
         
  26. double GetDistance(Point a, Point b) 
    27.  
         
  27. { 
    28.  
         
  28.     return sqrt(pow(a.x - b.x, 2.0) + pow(a.y - b.y,2.0)); 
    29.  
         
  29. } 
    30.  
         
  30.  
    31.  
         
  31. double MinDistance(double a, double b) 
    32.  
         
  32. { 
    33.  
         
  33.     return a<=b? a: b; 
    34.  
         
  34. } 
    35.  
         
  35.  
    36.  
         
  36. double GetMinDistabce(int l, int r) 
    37.  
         
  37. { 
    38.  
         
  38.     if(l == r) 
    39.  
         
  39.         return 0; 
    40.  
         
  40.     else if(l+1 == r) 
    41.  
         
  41.         return GetDistance(arrP[l], arrP[r]); 
    42.  
         
  42.     else if(l+2 == r){ 
    43.  
         
  43.         double tmp1 = GetDistance(arrP[l],arrP[l+1]); 
    44.  
         
  44.         double tmp2 = GetDistance(arrP[l],arrP[r]); 
    45.  
         
  45.         double tmp3 = GetDistance(arrP[l+1],arrP[r]); 
    46.  
         
  46.         return MinDistance(MinDistance(tmp1,tmp2),tmp3); 
    47.  
         
  47.     } 
    48.  
         
  48.  
    49.  
         
  49.  
    50.  
         
  50.     int middle=(l+r)/2,j=0,k=0; 
    51.  
         
  51.  
    52.  
         
  52.     double minDistance = MinDistance(GetMinDistabce(l,middle),GetMinDistabce(middle+1,r)); 
    53.  
         
  53.     for(int i=l;i<=r;i++){ 
    54.  
         
  54.         if(fabs(arrP[i].x - arrP[middle].x) < minDistance) 
    55.  
         
  55.             arrX[j++] = arrP[i];//arrX[]存储的是x坐标距离小于当前最小距离的点 
    56.  
         
  56.     } 
    57.  
         
  57.     sort(arrX,arrX+j,CompY); 
    58.  
         
  58.     middle = (j+1)/2; 
    59.  
         
  59.     for(int i = 0;i < j; i++){ 
    60.  
         
  60.         if(fabs(arrX[i].y - arrX[middle].y) < minDistance) 
    61.  
         
  61.             arrY[k++]=arrX[i];//arrY[]存储的是x坐标距离小于当前最小距离的点，且Y坐标距离也小于当前最小点的点 
    62.  
         
  62.     } 
    63.  
         
  63.     for(int i=0; i<k; i++){ 
          //遍历arrY数组，两两计算点之间距离 
    64.  
         
  64.         for(int j=i+1; j<k; j++){ 
    65.  
         
  65.             double tmpDistance = GetDistance(arrY[i],arrY[j]); 
    66.  
         
  66.             if(tmpDistance < minDistance) 
    67.  
         
  67.                 minDistance = tmpDistance; 
    68.  
         
  68.         } 
    69.  
         
  69.     } 
    70.  
         
  70.     return minDistance; 
    71.  
         
  71. } 
    72.  
         
  72.  
    73.  
         
  73. int main() 
    74.  
         
  74. { 
    75.  
         
  75.     int n; 
    76.  
         
  76.     while(cin>>n && n!=0){ 
    77.  
         
  77.         //Point p; 
    78.  
         
  78.         double minDistance; 
    79.  
         
  79.         for(int i=0; i<n; i++){ 
    80.  
         
  80.             cin >> arrP[i].x >> arrP[i].y; 
    81.  
         
  81.         } 
    82.  
         
  82.         sort(arrP,arrP+n,CompX); 
    83.  
         
  83.         minDistance = GetMinDistabce(0,n-1); 
    84.  
         
  84.         cout.precision(2); 
    85.  
         
  85.         cout << fixed << minDistance/2<<endl; 
    86.  
         
  86.     } 
    87.  
         
  87.     return 0; 
    88.  
         
  88. } 
    89.