Exactly

Being slightly partisan here, but DMOJ will be hosting monthly IOI-oriented contests called DMOPCs. Also there exists the CEOI and BOI, etc. (google/yandex/baidu search is your friend). See this for a full list.

Sure

tomorrow

No. There was feedback for only samples at the last one I participate in :(

It's not just you.

But we have problems , what if most of us solves 4 or 5 or all problems in extended time.

best idea: wait until submitting is open , meanwhile solve other problems

use maps as if they were normal arrays , it shouldn't make implementation much worse

same here ! i implemented the 25% solution instead of the whole one because i got bored manipulating maps !

Nah. Notice that for a field to be attacked, the xor of its row and column must be different. It's just map juggling to maintain and update the xors of rows/columns, then you should store the number of rows and of columns with a given xor in another map and the answer is found as N² minus the number of fields which have equal xor of row and column. And again some map juggling to update those values efficiently.

Due to earlier technical problems the results page will be available tomorrow. Many submissions are still in the judging queue and need to be evaluated.

Again, sorry for the inconvenience.

F: notice that for each guy we can calculate his possible left and right bounds independently. Take a vertex x, sort it's children by V[i].

Suppose that we want to find all the left bounds for x. In the beginning, the only left bound is V[x]. Iterate through the children from right to left, starting from the first child i that has V[i] < V[x]. If a child has one of it's right bounds in the position of one of x's left bounds minus 1, we can add all of this child's left bounds to x's left bounds.

Hope this isn't too unclear >_<

I'll try to explain in detail. subsequence=consecutive elements.

One observation is:a subsequence that is invited from subtree of x can be seen as leftpart+val[x]+rightpart. So you can do left and right subsequences independently. You can store left[x][i]=1 if you can invite from it's subtree some people with jokes from interval[i,val[x]], right[x][i]=1 for interval[val[x],i].

Now it comes the hard part.Let's solve left parts.If you imagine how a left part could be made out of smaller subsequences,and also that in every subsequences there is surely val[y](y a direct son),you should sort sons by val[y],and start your dynamic with sons from val[x]-1 to 1.

Why it is better than random?Because a son can help to make a left part if we already traversed sons with value > current.Just imagine what I said earlier,how a left part is composed of subsequences.

Now we fix a st[x][i] which ==0 and try to make it.This implies st[current_son][i]==1. Also we fix j (i<j<=val[x]) and if st[x][j]==1 and dr[curr_son][j-1]==1,we can make this left part with left end in i.To imagine it,we add subsequnce of curr_son made from i to j-1 with left part already done from j to val[x].

Complexity(N*VAL_MAX*VAL_MAX),but is better in practice.Memory O(N*VAL_MAX),and it can be stored as bool or bitset.

Right part is similar.Hope I helped:)

I have full score with almost the same complexity, except I build the segment tree in O(c^2 * n).

And another thing is that in each update I do MOD operation only c times, not c^2.

Yes, it is possible to avoid division:

http://ideone.com/nd4dDL

Contest is now in the analysis mode, so you can continue submitting solutions.