@ilyakor we have done a bit of research about the Indian visa process before coming up with the dates and we are hopeful that we can get the visa within the time frame. Also, we will be communicating with all the global participants (who will be advancing to elimination round) regarding the documentation, this helps us to quickly proceed with the visa process just after the elimination.

Coming to the platform: we have fixed all the issues and looking forward to deliver a great contest.

Hi ilyakor,

Regarding your point of allowing team formation only from same organization, we will take a review over it after the end of this Snackdown, and will decide whether it requires changes.

Primarily, our reason for allowing team formations from same organistion is historic in the sense that we started Snackdown with keeping in mind ACM ICPC preparations for Indian teams. But, now as we invite participants from all over the world and also from various channels, like high school students, university students (both eligible/ineligible for ICPC) and past university students, we are open to changes in this.

We will also have a public opinion regarding whether we should make a fixed/predecided distribution of high school students, university and non-university students in the onsite participation or not.

Thanks a lot for your feedback, ilyakor!!

@zeliboba there is no restriction as such for all the online rounds. For ex: If you and your partner are at two different places during the contest, you can login with your individual accounts and submit on behalf of your team. Coming to the final onsite round each team will be given a single computer to compete.

90 is quite a lot for few :P

Unable to parse markup [type=CF_TEX]

CF Tex is broken: Answer = min(abs(a-b) mod {gcd(c, d)}, gcd(c, d) -abs(a-b) mod {gcd(c, d)}

Let next[i] denote the least value of right endpoint among all segments starting at some index  ≥ i . So for each query , you can find the answer using this array by doing L, R = input() , and then L = next[L] + 1 while L ≤ R and increment answer in each iteration . But this is O(N) . To make this faster , use binary jumping . next[i][j] = the index we will be after jumping 2ⁱ times. With this you can simulate this in O(log(n)) time with O(NlogN) precomputation . Code

I handled the queries offline by sorting the starting points in reverse order with persistant segment trees.For current st,en if en < all en's visited till now ,root[st]=root[en+1] ,otherwise root[i]=root[i+1] where in segment tree I have frequency of all end points. code

My solution: let's implement just two operations:  * 2 and  + 1. Here they are:

•  * 2 <=> {permutation}(M + 2)(M + 1), where M = max({permutation})
•  + 1 <=> (M + 1)...(M + LEN){permutation}, where LEN is the length of LIS of {permutation}

(take a pen and try out some examples here, understanding how and why these operations work is significant)

So we can for any given N we can generate the sequence with N LISes with this recursive function:

list<int> gen(int n) {
  if (n == 1) {
    return { 1 };
  }
  list<int> res = gen(n / 2);
  mulTwo(res); // * 2
  if (n % 2 != 0) {
     addOne(res); // + 1
  }
  return res;
}

But it is not enaugh because the length of the result sequence will be more than 100 in some cases. So let's generalize the operations:

•  * K instead of  * 2
•  + 1,  + 2, ...,  + (K - 1) instead of  + 1

You can do it on your own and check yourself here (sorry for white text, but spoilers don't work with markup):

 * K <=> {permutation}(M + K)...(M + 1)
 + Z <=> (M + Z)...(M + 1) (M + Z + 1)...(M + Z + LEN - 1){permutation}

Now when, for example, K = 7 all result sequences for n = [1, 100000] will fit in 100 numbers.

Time complexity is O(T * log²(N))

How did you came up with the equations in the last problem ?