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
}

Python: # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0144

"""
import sys
from sys import stdin
input = stdin.readline
from enum import Enum


class Graph(object):
    """ single source shortest path """
    class Status(Enum):
        """ ?????????????¨??????¶??? """
        white = 1  # ????¨????
        gray = 2  # ?¨???????
        black = 3  #?¨???????

    def __init__(self, n, data):
        self.num_of_nodes = n+1
        self.color = [Graph.Status.white] * self.num_of_nodes  # ????????????????¨??????¶???
        self.M = [[float('inf')] * self.num_of_nodes for _ in range(self.num_of_nodes)]
        for i in range(self.num_of_nodes):
            self.M[i][i] = 0
        self._make_matrix(data)  # data????????????????????£??\??????(?????\?¶???¨???????????????????????§????????????)
        self.d = [float('inf')] * self.num_of_nodes  # ?§???????????????????(?????????)
        self.p = [-1] * self.num_of_nodes  # ????????????????????????????¨?????????????????????????

    def _make_matrix(self, data):
        for d in data:
            r = d[0]
            for t in d[2:]:
                self.M[r][t] = 1

    def dijkstra(self, start):
        self.d[start] = 0
        self.p[start] = -1
        while True:
            mincost = float('inf')
            # ??\??????????????§??????????????¨?????????????????????u???????????????
            for i in range(len(self.d)):
                if self.color[i] != Graph.Status.black and self.d[i] < mincost:  # S????±???????????????????S??¨??\?¶?????????????????????????????????????????°???????????????????
                    mincost = self.d[i]
                    u = i  # u??????????????????ID
            if mincost == float('inf'):
                break
            self.color[u] = Graph.Status.black  # ?????????u???S????±???????????????´???
            for v in range(len(self.d)):
                if self.color[v] != Graph.Status.black and self.M[u][v] != float('inf'):
                    # v????????????????????????????????°??????S???????????£???u????????????????????????????????????????????°??????????????±??§??´??°??????
                    if self.d[u] + self.M[u][v] < self.d[v]:
                        self.d[v] = self.d[u] + self.M[u][v]
                        self.p[v] = u
                        self.color[v] = Graph.Status.gray

    def warshallFloyd(self):
        V = self.num_of_nodes
        for k in range(V):
            for i in range(V):
                for j in range(V):
                    self.M[i][j] = min(self.M[i][j], self.M[i][k] + self.M[k][j])



def main(args):
    n = int(input())
    network = []
    for _ in range(n):
        network.append([int(x) for x in input().split()])

    packets = []
    p = int(input())
    for _ in range(p):
        packets.append([int(x) for x in input().split()])

    g = Graph(n, network)
    g.warshallFloyd()

    for s, d, v in packets:
        if g.M[s][d] < v:
            print(g.M[s][d]+1)
        else:
            print('NA')



if __name__ == '__main__':
    main(sys.argv[1:])

Python: from collections import deque

n = int(input())
rlst = [None] * (n + 1)
for _ in range(n):
  lst = list(map(int, input().split()))
  r = lst[0]
  lst = lst[2:]
  rlst[r] = lst

p = int(input())

for _ in range(p):
  s, d, v = map(int, input().split())
  visited = [False] * (n + 1)
  visited[s] = True
  que = deque()
  que.append((s, 0))
  while que:
    node, dist = que.pop()
    if node == d:
      print(dist + 1)
      break
    if dist < v - 1:
      for to in rlst[node]:
        if not visited[to]:
          que.append((to, dist + 1))
          visited[to] = True
  else:
    print("NA")

Python: """
def find(s,p,g,box,cost):
    for i in rooter[p]:
        if i==g:box.append(cost+1)
        elif i==s:continue
        else:find(s,i,g,box,cost+1)
    return box
rooter={}
for i in range(int(input())):
    N=list(map(int,input().split()))
    box=[]
    for j in N[2:]:box.append(j)
    rooter[N[0]]=box

for i in range(int(input())):
    s,g,v=map(int,input().split())
    cost=1
    box=[]
    ans=min(find(s,s,g,box,cost))
    if ans<=v:print(ans)
    else:print("NA")
"""
from collections import deque

n = int(input())
rlst = [None] * (n + 1)
for _ in range(n):
    lst = list(map(int, input().split()))
    r = lst[0]
    lst = lst[2:]
    rlst[r] = lst

p = int(input())

for _ in range(p):
    s, d, v = map(int, input().split())
    visited = [False] * (n + 1)
    visited[s] = True
    que = deque()
    que.append((s, 0))
    while que:
        node, dist = que.popleft()
        if node == d:
            if dist < v:
                print(dist + 1)
            else:
                print("NA")
            break
        for to in rlst[node]:
            if not visited[to]:
                que.append((to, dist + 1))
                visited[to] = True
    else:
        print("NA")

Python: from collections import deque

n = int(input())
rlst = [None] * (n + 1)
for _ in range(n):
  lst = list(map(int, input().split()))
  r = lst[0]
  lst = lst[2:]
  rlst[r] = lst

p = int(input())

for _ in range(p):
  s, d, v = map(int, input().split())
  visited = [False] * (n + 1)
  visited[s] = True
  que = deque()
  que.append((s, 0))
  while que:
    node, dist = que.pop()
    if node == d:
      if dist < v:
        print(dist + 1)
      else:
        print("NA")
      break
    for to in rlst[node]:
      if not visited[to]:
        que.append((to, dist + 1))
        visited[to] = True
  else:
    print("NA")

Python: # AOJ 0144 Packet Transportation
# Python3 2018.6.23 bal4u

INF = 0x7fffffff
n = int(input())
arr = [[INF for j in range(n)] for i in range(n)]
for i in range(n):
	a = list(map(int, input().split()))
	x, k = a[0]-1, a[1]
	for j in range(k):
		y = a[j+2]-1
		arr[x][y] = 1
for k in range(n):
	arr[k][k] = 0
	for i in range(n):
		if arr[i][k] >= INF: continue
		for j in range(n):
			if arr[k][j] >= INF: continue
			arr[i][j] = min(arr[i][j], arr[i][k] + arr[k][j])
p = int(input())
for i in range(p):
	s, d, v = map(int, input().split())
	s,d = s-1, d-1
	print(arr[s][d]+1 if arr[s][d] < v else "NA")