^

You can't take $$$0$$$ as a digit in the number.

For t <= 62, you can imagine finding value on a binary tree. It the ith bit of k is 0, go left, else go right; For t > 62, since we have a tons of leading zeros in k (0000...), we can do binary lifting. Submission

What I did:

First find out, which is the letter from the original string, that creates the block in which the char from the query will lie. This is realpos = pos / (1ull << it). Then determine the position inside this block, where the query will be. This is innerpos = pos % (1ull << it). (Special case for more than 63 iterations has to be implemented.)

Now we know the letter from the original string. We take that as a base $$$B$$$. Instead of "A->BC, B->CA, C->AB." I will use "A->AB, B->BC, C->CA." now. To account for this change we add the number of iterations to $$$B$$$.

Now we need to consider the innerpos. Which letter will be at this position? This hapens to be the count of set bits in innerpos in binary. So we just need to add __builtin_popcountll(innerpos) to $$$B$$$.

Then $$$B$$$ is the answer. https://atcoder.jp/contests/abc242/submissions/29884835

Same dude, I was able to solve $$$G$$$ because of that, but not $$$F$$$.

Yes, that was also exactly my experience! Didn't want E, couldn't F, saw G. Never did Mo before but it so much looked like Mo, so I had to do it.

I forgot to change the block size in my first submission in problem G but in fact, block size of 32 ran faster than 750. I don't know the reason why the solution was accepted...

you can write $$$E[X] = P(X \gt 0) + P(X \gt 1) + P(X \gt 2) + \cdots $$$

$$$P(X \gt k)$$$ is just the probability that the process is not completed in $$$k$$$ steps.

To calculate probability that the process isn't completed in $$$k$$$ steps, We can use inclusion-exclusion. That is P({1} isn't covered in $$$k$$$ steps) + P({2} isn't covered in $$$k$$$ steps) +...- P({1,2} isnt covered in $$$k$$$ steps)-P({1,3} isn't covered in K steps)-... + P({1,2,3} isnt covered in $$$k$$$ steps) + ...

You can formally write it as : For each nontrivial subset $$$S \subseteq [1,\cdots,n]$$$ , let $$$j$$$ be the number of segments which don't intersect with $$$S$$$, add ($$$(-1)^{i+1}(\frac{j}{m})^k$$$ to the answer. Summing over all $$$k$$$ , we only need to calculate $$$(\sum_{k=1}^{k=\infty} (\frac{j}{m})^k)$$$ for every subset $$$S \subseteq [1,\cdots,n]$$$, You can use a dp to calculate number of ways to select a subset of $$$[1,\cdots,n]$$$ with size $$$i$$$ which have $$$j$$$ segments not intersecting with it.Solution

Just use mo's algorithm. Whenever you add a number to a range, check if the count of the number is odd, and if so add one to the answer. Similarly, whenever you erase a number from a range, check if the count of the number is even, and if so remove one from the answer.

My solution involves two steps, first calculating dp[r][c][k], which represents the number of possible covering of r x c with k rooks of a same color without leaving a row nor column empty, and then the second step was just simply iterating through number of rows and columns for black rooks and white rooks, and adding the value $$$dp[r_b][c_b][b] \times dp[r_w][c_w][w] \times {n \choose {r_b}} \times {n-r_b \choose {r_w}} \times {m \choose {c_b}} \times {m-c_b \choose {c_w}}$$$ for each $$$r_w, r_b, c_w, c_b$$$.

Simple problems of advanced tricks are often easier if you already know the technique.

Wow, that must've felt like an achievement and hurt at the same time! Definitely something to talk about, for sure.

You should modify stack size on your local device. Recursion sometimes give RE with not enough stack size.

Try enumerating the first half of the palindrome.

Since the last heuristic contest they've experienced server overload (or something like that) so sometimes they disabled ranking page. There also has been postponed contest around last week or two. I assume this functionality is temporarily disabled to cut performance cost, tho I'm not sure.