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 = A 1 , A 2 , ..., A n = B,
  with n at least 2, where, for any i in 1 .. n -1, either
  A i -A i +1 is an input crossing or
  A i and A i +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
Crossing 1 ...
Crossing N M
Question 1 ...
Question M   Both Crossing s and Question s 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 (Python):
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write

def solve():
    N = int(readline())
    if N == 0:
        return False
    L = 0
    n_map = {}
    def get(s):
        nonlocal L
        if s in n_map:
            return n_map[s]
        n_map[s] = L
        L += 1
        return L-1

    G = [[] for i in range(2*N)]
    RG = [[] for i in range(2*N)]
    for i in range(N):
        a, b = readline().strip().split("-")
        ka = get(a); kb = get(b)
        G[ka].append(kb)
        RG[kb].append(ka)

    F = [[-1]*L for i in range(L)]
    for v in range(L):
        for w1 in G[v]:
            for w2 in G[v]:
                F[w1][w2] = 1
        for w1 in RG[v]:
            for w2 in RG[v]:
                F[w1][w2] = 1
    for v in range(L):
        for w1 in G[v]:
            for w2 in RG[v]:
                F[w1][w2] = F[w2][w1] = 0

    G0 = [[] for i in range(L)]
    for v in range(L):
        for w in range(L):
            if F[v][w] == 1:
                G0[v].append(w)
                G0[w].append(v)

    PS = []
    que = deque()
    for i in range(L):
        P = [-1]*L
        que.append(i)
        P[i] = 0
        while que:
            v = que.popleft()
            p = P[v]
            for w in G[v]:
                if P[w] != -1:
                    continue
                P[w] = p^1
                que.append(w)
            for w in G0[v]:
                if P[w] != -1:
                    continue
                P[w] = p
                que.append(w)
        PS.append(P)

    write("%d\n" % L)
    M = int(readline())
    for i in range(M):
        a, b = readline().strip().split("-")
        ka = n_map.get(a, -1); kb = n_map.get(b, -1)
        if ka == -1 or kb == -1:
            write("NO\n")
            continue
        write("YES\n" if PS[ka][kb] == 1 else "NO\n")
    return True
while solve():
    ...