Problem:
Problem F: Name the Crossing

The city of Kyoto is well-known for its Chinese plan: streets are
either North-South or East-West. Some streets are numbered, but most
of them have real names.

Crossings are named after the two streets crossing there,
e.g. Kawaramachi-Sanjo is the crossing of Kawaramachi street and Sanjo
street. But there is a problem: which name should come first?
At first the order seems quite arbitrary: one says Kawaramachi-Sanjo
(North-South first) but Shijo-Kawaramachi (East-West first). With some
experience, one realizes that actually there
seems to be an "order" on the streets, for instance in the above
Shijo is "stronger" than Kawaramachi, which in turn is "stronger" than
Sanjo.
One can use this order to deduce the names of other crossings.

You are given as input a list of known crossing names X-Y.
Streets are either North-South or East-West, and only orthogonal streets
may cross.

As your list is very incomplete, you start by completing it using
the following rule:

two streets A and B have equal strength if (1) to (3) are
all true:

they both cross the same third street C in the input

there is no street D such that D-A and B-D appear in the input

there is no street E such that A-E and E-B appear in the input

We use this definition to extend our strength relation:

A is stronger than B, when there is a
sequence A = A1, A2, ..., An = B,
with n at least 2,

where, for any i in 1 .. n-1, either
Ai-Ai+1 is an input crossing or
Ai and Ai+1 have equal strength.

Then you are asked whether some other possible crossing names X-Y are
valid. You should answer affirmatively if you can infer the validity of a
name, negatively if you cannot. Concretely:

YES if you can infer that the two streets are orthogonal, and X
is stronger than Y

NO otherwise

Input

The input is a sequence of data sets, each of the form

N
Crossing1
...
CrossingN
M
Question1
...
QuestionM

Both Crossings and Questions are of the form

X-Y

where X and Y are strings of alphanumerical characters,
of lengths no more than 16. There is no white space, and case matters
for alphabetical characters.

N and M are between 1 and 1000 inclusive, and there are
no more than 200 streets in a data set.

The last data set is followed by a line containing a zero.

Output

The output for each data set should be composed of M+1 lines,
the first one containing the number of streets
in the Crossing part of the input, followed by the answers to
each question, either YES or NO without any spaces.

Sample Input

7
Shijo-Kawaramachi
Karasuma-Imadegawa
Kawaramachi-Imadegawa
Nishioji-Shijo
Karasuma-Gojo
Torimaru-Rokujo
Rokujo-Karasuma
6
Shijo-Karasuma
Imadegawa-Nishioji
Nishioji-Gojo
Shijo-Torimaru
Torimaru-Gojo
Shijo-Kawabata
4
1jo-Midosuji
Midosuji-2jo
2jo-Omotesando
Omotesando-1jo
4
Midosuji-1jo
1jo-Midosuji
Midosuji-Omotesando
1jo-1jo
0

Output for the Sample Input

8
YES
NO
YES
NO
YES
NO
4
YES
YES
NO
NO

Solution in C++11 (judge verdict: Runtime Error)

#include <bits/stdc++.h>
using namespace std;

using Pair = pair<int, int>;

int N;
int M;
int g_idx;
char buf[114514];
int par[4145];
int myrank[4145];
bool used[4145];
bool isr[4145][4145];
bool isr2[4145][4145];

vector<int> vs[4145];
vector<int> es[4145];
vector<int> res[4145];
vector<int> bs[4145];
map<string, int> mp;

int root(int v) {
  if (par[v] == v) return v;
  return par[v] = root(par[v]);
}

void unite(int a, int b) {
  a = root(a);
  b = root(b);
  if (a == b) return;
  if (myrank[a] < myrank[b]) par[a] = b;
  else if (myrank[b] < myrank[a]) par[b] = a;
  else {
    par[a] = b;
    myrank[a]++;
  }
}


Pair GetIdx(string &s) {
  auto itr = s.find('-');
  string a;
  a.assign(s, 0, itr);
  string b;
  b.assign(s, itr+1, s.size()-itr-1);
  if (!mp.count(a)) mp[a] = g_idx++;
  if (!mp.count(b)) mp[b] = g_idx++;
  return Pair(mp[a], mp[b]);
}

void dfs1(int v, int k) {
  isr[k][v] = true;
  for (int u : es[v]) {
    if (isr[k][u]) continue;
    dfs1(u, k);
  }
}

void dfs2(int v, int k) {
  for (int dv : vs[root(v)]) {
    isr2[k][dv] = true;
    for (int u : es[dv]) {
      if (isr2[k][u]) continue;
      dfs2(u, k);
    }
  }
}

int dfs3(int v, int k) {
  if (used[v]) return -1;
  if (v == k) return 0;
  used[v] = true;

  int ret = -1;
  for (int u : bs[v]) {
    ret = max(ret, dfs3(u, k));
  }
  if (ret == -1) return -1;
  //printf("%d %d: %d\n", v, k, ret);
  return ret+1;
}

int main() {
  while (1) {
    scanf("%d", &N);
    if (N == 0) return 0;

    mp.clear();
    g_idx = 0;
    for (int i=0; i<N; i++) {
      scanf("%s", buf);
      string s = buf;
      int a, b;
      tie(a, b) = GetIdx(s);
      bs[a].emplace_back(b);
      bs[b].emplace_back(a);
      es[a].emplace_back(b);
      res[b].emplace_back(a);
    }
    printf("%d\n", g_idx);

    for (int i=0; i<g_idx; i++) {
      par[i] = i;
      myrank[i] = 0;
      for (int j=0; j<g_idx; j++) {
        isr[i][j] = false;
        isr2[i][j] = false;
      }
    }

    for (int i=0; i<g_idx; i++) {
      vs[i].clear();
      dfs1(i, i);
    }

    for (int i=0; i<g_idx; i++) {
      for (int u : es[i]) {
        for (int v : es[i]) {
          if (!isr[u][v] && !isr[v][u]) unite(u, v);
        }
      }

      for (int u : res[i]) {
        for (int v : res[i]) {
          if (!isr[u][v] && !isr[v][u]) unite(u, v);
        }
      }
    }

    for (int i=0; i<g_idx; i++) {
      vs[root(i)].emplace_back(i);
    }

    for (int i=0; i<g_idx; i++) {
      dfs2(i, i);
    }
    
    scanf("%d", &M);
    for (int i=0; i<M; i++) {
      scanf("%s", buf);
      string s = buf;
      int a, b;
      tie(a, b) = GetIdx(s);
      //for (int i=0; i<g_idx; i++) used[i] = false;
      //printf("%d %d : %d\n", a, b, dfs3(a, b));
      for (int i=0; i<g_idx; i++) used[i] = false;
      if (isr2[a][b] && dfs3(a, b)%2 == 1) puts("YES");
      else puts("NO");
    }

    for (int i=0; i<g_idx; i++) {
      es[i].clear();
      res[i].clear();
      bs[i].clear();
    }
  }
}