We are observing class declarations in an obje\(ct-or\)iented programming language similar to C++. Each
class declaration is of the form “\(K\) : \(P\)1 \(P\)2 . . . \(Pk\) ;” where \(K\) is the name of the new class being
declared, and \(P\)1, P2, . . . , P\(k\) the names of classes being inherited by class \(K\). For example, “shape :
;” is a declaration of class “shape” that does not inherit any other class, whereas “square : shape
rectangle ;” is a declaration of class “square” that inherits classes “shape” and “rectangle”.
If class \(K\)1 inherits class \(K\)2, class \(K\)2 inherits class \(K\)3, and so on, up to class \(Km - 1\) that inherits class \(Km\),
then we say that all classes \(K_{1}\), K_{2}, . . . , K_{m}{−} are derived from class \(K_{m}\). The rules of the programming
language forbid circular definitions, so it is not allowed to have a class derived from itself. In other words,
the class hierarchy forms a directed acyclic graph. Additionally, it is not allowed for a \(so-ca\)lled diamond
to appear in the class hierarchy. A diamond consists of four different classes A, B, X, Y such that it holds:
• Classes \(X\) and \(Y\) are derived from \(A\).
• Class \(B\) is derived from both \(X\) and \(Y\) .
• Neither is class \(X\) derived from \(Y\) , nor is class \(Y\) derived from \(X\).
A
X
Y
B
Figure 1: A diamond
shape
circle
square
rectangle
runnable
thread
object
Figure 2: The hierarchy after processing all declarations from
the first sample test
You are given a series of class declarations to be processed sequentially, and determine for each one
whether it is correctly declared. The correctly declared classes are added to the hierarchy, while the
incorrect ones are discarded. Declaration “\(K\) : \(P\)1 \(P\)2 . . . \(Pk\) ;” is correctly declared if the following holds:
1. Class \(K\) hasn’t been declared yet.
2. All classes \(P\)1, P2, . . . , P\(k\) have been previously declared. Notice that this condition ensures that a
class can never be derived from itself, or that cycles cannot exist in the class hierarchy.
3. By adding class \(K\) that inherits \(P\)1, P2, . . . , P\(k\) the class hierarchy remains in order, that is, not a
single diamond is formed.
Write a programme that will process the declarations respectively as described above and determine the
correctness of each one of them.

Subtask
Score
Limitations
1
13
\(1 \le n \le 100\), the correctness can be determined by considering only condition 1.
2
14
\(1 \le n \le 100\), the correctness can be determined by considering only conditions 1 and 2.
3
29
\(1 \le n \le 100\).
4
44
\(101 \le n \le 1\,000\).

The first line of input contains the integer \(n\) – the number of declarations. Each of the following \(n\) lines
contains a single declaration in the form of “\(K\) : \(P\)1 \(P\)2 . . . \(Pk\) ;” where \(P\)1, P2, . . . , P\(k\) is a series of zero,
one or more classes that class \(K\) inherits. All class names in a single declaration K, P1, P2, . . . , P\(k\) are
mutually different. Each class name is a string of at most 10 lower case letters of the English alphabet.
All the elements of a declaration (the class names and characters “:” and “;”) are separated by exactly
one space. In each specific declaration, for the number of classes \(k\) it holds \(0 \le k \le 1\,000\).
1 od 8

You must output \(n\) lines. The \(i^{th}\) line must contain “ok” if the \(i^{th}\) declaration is correct, and “greska” if
it isn’t.

생성자가 기록되지 않았습니다.

출처 COCI 2015/2016 Olympiad