Oh I see, thanks for letting me know.

It depends on the contest but for this one, you have only 20 mins left to try.

Also note that if you unsuccessfully hack the code there might be a penalty, so only do it if you're sure the defender's code is truly exploitable.

Sure, look here: https://codeforces.me/blog/entry/6249

In short, the open hacking phase is the (12-hour) period after some contests where people try to break other's solutions for more points. If your solution is absolutely correct, you won't have to worry about being hacked. On the other hand, is there is a subtle bug in the program, someone might want to exploit it to break your program for extra points.

There is a 12 hour open hacking phase that ends in an hour and a half, then it takes a few hours after that for the rating to update.

Ah I've read it wrongly, sorry my bad.

I'm not experienced in Java, sorry, but I'm wondering if it's because hashmaps can't store multiple copies of the same object. Some participants can have the same scores and penalty.

Also, I just managed to find time today so I wrote a small explanation here: https://codeforces.me/blog/entry/117727?#comment-1042026

Hope it might help you understand it better, feel free to ask if you need more clarifications.

Your link isn't accessible by the way.

How I visualized it is like this: consider first the $$$m=1$$$ case. Obviously what we do is check every digit $$$d_1$$$ between $$$l_1$$$ and $$$r_1$$$. If $$$d_1$$$ does not appear at all in the string $$$s$$$, then we output "YES" because $$$d_1$$$ will definitely work. Otherwise if no such $$$d_1$$$ exists then there is no viable value for $$$d_1$$$, whence we cout "NO".

Now let's try the $$$m=2$$$ case. For the first digit $$$d_1$$$ we do the exact same as above, but this time even if every possible $$$d_1$$$ between $$$l_1$$$ and $$$r_1$$$ appear, we might still be able to generate a valid passcode if $$$d_2$$$ doesn't appear in the string $$$s$$$ after $$$d_1$$$ does. To maximize the possibly of this happening, we will try to pick the first occurrence of $$$d_1$$$ to be as far right as possible, so that there is less digits of $$$s$$$ that can block $$$d_2$$$ from succeeding.

But how do we do this? The $$$\mathbf{nxt}$$$ array is what comes into play here. Let $$$\mathbf{nxt}$$$ be a $$$10$$$ by $$$|s|+1$$$ array such that $$$\mathbf{nxt}[i][j]$$$ is the (1-based) position of the next occurrence of the digit $$$i$$$ after position $$$j$$$ in $$$s$$$, or INF if no such position exists. (Long sentence, sorry.) Then the algorithm will be something like this:

j = 0 // initially we start having no digits of s covered
for every d1 from l1 to r1
    if nxt[0][j] is INF // then we are done!
        print "YES" and finish

j = max {nxt[d1][j] | l1 <= d1 <= r1} // jump as far right as possible
for every d2 from l2 to r2
    if nxt[0][j] is INF // then we are done!
        print "YES" and finish

print "NO" and finish

This now obviously generalizes to any positive $$$m$$$, I trust you can carry on the analysis from here :)

edit: minor typos, sorry

Sure, https://open.kattis.com/problems/colorland

If you know the problem colorland in Kattis, this problem is similar to that, you build an implicit graph from the start of the string to an "INF" node and see if there is a path of length <=m from left to right. (Note: you can greedily jump as far as possible!) You could maybe see my solution for more clarification.

If you're given for example

and

we see that the red part (the longest common prefix) contributes $$$0$$$, the blue part (the first digit where $$$L$$$ and $$$R$$$ differ) contributes at most $$$8-6=2$$$, and for the green part (the rest), we can pick $$$9999999$$$ for $$$L$$$ and $$$0000000$$$ for $$$R$$$ (because whatever you set, the blue part ensures the first number is already smaller than the second). Thus the answer is always