Zigzag Game
Contest: Forethought Future Cup - Final Round (Onsite Finalists Only)
Difficulty rating: 3500
Tags: games, interactive

You are given a complete bipartite graph with $$$2n$$$ nodes, with $$$n$$$ nodes on each side of the bipartition. Nodes $$$1$$$ through $$$n$$$ are on one side of the bipartition, and nodes $$$n+1$$$ to $$$2n$$$ are on the other side. You are also given an $$$n \times n$$$ matrix $$$a$$$ describing the edge weights. $$$a_{ij}$$$ denotes the weight of the edge between nodes $$$i$$$ and $$$j+n$$$. Each edge has a distinct weight.

Alice and Bob are playing a game on this graph. First Alice chooses to play as either "increasing" or "decreasing" for herself, and Bob gets the other choice. Then she places a token on any node of the graph. Bob then moves the token along any edge incident to that node. They now take turns playing the following game, with Alice going first.

The current player must move the token from the current vertex to some adjacent unvisited vertex. Let $$$w$$$ be the last weight of the last edge that was traversed. The edge that is traversed must be strictly greater than $$$w$$$ if the player is playing as "increasing", otherwise, it must be strictly less. The first player unable to make a move loses.

You are given $$$n$$$ and the edge weights of the graph. You can choose to play as either Alice or Bob, and you will play against the judge. You must win all the games for your answer to be judged correct.

Interaction format:
Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 50$$$). Description of the test cases follows.

Each test starts with an integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of nodes on each side of the bipartition.

The next $$$n$$$ lines contain $$$n$$$ integers $$$a_{ij}$$$ ($$$1 \leq a_{ij} \leq n^2$$$). $$$a_{ij}$$$ denotes the weight of the edge between node $$$i$$$ and node $$$j+n$$$. All $$$a_{ij}$$$ will be distinct.

You first print a string "A" or "B", denoting which player you want to play ("A" for Alice and "B" for Bob).

If playing as Alice, first print either "I" or "D" (denoting whether you choose "increasing" or "decreasing"). Then, print the node that you wish to start at.

If playing as Bob, read in a character "I" or "D" (denoting whether the judge chose "increasing" or "decreasing"), then the node that the judge chooses to start at.

To make a move, print the index of the node that you wish to go to. To read what move the judge made, read an integer from standard in.

If the judge responds with $$$-1$$$, then that means the judge has determined it has no legal moves (or it may have just given up) and that you won the case. Stop processing this case immediately and start processing the next case.

If the judge responds with $$$-2$$$, that means that the judge has determined that you made an invalid move, so you should exit immediately to avoid getting other verdicts.

If you are unable to make a move or give up, print $$$-1$$$ and then exit immediately. This will give you a Wrong answer verdict.

After printing a move do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:

- fflush(stdout) or cout.flush() in C++;
- System.out.flush() in Java;
- flush(output) in Pascal;
- stdout.flush() in Python;
- see documentation for other languages.

Hack Format

To hack, use the following format. Note that you can only hack with one test case.

The first line should contain a single integer $$$t$$$ ($$$t=1$$$).

The second line should contain an integer $$$n$$$ ($$$1 \leq n \leq 50$$$).

The next $$$n$$$ lines should contain $$$n$$$ integers each, the $$$a_{ij}$$$ ($$$1 \leq a_{ij} \leq n^2$$$). $$$a_{ij}$$$ denotes the weight of the edge between node $$$i$$$ and node $$$j+n$$$. All $$$a_{ij}$$$ must be distinct.

The judge will play a uniformly random legal move with this case versus the hacked program. If it has no legal moves left, it will give up and declare the player as the winner.

Constraints:
Time limit: 5.0 s
Memory limit: 256.0 MB

Note:
The first example has two test cases. In the first test case, the graph looks like the following.

In the sample output, the player decides to play as Alice and chooses "decreasing" and starting at node $$$3$$$. The judge responds by moving to node $$$6$$$. After, the player moves to node $$$2$$$. At this point, the judge has no more moves (since the weight must "increase"), so it gives up and prints $$$-1$$$.

In the next case, we have two nodes connected by an edge of weight $$$1$$$. The player decides to play as Bob. No matter what the judge chooses, the player can move the token to the other node and the judge has no moves so will lose.

Example input:
2
3
3 1 9
2 5 7
6 4 8
6
-1
1
1
I 1
-1

Example output:
A
D 3
2
B
2

Editorial:
I first got the idea for this problem from this problem: https://www.codechef.com/problems/HAMILG. There might be an easier version of the problem on a bipartite graph out there somewhere also. Anyways, the solution for the problem is conceptually simple. Find a matching of the graph, and then you can play according to the matching. You don't even need to remember which vertices you've seen before, since the main idea is if your opponent can make a move, then you can too.
The same idea can be extended to this problem. The intuition is to find some matching to show that Bob can always win. It's not clear how to find such a matching directly, so let's look at what properties the matching needs.
Let's call nodes $$$1$$$ to $$$n$$$ the "left" side of the bipartite graph and nodes $$$n+1$$$ to $$$2n$$$ the "right" side
Without loss of generality, suppose Alice choose "increasing" and she placed her token somewhere on the left side.
Now, let's consider what properties a matching needs. Let's take any two edges in our matching, one that connects nodes $$$(w,x)$$$ ($$$w$$$ is on the left, $$$x$$$ is on the right), and the other connects $$$(y,z)$$$ ($$$y$$$ is on the left, $$$z$$$ is on the right).
We want it to be the case that if it is legal for Alice to move from $$$x$$$ to $$$y$$$, then it is legal for Bob to move from $$$y$$$ to $$$z$$$. This way, Bob always can respond by playing according to the matching.
Let's see what this means in terms of edge weights. If Alice can move from $$$x$$$ to $$$y$$$, then that means $$$edge(x,y) > edge(w,x)$$$, since the last edge traversed was $$$(w,x)$$$ and Alice is increasing. We want it to be the case that $$$edge(x,y) > edge(w,x)$$$ implies that $$$edge(x,y) > edge(y,z)$$$. Thus, the matching is bad if and only if there are two edges in the matching $$$(w,x)$$$ and $$$(y,z)$$$ such that $$$edge(x,y) > edge(w,x)$$$ and $$$edge(x,y) < edge(y,z)$$$.
We can solve this with stable marriage. We call the bad case an instability, which happens if $$$x$$$ prefers $$$y$$$ over $$$w$$$ and $$$y$$$ prefers $$$x$$$ over $$$z$$$. We can construct the preference list of the nodes as follows. For each node on the left side, create a preference list of nodes on the right in decreasing order of weight. For each node on the right side, create a preference list of nodes on the left in increasing order of weight.
We now find any stable marriage in $$$O(n^2)$$$ time. It is guaranteed that one exists and has no instabilities. Thus, we've found a matching that guarantees Bob's win.
As a followup, can you devise a strategy that guarantees Alice can beat Bob if Bob makes a non-optimal move?