Oops, I was wrong, we should fix the order of vertices, not edges. I'll try to explain more clear.

Suppose we have some graph. Let's build it spanning tree adding edges in order (0, 1), (0, 2), ..., (0, n-1), (1, 2), ..., (n-2, n-1) (of course edge is added only if it's presented in graph and if it does not make a cycle). This is what I called lex-min MST. Clearly, all connected graphs are split into equivalency components such that lex-min MST of all graphs from one component is the same.

Now, let's fix some spanning tree with edges e₁, ..., e_n - 1. count number of graphs with such lex-min MST. What can we say about such graphs? We know that edges e₁, ..., e_n - 1 must be in the graph. More, for some other edges we know that they must not be in the graph, because otherwise lex-min MST would be different.

So we have a problem: for each edge we either must include it, or must not, or this edge does not matter. In terms of problem it means that we should take a linear combination of input graphs such that on some positions there are 1-s and on some there are zeros. How to count them? Remove all columns corresponding to edges which we don't care for. Now check using Gauss method if we have at least one way to make this linear combination. If yes, total count is 2^m - r, where m is the number of vectors (input graphs) and r is the rank of matrix with selected columns.

The answer for the problem is sum of answers for all permutations of n vertices. Thus overall complexity is O(n^n - 2·mn²) (because there are n^n - 2 trees on n vertices). It probably won't fit into time limit so we should build trees recursively and do Gauss steps one by one in recursion.

Intended solution was to count for each partition number of subsets where there is no edges between different part. Then you can calculate the answer using exclusion formula.

LCS is always n - 1, so you need to move one character so that the new string is also correct and it differs from original string. You can store all these strings in a set and the answer will be the size of the set.

For each red player, find the maximum time till which it can play the game. To do that,Let

dB[i] = Min time in which any player B can reach node i
dA[i] = Time in which current red player under consideration can reach node i.

ans = INF
for every node u in A
   compute dA[] for node u
   currmax = 0
   for i in 0 to n
      if dA[i] < dB[i]  //Assume player u comes to this node and stands here till game ends
          currmax = max(currmax,dB[i])
   ans = min(ans,currmax) 

We basically try to find the minimum time till which all the red ones can survive in the game . To that for each red player we find the max time till which it can play the game and take min over all these.

My idea is:We want to focus on a single red token,it doesn't matter a set of them,just one,so all blue tokens can focus on it and catch it.

Ok.Now for this red token,we want a path so it resists maximal time.How does this path look?Like a normal path,because if we go on an edge,and come back from it,it's like staying.

Good,so we fix a node to go (i is red token,j is final node).Now we also want to see if the red token,on it's way ,is safe(no blue token catches it before reaching j).

This can be done with some array(dp[x]=minimal time for a blue token to reach x).And then for every node on path(excluding j,cuz already we want to catch i on j) we compare time[i][x] with dp[x].

Taking into account all GOOD possible paths for i,we want the one with maximal time(to resist more).Take care that for a path(i going to j),the time to catch i is dp[j].

Also from all red tokens,we choose one that we can catch fastest.

Complexity O(n^3).

Lcs is 5 in correct answers

What does mean CL(dp, 0); in your code?