I think it's O(N²log(N)). You should use some unordered hash to avoid sorting!

The basic idea is to get the unique string of parentheses that represents the tree, for example: (()()) is a binary tree. But instead of sorting and returning large strings as we sort the children's strings, concatenate them, and add two characters each time, we may map each string into an ID, this way we return only one integer.

() will have the ID 0.

0,0 -which is (()())- will have the ID 1.

Two rooted trees are isomorphic if they have the same ID. The following function returns the ID of the tree rooted at a starting vertex.

int ID=1;
map<vector<int>,int> mp;
int DFS(int u,int parent){
   vector<int> ret;
   for(int i=0;i<graph[u].size();++i)
      if(graph[u][i]!=parent)
         ret.push_back(DFS(graph[u][i],u));
   sort(ret.begin(),ret.end());
   int &id=mp[ret];
   if(id==0)
      id=ID++;
   return id;
}

Instead of using a map, you may use hashing.

I will call sum of weights of edges on the path weight length of the path and amount of edges on the path edge length of the path.

For every path between vertices we can calculate probability that its weight length will be added to the answer (for path of edge length l it is (because this path counts iff the vertex on it that gets deleted first is one of the ends)). Now we do n bfs-es and sum for all unordered pairs of different vertices (also you should not forget to multiply answer by n!).

Unfortunately, the problem is you are from Russia and it's not possible to deliver t-shirts there. Sorry on behalf of the t-shirt vendors.

You don't need probability for this problem. Just precalculate distance and no. of nodes between every two nodes.

Then precalculate the number of permutations for a particular value 'd' such that the permutaions between two fixed nodes ( having 'd' nodes between them on the path in the tree ) has none of those nodes before the two fixed nodes in that permutation.

eg: if nodes 2 and 3 have d=2 nodes between them in the given tree {4,5}, and N = 5, then some of the valid permutations will be 12345, 21345, 32415, etc. Basically, {4,5} won't come before neither 2 nor 3 in the permutation.

Then ans += permutations[ nodes_between_path[u][v] ] * dist[u][v]

Chicken McNugget Theorem

https://en.wikipedia.org/wiki/Coin_problem

Almost answers your question. If gcd(a, b) = c > 1, then d must be divisible by c, and you can reduce it to a problem with gcd(a, b) = 1.

it can be done with Diophantine_equation

can you share the code?

Print the value of m, I think it's 1 and you are accessing a[1]. But that is not initialized.

Good day to you.

Well you have a tree — you know nothing about — and you have to determine a point which is similar for all such trees == centroid(s).

You would have to determine such point (any other) /or/ do it for all points.

Good Luck & Have Nice Day! :)