Problem:
Problem A: Lost in Space

William Robinson was completely puzzled in the music room; he could not find his triangle in
his bag. He was sure that he had prepared it the night before. He remembered its clank when
he had stepped on the school bus early that morning. No, not in his dream. His triangle was
quite unique: no two sides had the same length, which made his favorite peculiar jingle. He
insisted to the music teacher, Mr. Smith, that his triangle had probably been stolen by those
aliens and thrown away into deep space.

Your mission is to help Will find his triangle in space. His triangle has been made invisible by the
aliens, but candidate positions of its vertices are somehow known. You have to tell which three
of them make his triangle. Having gone through worm-holes, the triangle may have changed its
size. However, even in that case, all the sides are known to be enlarged or shrunk equally, that
is, the transformed triangle is similar to the original.

Input

The very first line of the input has an integer which is the number of data sets. Each data set
gives data for one incident such as that of Will’s. At least one and at most ten data sets are
given.

The first line of each data set contains three decimals that give lengths of the sides of the original
triangle, measured in centimeters. Three vertices of the original triangle are named P, Q, and
R. Three decimals given in the first line correspond to the lengths of sides QR, RP, and PQ, in
this order. They are separated by one or more space characters.

The second line of a data set has an integer which is the number of points in space to be
considered as candidates for vertices. At least three and at most thirty points are considered.

The rest of the data set are lines containing coordinates of candidate points, in light years. Each
line has three decimals, corresponding to x, y, and z coordinates, separated by one or more space
characters. Points are numbered in the order of their appearances, starting from one.

Among all the triangles formed by three of the given points, only one of them is similar to the
original, that is, ratios of the lengths of any two sides are equal to the corresponding ratios of
the original allowing an error of less than 0.01 percent. Other triangles have some of the ratios
different from the original by at least 0.1 percent.

The origin of the coordinate system is not the center of the earth but the center of our galaxy.
Note that negative coordinate values may appear here. As they are all within or close to our galaxy, coordinate values are less than one hundred thousand light years. You don’t have to
take relativistic effects into account, i.e., you may assume that we are in a Euclidean space. You
may also assume in your calculation that one light year is equal to 9.461 × 1012 kilometers.

A succeeding data set, if any, starts from the line immediately following the last line of the
preceding data set.

Output

For each data set, one line should be output. That line should contain the point numbers of the
three vertices of the similar triangle, separated by a space character. They should be reported
in the order P, Q, and then R.

Sample Input

2
50.36493 81.61338 79.96592
5
-10293.83 -4800.033 -5296.238
14936.30 6964.826 7684.818
-4516.069 25748.41 -27016.06
18301.59 -11946.25 5380.309
27115.20 43415.93 -71607.81
11.51547 13.35555 14.57307
5
-56292.27 2583.892 67754.62
-567.5082 -756.2763 -118.7268
-1235.987 -213.3318 -216.4862
-317.6108 -54.81976 -55.63033
22505.44 -40752.88 27482.94

Output for the Sample Input

1 2 4
3 4 2

Solution in JAVA (judge verdict: Accepted)

import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class Main{

	Scanner sc=new Scanner(System.in);

	int INF=1<<28;
	double EPS=1e-9;

	double[] d;
	P[] ps;
	int n;

	void run(){
		d=new double[3];
		for(int t=sc.nextInt(); t>0; t--){
			for(int i=0; i<3; i++){
				d[i]=sc.nextDouble();
			}
			n=sc.nextInt();
			ps=new P[n];
			for(int i=0; i<n; i++){
				double x=sc.nextDouble();
				double y=sc.nextDouble();
				double z=sc.nextDouble();
				ps[i]=new P(x, y, z);
			}
			solve();
		}
	}

	void solve(){
		double[] len={0, 0, 0};
		for(int c=0; c<n; c++){
			for(int b=0; b<n; b++){
				if(b==c){
					continue;
				}
				for(int a=0; a<n; a++){
					if(a==b||a==c){
						continue;
					}
					len[0]=ps[b].sub(ps[c]).abs()/d[0];
					len[1]=ps[c].sub(ps[a]).abs()/d[1];
					len[2]=ps[a].sub(ps[b]).abs()/d[2];
					boolean error=false;
					for(int i=0; i<3; i++){
						int p=i;
						int q=(i+1)%3;
						error|=abs(len[p]-len[q])/len[p]+EPS>=0.001;
					}
					if(!error){
						// debug(len);
						// debug(a,b,c);
						println((a+1)+" "+(b+1)+" "+(c+1));
					}
				}
			}
		}
	}

	class P{
		double x, y, z;

		P(){
			this(0, 0, 0);
		}

		P(double x, double y, double z){
			this.x=x;
			this.y=y;
			this.z=z;
		}

		P add(P p){
			return new P(x+p.x, y+p.y, z+p.y);
		}

		P sub(P p){
			return new P(x-p.x, y-p.y, z-p.z);
		}

		P mul(double m){
			return new P(x*m, y*m, z*m);
		}

		P div(double d){
			return new P(x/d, y/d, z/d);
		}

		double abs(){
			return Math.sqrt(abs2());
		}

		double abs2(){
			return x*x+y*y+z*z;
		}

		// inner product
		double dot(P p){
			return x*p.x+y*p.y+z*p.y;
		}

		// outer product
		P det(P p){
			return new P(y*p.z-z*p.y, z*p.x-x*p.z, x*p.y-y*p.x);
		}

		@Override
		public String toString(){
			return x+", "+y+", "+z;
		}
	}

	void debug(Object... os){
		System.err.println(Arrays.deepToString(os));
	}

	void print(String s){
		System.out.print(s);
	}

	void println(String s){
		System.out.println(s);
	}

	public static void main(String[] args){
		// System.setOut(new PrintStream(new BufferedOutputStream(System.out)));
		new Main().run();
	}
}