Go: package main

import (
	"bufio"
	"os"
	"strconv"
	"strings"
	"math"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	dd := make([][]int, 1000)
	for i := range dd {
		dd[i] = make([]int, 1000)
	}
	num := make([]int,1000)
	inv := make([]int, 1001)
	x := make([]int, 1000)
	y := make([]int, 1000)
	vv := make([]int, 1000)
	nowt := make([]float64, 1000)
	rev := make([]int, 1000)
	for scanner.Scan() {
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		for i := 0; i < n; i++ {
			scanner.Scan()
			buf1 := strings.Split(scanner.Text(), " ")
			num[i], _ = strconv.Atoi(buf1[0])
			x[i], _ = strconv.Atoi(buf1[1])
			y[i], _ = strconv.Atoi(buf1[2])
			inv[num[i]] = i
		}
		for i := 0; i < n; i++ {
			for j := 0; j < n; j++ {
				dd[i][j]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])
			}
		}
		scanner.Scan()
		m, _ := strconv.Atoi(scanner.Text())
		for i := 0; i < m; i++ {
			scanner.Scan()
			buf2 := strings.Split(scanner.Text(), " ")
			c, _ := strconv.Atoi(buf2[0])
			d, _ := strconv.Atoi(buf2[1])
			c = inv[c]
			d = inv[d]
			for j := 0; j < n; j++ {
				vv[j] = 0
				nowt[j]=999999999
				rev[j]=-1
			}
			nowt[c]=0
			for j := 0; j < n; j++ {
				M := 99999999
				at := 0
				for k := 0; k < n; k++ {
					if vv[k] == 0 && float64(M) > nowt[k] {
						M=int(nowt[k])
						at = k
					}
				}
				if M > 90000000 {
					break
				}
				vv[at]=1
				for k := 0; k < n; k++ {
					if vv[k] == 0 && dd[at][k]<=2500&&nowt[k]>nowt[at]+math.Sqrt(float64(dd[at][k])) {
						nowt[k]=nowt[at]+math.Sqrt(float64(dd[at][k]))
						rev[k] = at
					}
				}
			}
			if vv[d] == 0 {
				fmt.Println("NA")
			} else {
				stack := make([]int, 0)
				V := d
				for V != c {
					stack = append(stack, V)
					V = rev[V]
				}
				fmt.Print(num[c])
				for len(stack) > 0 {
					fmt.Printf(" %d", num[stack[len(stack)-1]])
					stack = stack[:len(stack)-1]
				}
				fmt.Println()
			}
		}
	}
}

C++: #include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
using namespace std;

const double EPS = 1e-6;

struct Building{
	int x, y;
	Building(){
		x = -1; y = -1;
	}
};

struct Edge{
	int to;
	double cost;
	Edge(){}
	Edge(const int &_to, const double &_cost){
		to = _to; cost = _cost;
	}
};

struct Data{
	int n;
	double cost;
	Data(){}
	Data(const int &_n, const double &_cost){
		n = _n; cost = _cost;
	}
	bool operator < (const Data &a) const{
		return cost > a.cost;
	}
};

double GetDistance(const Building &b1, const Building &b2){
	double dx = b1.x - b2.x, dy = b1.y - b2.y;
	return sqrt(dx*dx + dy*dy);
}

vector<Edge> e[1000];
Building v[1000];
priority_queue<Data> pq;

int main(){
	int N, M, B, S, G;

	while(cin >> N, N){
		for(int i = 0; i < 1000; i++) e[i].clear();

		for(int i = 0; i < N; i++){
			cin >> B; B--;
			cin >> v[B].x >> v[B].y;
		}

		int cnt = 0;
		for(int i = 0; i < 1000; i++){
			if(v[i].x != -1){
				v[cnt++] = v[i];
			}
		}

		for(int i = 0; i < N; i++){
			for(int j = i+1; j < N; j++){
				if(v[i].x == -1 || v[j].x == -1 || i == j) continue;
				double dist = GetDistance(v[i], v[j]);
				if(dist <= 50){
					e[i].push_back( Edge(j, dist) );
					e[j].push_back( Edge(i, dist) );
				}
			}
		}

		cin >> M;
		for(int j = 0; j < M; j++){
			cin >> S >> G; S--; G--;

			Data pq_top;
			pq.push( Data(S, 0) );
			double memo[1000];
			fill_n(memo, 1000, -1);
			bool na = true;

			while( !pq.empty() ){
				pq_top = pq.top(); pq.pop();
			
				if(memo[pq_top.n] > -0.5) continue;
				memo[pq_top.n] = pq_top.cost;
				if(pq_top.n == G){
					na = false; break;
				}

				for(int i = 0; i < e[pq_top.n].size(); i++){
					pq.push( Data( e[pq_top.n][i].to, pq_top.cost + e[pq_top.n][i].cost ) );
				}
			}
			while( !pq.empty() ) pq.pop();

			if(na){
				puts("NA"); break;
			}

			stack<int> ans;
			while(true){
				ans.push(G);
				if(G == S) break;
				for(int i = 0; i < e[G].size(); i++){
					if( abs(memo[G] - memo[ e[G][i].to ] - e[G][i].cost) < EPS){
						G = e[G][i].to; break;
					}
				}
			}
		
			printf("%d", ans.top()+1 ); ans.pop();
			while( !ans.empty() ){
				printf(" %d", ans.top()+1 ); ans.pop();
			}puts("");
		}
	}
	return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <cfloat>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <algorithm>
#include <functional>
#include <utility>
#include <numeric>

using namespace std;

typedef unsigned int UI;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int,int> PII;
typedef istringstream ISS;
typedef ostringstream OSS;

#define REP( i, m, n ) for ( int i = (int)( m ); i < (int)( n ); ++i )
#define EACH( v, c ) for ( auto &v : c )

#define ITER( c ) __typeof( (c).begin() )
#define IREP( c, it ) for ( ITER(c) it = c.begin(); it != c.end(); ++it )
#define ALL( c ) (c).begin(), (c).end()

#define PB( n ) push_back( n )
#define MP( a, b ) make_pair( ( a ), ( b ) )
#define EXIST( c, e ) ( (c).find( e ) != (c).end() )

#define fst first
#define snd second

#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
#define DEBUG( x ) cerr << __FILE__ << ":" << __LINE__ << ": " << #x << " = " << ( x ) << endl

struct Building
{
	int num, x, y;

	Building( int n, int x, int y ) : num( n ), x( x ), y( y )
	{
		return;
	}
};

double distance( double x1, int y1, int x2, int y2 )
{
	return sqrt( pow( x1 - x2, 2 ) + pow( y1 - y2, 2 ) );
}

typedef pair<int,double> Edge;

VI dijkstra( vector< vector< Edge > > G, const int s, int t )
{
	const int V = G.size();

	vector< double > dist( V, DBL_MAX );
	dist[s] = 0;

	VI prev( V, -1 );

	priority_queue< pair<double,int>, vector< pair<double,int> >, greater< pair<double,int> > > que;
	que.push( MP( 0, s ) );

	while ( !que.empty() )
	{
		double d = que.top().fst;
		int cur = que.top().snd;
		que.pop();

		REP( i, 0, G[ cur ].size() )
		{
			int next = G[ cur ][i].fst;
			double cost = G[ cur ][i].snd;

			if ( dist[ next ] <= d + cost )
			{
				continue;
			}

			dist[ next ] = d + cost;
			prev[ next ] = cur;

			que.push( MP( d + cost, next ) );
		}
	}

	if ( dist[t] == DBL_MAX )
	{
		return VI();
	}

	VI res;

	while ( true )
	{
		res.PB( t + 1 );

		if ( prev[t] == -1 )
		{
			break;
		}

		t = prev[t];
	}

	reverse( ALL( res ) );

	return res;
}

int main()
{
	cin.tie( 0 );
	ios::sync_with_stdio( false );

	while ( true )
	{
		int n;
		cin >> n;

		if ( !n )
		{
			break;
		}

		vector< Building > buils;

		REP( i, 0, n )
		{
			int num, x, y;
			cin >> num >> x >> y;

			num--;

			buils.PB( Building( num, x, y ) );
		}

		vector< vector< Edge > > G( n );

		REP( i, 0, n )
		{
			REP( j, i + 1, n )
			{
				double dist = distance( buils[i].x, buils[i].y, buils[j].x, buils[j].y );

				if ( dist <= 50 )
				{
					G[i].PB( MP( j, dist ) );
					G[j].PB( MP( i, dist ) );
				}
			}
		}

		int m; 
		cin >> m;

		REP( i, 0, m )
		{
			int s, t;
			cin >> s >> t;

			s--;
			t--;

			VI path = dijkstra( G, s, t );

			if ( path.size() == 0 )
			{
				cout << "NA" << endl;
			}
			else
			{
				REP( j, 0, path.size() )
				{
					if ( j )
					{
						cout << ' ';
					}

					cout << path[j];
				}
				cout << endl;
			}
		}
	}

	return 0;
}