/** Get an initial set of action parameters associated with an upstream node. */
public TreeMap<String, ActionParam> getInitialSourceParams() {
TreeMap<String, ActionParam> params = new TreeMap<String, ActionParam>();
{
ActionParam param =
new IntegerActionParam("Order", "Evaluates the MEL script in this order.", 100);
params.put(param.getName(), param);
}
return params;
}
int Query() {
int minimum = 100001;
visited = new boolean[V];
Arrays.fill(visited, false);
depth = new int[V];
Arrays.fill(depth, -1);
low = new int[V];
Arrays.fill(low, -1);
parent = new int[V];
Arrays.fill(parent, -1);
articulationPoints = new TreeMap<Integer, Boolean>();
getArticulationPoints(0, 0);
for (Map.Entry<Integer, Boolean> entry : articulationPoints.entrySet()) {
int i = (int) entry.getKey();
if (RatingScore[i] < minimum) {
minimum = RatingScore[i];
}
}
return minimum != 100001 ? minimum : -1;
}
void run() throws Exception {
// for this PS3, you can alter this method as you see fit
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
int TC = Integer.parseInt(br.readLine()); // there will be several test cases
while (TC-- > 0) {
br.readLine(); // ignore dummy blank line
V = Integer.parseInt(br.readLine());
StringTokenizer st = new StringTokenizer(br.readLine());
// read rating scores, A (index 0), B (index 1), C (index 2), ..., until the V-th index
RatingScore = new int[V];
for (int i = 0; i < V; i++) {
RatingScore[i] = Integer.parseInt(st.nextToken());
}
// clear the graph and read in a new graph as Adjacency Matrix
AdjMatrix = new TreeMap<Integer, TreeMap<Integer, Boolean>>();
for (int i = 0; i < V; i++) {
st = new StringTokenizer(br.readLine());
int k = Integer.parseInt(st.nextToken());
TreeMap<Integer, Boolean> g = AdjMatrix.get(i);
if (g == null) {
g = new TreeMap<Integer, Boolean>();
AdjMatrix.put(i, g);
}
while (k-- > 0) {
int j = Integer.parseInt(st.nextToken());
g.put(j, true);
TreeMap<Integer, Boolean> gCon = AdjMatrix.get(j);
if (gCon == null) {
gCon = new TreeMap<Integer, Boolean>();
AdjMatrix.put(j, gCon);
}
gCon.put(i, true);
}
}
pr.println(Query());
}
pr.close();
}
/** Get an initial set of action parameters associated with an upstream node. */
public TreeMap<String, ActionParam> getInitialSourceParams() {
TreeMap<String, ActionParam> params = new TreeMap<String, ActionParam>();
{
ActionParam param =
new IntegerActionParam("Order", "Loads the Houdini scene in this order.", 100);
params.put(param.getName(), param);
}
{
ActionParam param =
new StringActionParam(
"MergePattern",
"Specifies the pattern used to select the components to be merged into the "
+ "current scene.",
"*");
params.put(param.getName(), param);
}
return params;
}
void getArticulationPoints(int i, int d) {
visited[i] = true;
depth[i] = d;
low[i] = d;
int childCount = 0;
boolean isArticulation = false;
for (Map.Entry<Integer, Boolean> entry : AdjMatrix.get(i).entrySet()) {
int ni = (int) entry.getKey();
if (!visited[ni]) {
parent[ni] = i;
getArticulationPoints(ni, d + 1);
childCount++;
int low_i = low[i];
int low_ni = low[ni];
int depth_i = depth[i];
if (low_ni != -1 && depth_i != -1 && (low_ni >= depth_i)) {
isArticulation = true;
}
if (low_i != -1 && low_ni != -1) {
low[i] = Math.min(low_i, low_ni);
} else if (low_i == -1 && low_ni != -1) {
low[i] = low_ni;
} else if (low_i != -1 && low_ni == -1) {
low[i] = low_i;
}
} else if (ni != parent[i]) {
int depth_ni = depth[ni];
int low_i = low[i];
if (low_i != -1 && depth_ni != -1) {
low[i] = Math.min(low_i, depth_ni);
} else if (low_i == -1 && depth_ni != -1) {
low[i] = depth_ni;
} else if (low_i != -1 && depth_ni == -1) {
low[i] = low_i;
}
}
}
int parent_i = parent[i];
if ((parent_i != -1 && isArticulation) || (parent_i == -1 && childCount > 1)) {
articulationPoints.put(i, true);
}
}
