anton is the best setter

It seems like we cannot sign up on the Eolymp platform currently. I hope this issue is resolved ASAP.

Thanks for the interesting contest... now to wait two years to hear about who proceeds to WF!

Is anyone able to sign up on the platform? Also why is the mirror not on CF instead? Probably would have been much easier to both participate and prepare the contest that way.

How to solve N?

Is there any solution to Gears which does not require hashing?

For E, can someone please help me understand why this dynamic programming approach is incorrect.

Sorting the array and storing the indices in which these appear in the original array. If at any index 2*i-1 and 2*i, the elements weren't paired originally then we pair them, otherwise we either pair the elements at indices 2*i-1, 2*i with 2*i-3,2*i-2 or 2*i+1,2*i+2. Code: https://codeshare.io/6p9pmg

Thanks!

What is the intended solution for D? Will there be an editorial?

The official editorials have just been finished (sorry for the delay). They will also be available in the Gym contest when it gets uploaded.

https://drive.google.com/file/d/1MS0R9gT6XGpM_R1DIslzvhQ-MCMR4tIV/view?usp=sharing

Very nice problems, I liked them very much. Although I've seen K already several times. For example on Petrozavodsk two years ago (graph was presented as the thin grid there though, but that does not change anything), but even there I already thought that it's known. At least this time it took me 17 minutes to solve from scratch, unlike half of the contest like on Petro xd. And I think D&C approach is definitely easier to think of and to code than the one from the editorial.

M: I think it is a bit cleaner if we binary search using Stern-Brocot tree. No doubles, no rounding, just one phase solution, same complexity (although my code is worse by log factor since I binary searched instead of solving quadratic inequality).

L: Much more natural approach would be to compute dp from left to right, but it does not work that well, because then we would need to wrap it with binary search on the starting health on top. I think it is good to emphasize how clever is reversing that and why is it needed, but it was not present in the editorial. Also, when I was solving this and tried to optimize the needed convolution I got the "convex hull" idea, but couldn't get rid of a log from the inside of it which I needed to intersect two functions, but you claim in the editorial that it could be done without that log. Could you elaborate?

EDIT: OK, I found this editorial https://mirror.codeforces.com/blog/entry/98663 . The answer is SMAWK xd. Though based on recent blog about it I am not sure if this will help :P

Also, it's funny to see the scoreboard snowball effect and for example how C turned to be one of the easiest for CF participants, but one of the hardest for onsite participants.

Btw "I will add results of official participants soon." — that was not done

Hello antontrygubO_o, maybe there is a mistake in the editorial of problem D. In the last case, $$$(2, 2, 2)$$$, you showed that it's not able to switch the parity only if the parities of degrees of $$$2, 3, 4$$$ are all equal and of $$$1, 5$$$ are opposite. It is right, but potentially incomplete. Assume a component that $$$k \ge 3$$$ vertices $$$u_1, u_2, \cdots, u_k$$$ instead of $$$2, 3, 4$$$, satisfing the condition (the parities of $$$u_1, u_2, \cdots, u_k$$$ are all equal). It seems that we cannot switch the parity no matter what the value of $$$k$$$ is. One of the scenarios I described is shown below:

This is a code that enumerats spanning trees written by dcmfqw. It shows that the answer for the case above is NO.

#include <bits/stdc++.h>
using namespace std;
#define rep(i, d, u) for(int i = d; i <= u; ++i)
#define dep(i, u, d) for(int i = u; i >= d; --i)
#define cep(n) while(n--)
#define gep(i, a) for(int i = firs[a]; i; i = neig[i])
int ured() {
	int re = 0;
	char ch;
	do {
		ch = getchar();
	} while('9' < ch || ch < '0');
	do {
		re = re * 10 + (ch ^ '0');
	} while('0' <= (ch = getchar()) && ch <= '9');
	return re;
}
void uwit(int da) {
	int ch[21], cn = 0;
	do {
		ch[++cn] = da - da / 10 * 10;
	} while(da /= 10);
	do {
		putchar('0' ^ ch[cn]);
	} while(--cn);
}
const int _maxn = 200011;
int t, n, m, u[_maxn], v[_maxn], fath[_maxn], cnts;
bool visi[_maxn], pdif, indu[_maxn];
int find(int at) {
	return fath[at] == at ? at : fath[at] = find(fath[at]);
}
void dfs1(int at, int cn) {
	if(cn == n - 1) {
		rep(i, 1, n) {
			fath[i] = i, indu[i] = 0;
		}
		rep(i, 1, m) {
			if(visi[i]) {
				if(find(u[i]) == find(v[i])) {
					return;
				}
				fath[find(u[i])] = find(v[i]), indu[u[i]] ^= 1, indu[v[i]] ^= 1;
			}
		}
		cnts = 0;
		rep(i, 1, n) {
			cnts += indu[i];
		}
		if(!(cnts % 4)) {
			pdif = 1;
		}
		return;
	}
	if(at == m + 1) {
		return;
	}
	visi[at] = 1, dfs1(at + 1, cn + 1), visi[at] = 0, dfs1(at + 1, cn);
}
int main() {
  t = ured();
	cep(t) {
		n = ured(), m = ured();
		rep(i, 1, m) {
			u[i] = ured(), v[i] = ured(), visi[i] = 0;
		}
		pdif = 0, dfs1(1, 0);
		if(pdif) {
			puts("YES");
		} else {
			puts("NO");
		}
	}
	return 0;
}

192601989 this is a code also written by dcmfqw, following the approach I have described above.

I didn't find this case in your category discussion above. Maybe I misunderstood, but this hack does exist.

So is it your mistake? Or just where I did not see clearly?

Please forgive my poor English XD