/*
 * This program attempts to find a good tour for the 3D Euclidean
 * Travelling Salesman Problem.  The input data file begins with an
 * integer n, the number of points to visit.  On the next n lines
 * are x, y, z coordinates that are read into an array of points.
 *
 * If n <= 12, then the optimal solution is computed by trying all
 * (n-1)! permutations.  Otherwise, a number of random tours are
 * tried and the best one chosen.  In either case, when a new best value
 * is found, it is printed to standard error to keep the user entertained.
 *
 * At the end of the program, the best tour is printed on standard output
 * as a sequence of indices.  Index 0 is always printed first; it is 
 * assumed that this is where the saleman starts his tour.
 */
#include <stdio.h>
#include <math.h>

/* point structure: three floats */

typedef struct _point {
	float	x, y, z;
} point;


/* Euclidean distance in 3-space.  Find the distance between vertices i and j */

float distance (point v[], int i, int j) {
	float	dx, dy, dz;

	dx = v[i].x - v[j].x;
	dy = v[i].y - v[j].y;
	dz = v[i].z - v[j].z;
	return sqrt (dx*dx + dy*dy + dz*dz);
}

/* compute the length of a tour, starting from and ending at the first
 * index in the tour
 */
float tour_length (int tour[], point v[], int n) {
	int	i, from, to;
	float	sum;

	/* sum up distances between cities on the tour */
	
	sum = 0;

	/* start at city 0 */

	from = 0;
	for (i=1; i<n; i++) {

		/* find distance to next city in tour */

		to = tour[i];

		/* add that to the length of the tour */

		sum += distance (v, from, to);

		/* the next source is the current target */

		from = to;
	}

	/* add in the distance back to the first city */

	sum += distance (v, from, 0);
	return sum;
}

/* shuffle the elements of a tour */

void randomly_permute (int v[], int n) {
	int	i, j, k;

	/* shuffle around everything (except the first city)
	 * by swapping each element with a randomly chosen element
	 */
	for (i=1; i<n; i++) {
		j = rand () % (n-1);
		j++;
		k = v[i];
		v[i] = v[j];
		v[j] = k;
	}
}

/* recursively generate all permutations of tour[], keeping the best one */
void perm (point v[], int tour[], int best[], int i, int n, 
	float *min, int *k, int nfact) {
	int	j, t;
	float	length;

	/* base case: if i reaches n, then we have a complete permutation */
	if (i == n) {
		(*k)++;
		if (*k % 10000 == 0) {
			printf ("%0.2f%% done\n", 
				100.0 * (float) (*k) / (float) nfact);
		}
		/* compute the length, see if it is the best */

		length = tour_length (tour, v, n);
		if (length < *min) {
			/* if so, keep it and its length */

			*min = length;
			fprintf (stderr, "%f\n", *min);
			memcpy (best, tour, n * sizeof (int));
		}
	} else {

		/* recursively try all tours with i..n in the i'th position */
		for (j=i; j<n; j++) {
			t = tour[i];
			tour[i] = tour[j];
			tour[j] = t;
			perm (v, tour, best, i+1, n, min, k, nfact);
			t = tour[i];
			tour[i] = tour[j];
			tour[j] = t;
		}
	}
}

int fact (int n) {
	return n == 0 ? 1 : n * fact (n-1);
}

int main () {
	int	i, j, n, tour[1000], best[1000], nfact, k;
	float	length, min;
	point	cities[1000];

	scanf ("%d\n", &n);
	for (i=0; i<n; i++) {
		scanf ("%f %f %f\n", &cities[i].x, &cities[i].y, &cities[i].z);
	}
	for (i=0; i<n; i++) tour[i] = i;
	min = tour_length (tour, cities, n);
	memcpy (best, tour, n * sizeof (int));

	/* if n is reasonable, we'll just use brute force to 
	 * find the optimal tour.  Try increasing '10' here.
	 * It gets real bad real fast.
	 */
	if (n <= 12) {
		k = 0;
		nfact = fact (n-1);

		/* This
		 * -----------------------v */
		perm (cities, tour, best, 1, n, &min, &k, nfact);
		/* would normally be 0, but we want to keep index #0
		 * fixed; this call generates all (n-1) permutations
		 * of the last n-1 vertices in the tour
		 */
	}

	/* n is too big?  wimp out and try 1000 random permutations.
	 * You can increase this, too, with diminishing returns.
	 */
	else for (i=0; i<1000; i++) {
		randomly_permute (tour, n);
		length = tour_length (tour, cities, n);
		if (length <= min) {
			min = length;
			memcpy (best, tour, n * sizeof (int));
			fprintf (stderr, "%f\n", min);
		}
	}

	/* print out the winning tour */

	for (i=0; i<n; i++) printf ("%d ", best[i]);
	printf ("\n");
	exit (0);
}