1.

/* Problem : 10245
 * Author : Peter Schnitzler
 * Sprache : Java
 * Status : AC
 * Zeit : 1,176
 */

import java.text.DecimalFormat;
import java.util.Scanner;


public class Main
{
   
    //beschreibt einen punkt im 2 Dim. Raum.
    double x, y;
       
    public Main(double a, double b)
    {
        x = a;
        y = b;
    }
   

    public static void main(String[] args)
    {
        //fuer die Output formatierung
        DecimalFormat df = new DecimalFormat();
        df.applyPattern( "0.0000" );
       
       
        Scanner scan = new Scanner(System.in);
        int p = scan.nextInt();
        // p = Anzahl der Punkte pro testfall
       
        while (p != 0)
        {
            // Array der Punket.
            //dataX wird nach der X koordinaten Sortiert
            Main dataX[] = new Main[p];
           
            //einlesen der Punkte
            for (int count = 0; count < p; count++)
            {
                Main temp = new Main(Double.parseDouble(scan.next()), Double.parseDouble(scan.next()));
               
                dataX[count] = temp;
            }
           
           
            sortX(dataX, 0, p-1);
           
           
            boolean infini = true; //wurde noch kein abstand unter 10000 gefunden
            double minDisTotal = 100000000; //der kürzeste sofern gefunden abstand
           
           
            /* Hier wird die kürzeste Verbindung gesucht. Weil die Punkte nach ihrer
             * Position an der X achse sortiert sind, sind die Punkte die einem Punkt
             * im Array folgen tendeziel sehr nah. Ausserdem liefert die Sortierung
             * ein Abruchkriterium für die innere Schleife. Sobald nähmlich ein Punktepaar
             * gefunden wird, dessen Abstand entlang der X Koordinate grösser ist als
             * der kleinste bisher gefunde Abstand, ist sicher das dieses Punktepaar und
             * alle weiteren in der inneren Schleife gefunden paare nicht das kürzeste
             * Paar ist.
             */
            for (int count = 0; count < p; count++)
            {
                for (int run = count + 1; run < p; run++)
                {
                    double temp = dataX[run].x - dataX[count].x;
                    temp = temp * temp;
                   
                    if (temp > minDisTotal)
                    {
                        break;
                    }
                    //else
                   
                    double temp2 = dataX[run].y - dataX[count].y;
                   
                    double cage = temp + temp2 * temp2;
                   
                    if (cage < minDisTotal)
                    {
                        minDisTotal = cage;
                        infini = false;
                    }
                }
            }

           
            //output
            if (infini)
            {
                System.out.println("INFINITY");
            }
            else
            {
                System.out.println(df.format(Math.sqrt(minDisTotal)));
            }
           
           
            p = scan.nextInt();
        }

    }


  //sortiert die Punkte nach ihrer X coordinate mittels Quicksort
    private static void sortX(Main[] dataX, int min, int max)
    {
        if (max > min)
        {
            double pivot = dataX[min].x;
       
            int cutOff = min;
       
            for (int count = min + 1; count <= max; count ++)
            {
                double temp = dataX[count].x;
           
                if (temp <= pivot)
                {
                    cutOff++;
                    Main cage = dataX[count];
                    dataX[count] = dataX[cutOff];
                    dataX[cutOff] = cage;
                }
            }
           
            Main cage = dataX[min];
            dataX[min] = dataX[cutOff];
            dataX[cutOff] = cage;
           
           
            sortX(dataX, min, cutOff - 1);
            sortX(dataX, cutOff + 1, max);
        }
    }

}


2.


/* Problem : 10245
 * Author : Evgeni Pavlidis
 * Sprache : Java
            25.09.2009
 * Status : AC
 * Zeit : 0.400
 */

/*
Also der Fehler liegt darin, dass nicht alle relevanten Punkte miteinander verglichen werden. 
Die Puntkemenge wird nach der X-Achse sortiert in zwei Mengen geteilt und dadurch 2 Ergebnisse miteinander verglichen.
Somit werden viele Paare nicht mit einbezogen.
Ansonsten ist das Program schnell und wenn man die Idee vom Peter nimmt wird es sogar fuer 0.500 s akzeptiert.
*/

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.StringTokenizer;
import java.util.Arrays;

public class Main {

    public static void main(String...strings ) throws NumberFormatException, IOException{
       
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(new BufferedOutputStream(System.out));
       
        StringTokenizer token;
        int number = Integer.parseInt(reader.readLine());
        double[][] coordinatesX, coordinatesY;
        int i, j;
        double mindistXl, mindistXr, tmp, mindist;
        DecimalFormat df = new DecimalFormat();
        df.applyPattern( "0.0000" );
        while(number != 0){
            coordinatesX = new double[number][2];
           
            //coordinatesY = new double[number][2];
           
            // Einlesen
            for(i = 0; i < number; i++){
                token = new StringTokenizer(reader.readLine());
                coordinatesX[i][0] = Double.parseDouble(token.nextToken());
                coordinatesX[i][1] = Double.parseDouble(token.nextToken());
                //coordinatesY[i][0] = coordinatesX[i][0];
                //coordinatesY[i][1] = coordinatesX[i][1];
            }
            if(number > 3){
           
                // Koordinaten nach dem X-Wert sortieren
                sort(coordinatesX, 0, number-1);
               
                //sortY(coordinatesY, 0, number-1);
               
                mindistXl = mindistXr = 100000000;
                double test;
                // Minimale Distanz der linken Seite finden
                for(i = 0; i < number; i++)
                    for(j = i+1; j < number; j++){
                        test = coordinatesX[i][0] - coordinatesX[j][0];
                        test = test*test;
                        if(test > mindistXl)
                            break;

                        tmp = (Math.pow(coordinatesX[j][1]-coordinatesX[i][1], 2) + test);
                        if(tmp < mindistXl){
                            mindistXl = tmp;
                        }
                    }
               
                           
                // Minimale Distanz, aus den linken und rechten Werten
                mindist = mindistXl;            
               
/*                for(i = (number/2)-1; i < 0; i--)
                    for(j = number/2; j < number; j++){
                        tmp = (Math.pow(coordinatesX[j][1]-coordinatesX[i][1], 2) + Math.pow(coordinatesX[j][0]-coordinatesX[i][0], 2));
                        if(mindist < tmp)break;
                        if(tmp < mindist && tmp > 0){
                            mindist = tmp;
                        }
                    }
               
                for(i = (number/2)-1; i < 0; i--)
                    for(j = number/2; j < number; j++){
                        tmp = (Math.pow(coordinatesY[j][1]-coordinatesY[i][1], 2) + Math.pow(coordinatesY[j][0]-coordinatesY[i][0], 2));
                        if(mindist < tmp)break;
                        if(tmp < mindistY){
                            mindist = tmp;
                        }
                    }*/
            }
            else{
                // Closest Pair mit Brute-force finden
                mindist = 100000000;
                for(i = 0; i < number; i++)
                    for(j = i+1; j < number; j++){
                        tmp = (Math.pow(coordinatesX[j][1]-coordinatesX[i][1], 2) + Math.pow(coordinatesX[j][0]-coordinatesX[i][0], 2));
                        if(tmp < mindist){
                            mindist = tmp;
                        }
                    }
            }
           
            writer.println(mindist < 100000000 ? df.format(Math.sqrt(mindist)) : "INFINITY");
           
            number = Integer.parseInt(reader.readLine());
        }
        writer.flush();
    }
   
    public static void sort(double[][] a, int start, int end) {
        double[] tmp;
        int i = start;
        int j = end;
        double x = a[(start + end) / 2][0];

        do {
            // Vom Startpunkt aus einen Wert suchen der >= x ist
            while (a[i][0] < x) {
                i++;
            }
            // Vom Endpunkt aus einen Wert suchen der <= x ist
            while (a[j][0] > x) {
                j--;
            }

            // a[i] und a[j] tauschen
            if (i <= j) {
                tmp = a[i];
                a[i] = a[j];
                a[j] = tmp;
                i++;
                j--;
            }
        } while (i <= j);

        if (start < j) {
            sort(a, start, j);
        }

        if (i < end) {
            sort(a, i, end);
        }
    }
}