Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)
const INF = 1<<31

func main() {
	scanner.Scan()
	n, _ := strconv.Atoi(scanner.Text())
	arr := make([][]int, n)
	for i := range arr {
		arr[i] = make([]int, n)
	}
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			arr[i][j] = INF
		}
	}
	for i := 0; i < n; i++ {
		scanner.Scan()
		buf := strings.Split(scanner.Text(), " ")
		input := make([]int, len(buf))
		for j := range input {
			input[j], _ = strconv.Atoi(buf[j])
		}
		x, k := input[0]-1, input[1]
		for j := 0; j < k; j++ {
			y := input[j+2]-1
			arr[x][y] = 1
		}
	}
	for k := 0; k < n; k++ {
		arr[k][k] = 0
		for i := 0; i < n; i++ {
			if arr[i][k] >= INF {
				continue
			}
			for j := 0; j < n; j++ {
				if arr[k][j] >= INF {
					continue
				}
				arr[i][j] = min(arr[i][j], arr[i][k]+arr[k][j])
			}
		}
	}
	scanner.Scan()
	p, _ := strconv.Atoi(scanner.Text())
	for i := 0; i < p; i++ {
		scanner.Scan()
		buf := strings.Split(scanner.Text(), " ")
		input := make([]int, len(buf))
		for j := range input {
			input[j], _ = strconv.Atoi(buf[j])
		}
		s, d, v := input[0]-1, input[1]-1, input[2]
		if arr[s][d] < v {
			fmt.Println(arr[s][d]+1)
		} else {
			fmt.Println("NA")
		}
	}
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

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

int md = 10000000;
vector <int> ro[100];
int s,d,v;
int s2,d2;
int kk[100],n;

void visit(int sn,int dis) {
  int x;
  
  if(dis <= v) {
    for(int i=0;i<ro[sn].size();i++) {
      for(int j=0;j<n;j++)
	if(ro[sn][i] == kk[j]) {
	  x = j;
	  break;
	}
      //   cout <<sn << "to"<<x << endl;
      
      visit(x,dis+1);
    }
    
    if(sn == d2) md = min(md,dis);
    
  }
}
  
int main() {

  cin >> n;
  int a;
    
  for(int i=0;i<n;i++) {
    cin >> kk[i];
    cin >> a;
    ro[i].resize(a);
    for(int j=0;j<a;j++) cin >> ro[i][j];
  }
  
  int p;
  cin >> p;
  for(int i=0;i<p;i++) {
    cin >> s >> d >> v;

   
    for(int i=0;i<n;i++)
      if(kk[i] == s) {
	s2 = i;
	break;
      }
    
    for(int i=0;i<n;i++)
      if(kk[i] == d) {
	d2 = i;
	break;
      }
    
    md = 10000000;
    visit(s2,1);
    if(md != 10000000) cout << md <<endl;
    else cout << "NA" <<endl;
  }
  
  return 0;
  
}

C++: #include<iostream>
#include<cstring>
#include<queue>
#define MAX_N 110
#define INF (1<<30)
bool A[MAX_N][MAX_N];
int rooter_num;
using namespace std;
int bfs(int,int);
int main()
{
  int n,startNode,goalNode,TTL;
  int r,k,t;
  int a;
  memset(A,false,sizeof(A));
  cin>>rooter_num;
  /*------------input---------------*/
  for(int i=0;i<rooter_num;i++)
    {
      cin>>r>>k;
      for(int j=0;j<k;j++)
	{
	  cin>>t;
	  A[r][t]=true;
	}
    }
  cin>>n;
  /*-------------search--------------*/
  for(int i=0;i<n;i++)
    {
      cin>>startNode>>goalNode>>TTL;
      a=bfs(startNode,goalNode);
      //cout<<"TTL="<<TTL<<";"<<"a-1="<<a<<endl;
      /*
	 TTLの減少値 = (それまでに通ったルータの数) - 1
	 直前のNodeでTTLが1以上ならばパケットが通るので
	 goal地点でのTTLの減少値がTTLと同等,またはそれ以下ならば
	 パケットが通る事になる。
       */
      if(a<=TTL)cout<<a<<endl;
      else cout<<"NA"<<endl;
       
    }
  return 0;
}
int bfs(int startNode,int goalNode)
{
  queue<int>Q;
  int visited[rooter_num+1];
  /*
    visitedは既に通過しているかの判定と経由したルータの数を保持する
  */
  memset(visited,0,sizeof(visited));
  /*
    memsetによって全てを０で初期化する
  */

  int currentNode=startNode;
  Q.push(currentNode);
  visited[currentNode]=1;

  /*-------BFS--------*/  
  while(!Q.empty())
    {
      currentNode=Q.front();
      Q.pop();
      for(int nextNode=1;nextNode<=rooter_num;nextNode++)
	{

	  if(A[currentNode][nextNode]==0)continue;
	  /*
	    接続されていない場合を切り取った
	  */
	  if(nextNode==goalNode)return visited[currentNode]+1;
	  /*
	    goalNodeの接続を確認したので探索を打ち切る
	  */
	  if(visited[nextNode]<=0)
	    {
	      visited[nextNode]=visited[currentNode]+1;
	      Q.push(nextNode);
	    }
	  /*
	    まだ訪れていない(かつ接続出来るNodeを)キューに追加する
	   */
	}
    }
  return INF;
  /*
    接続出来ない場合無限大を返す
   */
}

C++: #include<iostream>
#include<map>
#include<queue>

const int INFTY = 1 << 22;

using namespace std;

class Rooter{
  public:
Rooter(){
  this->cost = INFTY;
  this->done = false;
}
  int cost;
  bool done;
  vector<int> vcon;
};

void BFS( int start, map< int, Rooter > &G ){
  queue< Rooter * > q;

  G[ start ].cost = 1;
  G[ start ].done = true;
  q.push( &G[start] );

  while( !q.empty() ){
    Rooter *r = q.front();
    q.pop();

    for(int i = 0; i < r->vcon.size(); i++){
      if( G[ r->vcon[i]].done ){
	continue;
      }
      G[ r->vcon[i] ].cost = min( G[ r->vcon[i] ].cost , r->cost + 1 );
      q.push( &G[ r->vcon[i] ] );
      G[ r->vcon[i] ].done = true;
    }
  }
}

void ResetGraph( map< int, Rooter > &G, vector<int> &vId ){
  for(int i = 0; i < vId.size(); i++){
    G[ vId[i] ].cost = INFTY;
    G[ vId[i] ].done = false;
  }
}

int main(void){
  int n, p;
  vector< int > vId;
  map< int, Rooter > G;

  cin >> n;
  
  for(int i = 0; i < n; i++){
    int no;
    int cnum;
    Rooter r;

    cin >> no >> cnum;
    vId.push_back( no );
    for(int j = 0; j < cnum; j++){
      int connect;
      cin >> connect;
      r.vcon.push_back( connect );
    }
    G[ no ] = r;
  }

  cin >> p;
  for(int i = 0; i < p; i++){
    int s, d, ttl;

    cin >> s >> d >> ttl;
    ResetGraph( G, vId );
    BFS( s, G );
    if( G[d].cost <= ttl ){
      cout << G[d].cost << '\n';
    }else{
      cout << "NA\n";
    }
  }
  
  return 0;
}

C++: #include <iostream>
#include <queue>
#include <map>
#include <climits>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef pair<int,int> NODE;

map< int,vector<int> > info;

int bfs(int s,int d){
	queue<NODE> Q;
	
	map<int,bool>done;
	
	
	Q.push( make_pair(s,0) );

	while(!Q.empty()){
		NODE now = Q.front();
		Q.pop();
		done[now.first] = true;
		if(now.first == d){
			return now.second;
		}
		for(int i=0;i<info[now.first].size();i++){
			if(!done[info[now.first][i]])
				Q.push( make_pair(info[now.first][i],now.second+1));
		}
	}
	return INT_MAX;
}

int main(){
	int n,r,k,t;
	int p,s,d,v;
	
	cin >> n;
	
	for(int i=0;i<n;i++){
		cin >> r >> k;
		for(int j=0;j<k;j++){
			cin >> t;
			info[r].push_back(t);
		}
	}
	
	cin >> p;
	
	for(int i=0;i<p;i++){
		cin >> s >> d >> v;
		if(v > bfs(s,d) )cout << bfs(s,d)+1 << endl;
		else cout << "NA" << endl;
	}
}

C++: #include<stdio.h>
#include<algorithm>
using namespace std;
int g[100][100];
int main(){
	int a;
	scanf("%d",&a);
	for(int i=0;i<100;i++)
		for(int j=0;j<100;j++)
			g[i][j]=1999999999;
	for(int i=0;i<a;i++)
		g[i][i]=0;
	for(int i=0;i<a;i++){
		int b,c;
		scanf("%d%d",&b,&c);
		for(int j=0;j<c;j++){
			int d;
			scanf("%d",&d);
			g[b-1][d-1]=1;
		}
	}
	for(int k=0;k<a;k++)
		for(int i=0;i<a;i++)
			for(int j=0;j<a;j++)
				g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
	scanf("%d",&a);
	while(a--){
		int p,q,r;scanf("%d%d%d",&p,&q,&r);
		r=min(r,10000);
		
		if(r<=g[p-1][q-1])printf("NA\n");
		else printf("%d\n",g[p-1][q-1]+1);
	}
}