Previous year champion has a wildcard?

Are you sure?

There are a total of 26 spots in the Finals, including mystic's spot. So if he places in the top 25, the top 26 contestants will all advance to the finals. Otherwise, the top 25 + mystic will advance.

Min-cost-max-flow (the idea isn't very hard, but it'd take a lot of time to explain it in details).

Maximal matching, then adding E? before and L? after, if needed.

I have greedy solution, through it is quite complex

I had simple bruteforce:

Choose 2 starting points then recoursively choose an edge, move the player, remove edge, make recoursive call, then add edge back.

Dynamic programming: D[Hs][Hc][Ss][Sc], where Hs and Hc are starting and current position of Hanaa and similarly Ss and Sc for Sherine. Value is the maximal balance we can achieve if it's currently Hanaa's turn.

For each state we carefully make one turn for Hanaa and one turn for Sherine. Sherine tries to minimize the value of the state we come to, Hanaa tries to maximize. Also we do not forget to separately process states where one of the girls has no way to move (in this case we have similar solution, making the other girl collect as much as she can).

It can be possibly implemented even easier if we'll make turn only for one girl in each DP state, but it was much more clear for me to implement it in such way as I described.

Also the answer is max_Hsmin_SsD[Hs][Hs][Ss][Ss] because Hanaa starts choosing starting position first, and then Sherine will choose the worst position from all possible.

Recursive case analysis worked 2 minutes for me (but I stored tree as a 2D matrix, so it could be more efficient). Iterate over all starting points for A and B, then iterate over all possible moves:

• If A and B are in the same vertex, then iterate over all possible moves for A, then we have independent games, so we can just launch DFS calculating the biggest sum from a child to a leaf for both parts.
• If A and B are in different vertices, then iterate over all possible moves for A. Assume vertice for A is root. Then, if we move in the same subtree with B, we just remove that edge, swap A and B, and recursively call the function. Otherwise, if we move in the different tree, again we have independent cases — remove edge and launch 2 DFS.

This is reasonable, because we make a recursive call only if we move to the same subtree, which can happen exactly once in each function call, so maximum recursive depth will be O(N).

Even if it isn't, you'll be qualified because someone in top-25 definitely will decline invitation.

The e-mail for the invitation for the round was pretty clear that 25 people + mystic would advance, so the 26th is also qualified.

See you in LA! :)