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 <bits/stdc++.h>

using namespace std;

#define MAX 1000
#define INF 1e9

int V;
struct State{
  int x, y;
};

vector<State> vec;

double Dis(State a, State b){
  return sqrt(pow((a.x-b.x),2.) + pow(a.y-b.y,2.));
}

double cost[MAX][MAX];

void dijkstra(int s, int t){
  double dist[MAX];
  bool used[MAX];
  int prev[MAX];

  fill(dist, dist+MAX, INF);
  memset(used,false,sizeof(used));
  memset(prev,-1,sizeof(prev));
  dist[s] = 0;

  while(true){
    int v = -1;
    for(int u = 0 ; u < V ; u++){
      if(!used[u] && (v == -1 || 
                      dist[u] < dist[v])){
        v = u;
      }
    }

    if(v == -1){
      break;
    }else{
      used[v] = true;
    }

    for(int u = 0 ; u < V ; u++){
      if(dist[u] > dist[v] + cost[u][v] && cost[u][v] <= 50){
        dist[u] = dist[v] + cost[u][v];
        prev[u] = v;
      }
    }
  }

  if(dist[t] == INF){
    cout << "NA" << endl;
  }else{
    vector<int> path;
    for(int i = t ; i != -1 ; i = prev[i]){
      path.push_back(i);
    }
    reverse(path.begin(), path.end());
    
    int len = path.size();
    for(int i = 0 ; i < len ; i++){
      cout << path[i]+1 << (i == len-1 ? '\n' : ' ');
    }
  }
}

int main(){
  int n, start, goal, num;
  State s;

  while(cin >> V, V){
    State dist[MAX];

    vec.clear();
    fill(cost[0],cost[V],INF);
    for(int i = 0 ; i < V ; i++){
      cin >> num >> s.x >> s.y;
      vec.push_back(s);
      dist[num-1] = s;
    }

    for(int i = 0 ; i < V-1 ; i++){
      for(int j = i+1 ; j < V ; j++){
        cost[i][j] = cost[j][i] = 
          Dis(dist[i],dist[j]);
      }
    }
 
    cin >> n;
    for(int i = 0 ; i < n ; i++){
      cin >> start >> goal;
      start--, goal--;
      dijkstra(start, goal);
    }
  }
  
  return 0;
}

C++: #include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <complex>

using namespace std;

const int MAX_V = 1001;
// d[u][v]Íu©çvÖÌRXgBßÉ×Ú·éGbWÌRXgðüêÄ¨¢½è·êÎæ¢Í¸B
double d[MAX_V][MAX_V];
const int INF=1000000000;
// ¸_
int V;

#define EPS (1e-10)
#define EQ(a,b) (abs((a)-(b))<EPS)

// prv[i][j] -> iªX^[gn_ÌÆ«Aj©çÇ±Éßé©
int prv[MAX_V][MAX_V];

// S_ÎÅZoHâèðÆ­O(V^3)AÓª ÁÄà®ì
void warshall_floyd(){
    for(int i = 0; i < V; i++){
        for(int j = 0; j < V; j++){
            for(int k = 0; k < V; k++){
                //d[j][k]=min(d[j][k],d[j][i]+d[i][k]);
                if(d[j][k]>d[j][i]+d[i][k]){
                    int cp=k;
                    // XV
                    while(1){
                        prv[j][cp]=prv[i][cp];
                        cp=prv[i][cp];
                        if(cp==i)break;
                    }
                    d[j][k]=d[j][i]+d[i][k];
                }
            }
        }
    }
}
typedef complex<double> P;

void init(int n){
    V=n;
    for(int i = 0; i < MAX_V; i++){
        for(int j = 0; j < MAX_V; j++){
            if(i==j)d[i][j]=0;
            else d[i][j]=INF;
            prv[i][j]=INF;
        }
    }
}

int main(){
    int n;
    while(cin>>n&&n!=0){
        init(n);
        int billNum[MAX_V];
        P billP[MAX_V];
        for(int i=0;i<n;i++){
            int x,y;
            cin>>billNum[i]>>x>>y;
            billP[i]=P(x,y);
            billNum[i]--;
        }
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                double dist=abs(billP[i]-billP[j]);
                // £ª50ÈºÈç¹ðìéÆ¯ÉAßèûðüêÄ¨­
                if(dist<50||EQ(dist,50)){
                    d[i][j]=dist;
                    prv[i][j]=i;
                }
            }
        }
        warshall_floyd();
        int m;
        cin>>m;
        for(int i=0;i<m;i++){
            int s,g;
            cin>>s>>g;
            s--;g--;
            if(EQ(d[s][g],INF))
                cout<<"NA"<<endl;
            else{
                vector<int> v;
                int cp=g;
                while(1){
                    v.push_back(cp+1);
                    if(cp==s)
                        break;
                    cp=prv[s][cp];
                }
                for(int j = v.size()-1; j >= 0; j--){
                    cout<<v[j];
                    if(j==0)cout<<endl;
                    else cout<<" ";
                }
            }
        }
    }

  return 0;
}

C++: #include <iostream>
#include <cmath>
#define ROPE 50.0
#define NEXTD -30

using namespace std;
double dist(int,int);
int inv_in(int,int);

int index_[1000],x[1000],y[1000];
double dst[1000][1000];
int next[1000][1000];

int main(){
  int b_num,root_num;
  int s_index[1000],g_index[1000];
  while(cin >> b_num && b_num!=0){
    for(int i=0;i<b_num;i++){  
      cin >> index_[i] >> x[i] >> y[i];
      for(int j=0;j<=i;j++){
	dst[i][j]= (dist(i,j) > ROPE) ? 10000000.0 : 100000+dist(i,j);
	//ÀÍÍKEEE
	dst[j][i]= dst[i][j];
	next[i][j] = (dist(i,j) > ROPE) ? NEXTD : j;
	next[j][i] = (dist(i,j) > ROPE) ? NEXTD : i;
      }
    }
    
    for(int k=0; k<b_num;k++){
      for(int i =0; i<b_num; i++){
	for(int j =0; j<b_num; j++){
	  if(dst[i][j] > dst[i][k] + dst[k][j]){
	    dst[i][j] = dst[i][k] + dst[k][j];
	    next[i][j] = next[i][k];
	  }
	}
      }
    }
    
    cin >> root_num;
    for(int i=0;i < root_num;i++){
      cin >> s_index[i] >> g_index[i];
      int S=inv_in(b_num,s_index[i]);
      int G=inv_in(b_num,g_index[i]);
      if(next[S][G]!=NEXTD){
	for(int j=S;j!=G;j=next[j][G]){
	  cout << index_[j] << ' ' ;
	}
	cout << index_[G] << endl;
      }
      else{
	cout << "NA" << endl;
      }    
    }
  }
}

double dist(int i,int j){
  double dis;
  dis = pow(pow(double(x[i]-x[j]),2.0)+pow(double(y[i]-y[j]),2.0),0.5);
  return dis;
}

int inv_in(int b_num,int b_ind){
  int inv;
  for(int j=0;j<b_num;j++){
    if(index_[j]==b_ind){
      inv = j;
      break;
    }
  }
  return inv;
}