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 <stdio.h>

/* ?????°???????????? */
typedef	void			VD;
typedef	signed char		I1;
typedef unsigned char 	U1;
typedef	signed short	I2;
typedef unsigned short 	U2;
typedef	signed int		I4;
typedef unsigned int 	U4;

/* ?????°?????? */
#define MAX_ROUTER 100
#define MAX_TTL 10000

#define CONNECT 1
#define DISCONNECT 0
#define SENTINEL -1

#define INPUT_SUCCESS 0
#define INPUT_ERORR -1

/* ????????????????????£?¨? */
VD setInit(VD);
I1 inputConnectInfo(VD);
I1 inputTransmitPacket(VD);
I4 CalcRouterSum(I4 i4Sender,I4 i4Destination,I4 i4TTL,I4 i4RouterSum);

/* ??°?????????????????° */
I1 u1Connect[MAX_ROUTER+1][MAX_ROUTER+1];
I4 i4RouterNum;

I4 main(VD)
{
	I1 i1ErrorCheck;
	I4 i4CalcNum;
	I4 i4RoopCnt1;
	I4 i4RoopCnt2;
	
	setInit();
	i1ErrorCheck = inputConnectInfo();
	if(i1ErrorCheck == INPUT_SUCCESS){
		scanf("%d",&i4CalcNum);
		for( i4RoopCnt1=0; i4RoopCnt1<i4CalcNum; i4RoopCnt1++)
		{
			inputTransmitPacket();
		}
	}
}

VD setInit(VD)
{
	I4 i4RoopCnt1;
	I4 i4RoopCnt2;
	
	for( i4RoopCnt1=1; i4RoopCnt1<=MAX_ROUTER; i4RoopCnt1++)
	{
		for(i4RoopCnt2=1; i4RoopCnt2<=MAX_ROUTER; i4RoopCnt2++)
		{
			u1Connect[i4RoopCnt1][i4RoopCnt2] = DISCONNECT;
		}
	}
	return;
}

I1 inputConnectInfo(VD)
{
	I1 i1Return;
	I4 i4RoopCnt1;
	I4 i4RoopCnt2;
	I4 i4RouterCnt;
	I4 i4ConnectNum;
	I4 i4AccessPoint;
	
	i1Return = INPUT_SUCCESS;
	
	scanf("%d",&i4RouterNum);
	if(i4RouterNum <= (I4)MAX_ROUTER)
	{
		for( i4RoopCnt1=1; i4RoopCnt1<=i4RouterNum; i4RoopCnt1++)
		{
			scanf("%d%d",&i4RouterCnt,&i4ConnectNum);
			for( i4RoopCnt2=0; i4RoopCnt2<i4ConnectNum; i4RoopCnt2++)
			{
				scanf("%d",&i4AccessPoint);
				u1Connect[i4RouterCnt][i4AccessPoint] = CONNECT;
			}
			u1Connect[i4RouterCnt][i4RouterNum+1] = SENTINEL;
		}
	}
	else
	{
		i1Return = INPUT_ERORR;
	}
	return i1Return;
}

I1 inputTransmitPacket(VD)
{
	I1 i1Return;
	I4 i4StartRouter;
	I4 i4GoalRouter;
	I4 i4TTL;
	I4 i4Ans;
	
	i1Return = INPUT_SUCCESS;
	
	scanf("%d%d%d",&i4StartRouter,&i4GoalRouter,&i4TTL);
	if(i4TTL <= MAX_TTL)
	{
		printf("start:%d,goal:%d,TTL:%d\n",i4StartRouter,i4GoalRouter,i4TTL);
		i4Ans = CalcRouterSum(i4StartRouter,i4GoalRouter,i4TTL,1);
		if(i4Ans >= i4TTL+1){
			printf("NA\n");
		}
		else
		{
			printf("%d\n",i4Ans);
		}
		printf("--------------\n");
	}
	else
	{
		i1Return = INPUT_ERORR;
	}
	return i1Return;
}

I4 CalcRouterSum(I4 i4Sender,I4 i4Destination,I4 i4TTL,I4 i4RouterSum)
{
	printf("%d -> %d,TTL=%d\n",i4Sender,i4Destination,i4TTL);
	I4 i4RoopCnt1;
	I4 i4MinRouterNum;
	I4 i4TmpRouterSum;
	I4 i4Return;
	
	
	i4Return = i4TTL+i4RouterSum;
	
	if(i4Sender == i4Destination)
	{
		printf("RouterSum=%d\n",i4RouterSum);
		return i4RouterSum;
	}
	else
	{
		if(i4TTL <= 0)
		{
			printf("TTL is 0\n");
			return 0;
		}
		else
		{
			i4RoopCnt1 = 1;
			while(u1Connect[i4Sender][i4RoopCnt1] != SENTINEL){
				if(u1Connect[i4Sender][i4RoopCnt1] == CONNECT)
				{
					i4TmpRouterSum = CalcRouterSum(i4RoopCnt1,i4Destination,i4TTL-1,i4RouterSum+1);
					if((i4TmpRouterSum > 0 ) && (i4TmpRouterSum < i4Return))
					{
						printf("CalcRouterSum()=%d\n",i4TmpRouterSum);
						i4Return = i4TmpRouterSum;
					}
						
				}
				i4RoopCnt1++;
			}
			
		}
	}
	return i4Return;
}

C++: #include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctype.h>
#include <ctime>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <iterator>
#include <algorithm>

using namespace std;

#define REP(i, x, n) for(int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define lengthof(x) (sizeof(x) / sizeof(*(x)))
#define FILL(ptr, value) FILL_((ptr), sizeof(ptr)/sizeof(value), (value))
template <typename T>
void FILL_(void * ptr, size_t size, T value){
  std::fill((T*)ptr, (T*)ptr+size, value);
}
//4方向ベクトル→↑←↓
int dx[] ={1,0,-1,0};
int dy[] ={0,-1,0,1};
typedef pair<int,int> P;
const int INF =100000000;
int n;
int d[110][110];
int main()
{
  int r,k;
  while(cin>>n){
    for(int i = 0;i < 110;i++){
      for(int j = 0;j <110;j++){
	d[i][j]= INF;
      }
    }
    for(int i = 1;i <=n;i++){
      cin>>r>>k;
      for(int j = 0;j < k;j++){
	int x;
	cin>>x;
	d[r][x] = 1;
      }
    }
    for(int k = 1;k <=n;k++){
      for(int i = 1;i <=n;i++){
	for(int j = 1;j <=n;j++){
	  d[i][j] =min(d[i][j],d[i][k]+d[k][j]);
	}
      }
    }
    int p;
    cin>>p;
    int s1,d1,v1;
    for(int i = 0;i <p;i++){
      cin>>s1>>d1>>v1;
      if(d[s1][d1]+1<=v1){
	cout <<d[s1][d1]+1<<endl;
      }else{
	cout <<"NA"<<endl;
      }
    }
  }
  return 0;
}

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

using namespace std;

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;

#define REP( i, m, n ) for ( int i = (int)( m ); i < (int)( n ); i++ )
#define UREP( i, m, n ) for ( unsigned int i = (unsigned int)( m ); i < (unsigned int)( n ); i++ )

#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 RALL( c ) (c).rbegin(), (c).rend()

#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

typedef vector<char> VC;
typedef vector< VC > VVC;

int main()
{
	int n;
	cin >> n;

	VVI res( n, VI( n, INT_MAX / 10 ) );

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

		from--;

		REP( j, 0, num )
		{
			int to;
			cin >> to;

			to--;

			res[ from ][ to ] = 1;
		}
	}

	const int N = res.size();

	REP( k, 0, N )
	{
		REP( i, 0, N )
		{
			REP( j, 0, N )
			{
				res[i][j] = min( res[i][j], res[i][k] + res[k][j] );
			}
		}
	}

	int p;
	cin >> p;

	REP( i, 0, p )
	{
		int s, d, v;
		cin >> s >> d >> v;

		s--;
		d--;

		int dist = res[s][d] + 1;

		if ( dist <= v )
		{
			cout << dist << endl;
		}
		else
		{
			cout << "NA" << endl;
		}
	}

	return 0;
}