Notice that any number X which divides all the elements of the array also divides the sum of the array. Moreover, the sum is constant after any number of operations.

Therefore, we iterate over all the divisors of the original array, and find the highest divisor which can be the answer.

For checking if X is valid, I found A[i] % X for all A[i], pushed them into an array, sorted them, and then tried to reduce the left ones and increase the ones on the right to minimise the number of operations required.

Code: https://atcoder.jp/contests/abc136/submissions/6699490

They are explained in detail on my blog, but the gist is that for E, we should check whether each factor of the sum of the values in the array is achievable. We can use a greedy strategy to compute the minimum number of moves necessary to make all of our numbers divisible by one of these factors. For F, we use the Principle of Inclusion/Exclusion, along with a segment tree to track some important values. (Full details are on the blog.)

Thanks for the editorial @geothermal

Thanks for quick and well-explained editorial after each Atcoder contest!

Can you help me understand how idea of parity worked in problem D's solution?

You can maintain the prefix and suffix sums of L and R in each grid, while resetting them to $$$0$$$ when the letter in the grid is not the same as the one you want to maintain.

This seems a little bit hard to understand, so code is here:

int prel[MAXN], prer[MAXN], sufl[MAXN], sufr[MAXN], ans[MAXN];
for (int i = 0; i < s.length(); i++) {
	if (s[i] == 'L'){
		prel[i] = prel[i - 1] + 1;
		prer[i] = 0;
	}
	else {
		prer[i] = prer[i - 1] + 1;
		prel[i] = 0;
	}
}
for (int i = s.length() - 1; i >= 0; i--) {
	if (s[i] == 'L') {
		sufl[i] = sufl[i + 1] + 1;
		sufr[i] = 0;
	}
	else {
		sufr[i] = sufr[i + 1] + 1;
		sufl[i] = 0;
	}
}

where the $$$prel,prer,sufl,sufr$$$ arrays denote the prefix and suffix sums.

Then, you can see that if a child wanders to RL, he would always be wandering between these two grids. So a child would go one direction (as the one written in his grid) until he arrives to RL, since $$$10^{100}$$$ is a huge even number, you can assume that the movements fall into a 2-loop, count the prefix and suffix sums and you will know the answer.

Well find the closest opposing character in proper direction (for R, the closest L to right // for L, the closest R to left).

It is easy to see that the child will step there "once".

It is also easy to see that the child will "rotate" there + on its neighbor (before it) ..co in some "RL" substring :)

To see where it will end, simply check the parity of distance.

Good Luck & Wish you a nice day!

https://atcoder.jp/contests/abc136/submissions/6698199

Check if you pass:

4
9 8 8 7

As far as I can tell your code misses the differences offset by equal values.