+1 to that. I find this situation pretty ridiculous. An obvious solution would be just not to wait a whole week to host the mirror.

Due to the popular demand we have now published the official results here, but without the task-wise scores for now. Unfortunately, this took longer than expected due to organizatorial issues.

However, we also feel that the wording of your message was somewhat disrespectful and that your request could have been phrased more politely.

I tried some greedy + dp, but had only one hour for that problem... Tried to first take all elements, and then remove largest elements until sum <= L, and then try to add one element and do dp[S] -> max number of elements resulting with sum S. Probably not correct : )

They already did, https://contest.boi2022.uni-luebeck.de/ranking/

Sort all events by their end time and then for every event $$$i$$$ find range $$$[L_i, R_i]$$$ such that for every event $$$j, L_i \le j \le R_i$$$ you can jump from $$$j$$$ to $$$i$$$, and with that you can use binary lifting to find number of jumps to reach other event.

Ah, this did indeed seem like a problem that could have appeared previously, but nobody in the SC was aware of this.

Also, as a small challenge to everyone, we are not yet sure what the optimal solution to this problem is. We know of a solution that uses only $$$N-1$$$ queries, but maybe someone can do better? (For $$$N$$$ sufficiently large)

You should be able to download spoilers in the analysis mode which runs for 5 hours after each mirror, but we will also publish spoilers and test data on the website after both mirrors are over.

You can encode the 3 possibilities of X as 0000, 1111 and 0110. For 0000, the received sequence while decoding cannot have two consecutive 1 bits. For 1111, there cannot be two consecutive 0 bits. For 0110, there must be some consecutive equal bits. So, you can eliminate at least one possibility and return the other two.

I solved it with randomization.

The key idea was to use the same seed while using mt19937 function for both encode and decode.

For N = 3, we need to send two bits, let's call them b1 and b2 respectively.

We will send a boolean vector sized 250, each of the indexes could represent one of the following things:

1. it could be b1
2. it could be b2
3. it could be some random bit

vector < ll > v(250, -1);
    vector < ll > b1, b2;
    mt19937 rng(K);
    for(ll i = 0; i < 250; i++){
        if(rng()%3 == 1 && (!i || v[i - 1] == -1) ){
            mx--;
            v[i] = rng()%2;  // random bits
        }else{
            if(rng()%2) b1.pb(i);
            else b2.pb(i);
        }
    }
    for(auto u : b1) v[u] = (1 << 0) & X;
    for(auto u : b2) v[u] = (X >> 1) & 1;
    for(auto u : v) send(u);

We could simulate the same while decoding. So while decoding,

If i_th number is a random bit, we would know what is the actual value of that bit and what we recieved. If they differ, then we would know for sure that i-1 th & i+1 th number is exactly what we sent (Those indexes would represent b1 or b2).

So, if the number of changes while sending the bits are frequent then we can easily figure out X.

Otherwise, we can assume the most of the bits we sent have sent aren't changed that much. So in this case, we can naively depend on the occcurences of 0 or 1 in the indexes of b1 for figuring out first bit, and the same for the 2nd one.

Full code: https://ideone.com/diqCci

There's a solution that uses at most 3 bits:

For the first bit, encode() sends 1 if $$$n=3$$$ and 0 otherwise. Then there are two scenarios:

• If judge sends 1, encode() sends a second bit: 1 if $$$n=1$$$ and 0 otherwise. If judge sends 1, then decode() knows that $$$n$$$ cannot be 2, since that would mean encode() sending 00 and the judge sending the wrong bit twice in a row. Similarly, if judge sends 0, then decode() knows that $$$n$$$ cannot be 1.

• If judge sends 0, encode() sends the same bit as the first one again. If judge sends 0 again, then decode() knows that $$$n$$$ cannot be 3, using the same reasoning as above. Otherwise, encode() does the same as the above case for the third bit.

In any case, decode() can eliminate one possibility and return the other two.

void encode(int n, int x) {
	if (n!=3) return;
	int v;
	if (x==1 || x==2) v=send(0); else v=send(1);
	if (v==0) {
		if (x==1 || x==2) v=send(0); else v=send(1);
		if (v==0) {
			return;
		} 
		else {
			if (x==1) v=send(0); else v=send(1);
			return;
		}
	}
	else {
			if (x==1) v=send(0); else v=send(1);
			return;
	}
}

pii(int) decode(int n) {
	int v;
	v=receive();
	if (v==0) {
		v=receive();
		if (v==0) return {1,2};
		else {
			v=receive();
			if (v==0) return {1,3}; else return {2,3};
		}
	}
	else {
		v=receive();
		if (v==0) return {1,3}; else return {2,3};
	}
}

That was an interesting bug on our side that we hadn't experienced before... The scoreboard should now be correct :-)

Let dp[mask] be answer if we have this subset of groups. Now transition will be, dp[mask] = min_{mask&(1<<j)==true} dp[mask^(1<<j)]+cost[mask][j].How we can calculate cost? We can notice than if we have some groups already in place, when adding new group it's optimal to get some prefix of places from the left, and everyone else from the right. We can brute force the division point and calculate the cost, then tak minimal. To get full score notice than this function is convex, so you can binary search for best division point. To calculcate answer fast, you can use prefix sums, one prefix sum array for each group that is already in place, so you have to compute pref sums only once for every group you are calculatin cost for, and then just use it to find answer for every mask.

lumibons upsolving/tasks/test data uploaded when?

Hopefully, with the test data now finally having been published, the tasks might soon be available on some online judges. Until then, you can use the task data from the website to test the correctness of your program yourself.