This is a very straight forward problem. Just add 1 to a year number while it still has equal digits.

Precalculate the next prime for every integer from 1 to 10^{5}. You can do that in any way. The main thing is to test all the divisors up to square root when you are checking if a number is prime.

Now for each *a*_{ij} (element of the given matrix) we can easily calculate *add*_{ij} — how many do we have to add in order to make *a*_{ij} prime. After that all we need to do is to find row or column with minimal sum in this new matrix.

If 3*k* > *n* there is no solution (because each of the *k* sets must have at least 3 elements). Otherwise we can divide first 3*k* words in the following way:

`1 1 2 2 3 3 ... k k 1 2 3 ... k`

For each of the *k* sets, the difference between the first and the second elements will be 1. And the difference between the second and the third elements is definitely not 1 (more precisely, it is 2*k* - *i* - 1 for the *i*-th set). So each set doesn't form an arithmetic progression for sure.

For this solution it doesn't matter how we divide the rest *n* - 3*k* words.

At first, build a trie containing all suffixes of given string (this structure is also called explicit suffix tree). Let's iterate over all substrings in order of indexes' increasing, i. e. first [1...1], then [1...2], [1...3], ..., [1...*n*], [2...2], [2...3], ..., [2...*n*], ... Note, that moving from a substring to the next one is just adding a single character to the end. So we can easily maintain the number of bad characters, and also the "current" node in the trie. If the number of bad characters doesn't exceed *k*, then the substring is good. And we need to mark the corresponding node of trie, if we never did this before. The answer will be the number of marked nodes in the trie.

There is also an easier solution, where instead of trie we use Rabin-Karp rolling hash to count substrings that differ by content. Just sort the hashes of all good substrings and find the number of unique hashes (equal hashes will be on adjacent positions after sort). But these hashes are unreliable in general, so it's always better to use precise algorithm.

It could be proved, that a card (*x*, *y*) (*x* < *y*) can be transformed to any card (1, 1 + *k*·*d*), where *d* is the maximal odd divisor of *y* - *x*, and *k* is just any positive integer. So every (*a*_{i} - 1) must be divisible by *d*, i. e. *d* is a divisor of *gcd*(*a*_{1} - 1, ..., *a*_{n} - 1), and we can just iterate over all possible divisors. Let's take a look at all the initial cards (*x*, *y*), which have have *d* as their maximal odd divisor: these are cards with *y* - *x* equal to *d*, or 2*d*, or 4*d*, 8*d*, 16*d*, ... Don't forget that the numbers *x* and *y* must not exceed *m*. It means that the total number of cards with some fixed difference *t* = *y* - *x* is exactly *m* - *t*.

The resulting solution: sum up (*m* - 2^{l}*d*), where *d* is any odd divisor of *gcd*(*a*_{1} - 1, ..., *a*_{n} - 1), and *l* is such, that 2^{l}*d* ≤ *m*.

Is there any background in problem E?

In 4rth q after so many TLE's I have drawn an inference that generally map is slower than set though both being dynamic memory allocation....

I'm quiet new in Java,I keep getting TLE and use trie data structure,any advises?(Though the same code written in C++ got AC) code

It's not because you use Java, it's because you make a lot of substring() calls.

Thanks,so is there a faster way to remove the first character from string?Or i should use array of chars instead of strings or something like that

Just remember where the string really begins.

Yup thanks got it

i m not getting the problem E' editorial can any one explain ?

Here is the proof for the solution given in the editorial.

For problem 4, suffix array with lcp can also be used. We can first pre-compute the bad character count for all the substrings and store it in a table. Then, iterating through the suffix array and avoiding duplicate substrings using the lcp table, we can find the answer.

Hello. I am having trouble with the problem D (getting TLE). I am using the trie to solve the problem. When I build it, I already keep track of the current number of bad characters. If it is bigger than

k, I leave the recursion. The final answer is the number of nodes of the tree.Could anyone help me please? What am I doing wrong? Code

Why do you have these 2 nested loops in main() function? You are not really using

`i`

anywhere.OMG, thanks RAD. It was something I was trying and forgot to remove.

Problem C: in each set Ui, its elements ui, 1, ui, 2, ..., ui, |Ui| do not form an arithmetic progression (in particular, |Ui| ≥ 3 should hold). What's the meaning of it ? Does it means when Ui < 3 there is no necessary to hold this condition ?

Can you tell me what's wrong of my code ? Problem D: 3145554

Complexity

I don't think so, I learned from this AC submission? Why his is ok ? 3105181

Try to find out what is the complexity of string comparisons

Somebody can help me prove

that a card (x, y) (x < y) can be transformed to any card (1, 1 + k·d), where d is the maximal odd divisor of y - xin problem "Three Horses"? Thank youProblem D 271D - Good Substrings : This is my code. I've used the concept of Rolling hash/Rabin Karp algorithm. But I guess there are some collisions happening and it's failing on test case number 8. Any help is greatly appreciated. Been trying this for a long time.

Code: 27820412

Update: Solved! I tried many different ways. Initially, I used two hash moduli instead of one, but this exceeded the Time Limit on test #8 (Which is weird!). I ended up using a really large prime (About the size of 2^50) which just passed the time limit for Testcase #8 and passed the cases as well. :)

don't use 2 ^ k type constants. it will certainly cause collisions.

i solved it using two different constants and it passed perfectly fine. 33217384

Can you help me in explaining why we use two modulo hash instead of 1

D can be solved using 2 pointer and little bit of a lcp array.This is my solution. https://codeforces.com/contest/271/submission/44768791

In problem D, why bruteforce cost O(n^2 * lg(n^2)) ~= 1e7 gives TLE. Can someone explain why ? I'm really confuse about it.

I also had the same query, apparently, it leads to memory limit exceeded (MLE). Refer this post: https://codeforces.com/blog/entry/6668

Can anyone explain the solution to 271A - Beautiful Year more clearly ?

You can solve it by brute force. For a given year Y, start with the year Y+1 and check if it has all distinct digits, if not, keep adding one to it till you find such a year.

Can anyone explain me why we use 2 modulo hash here rather than 1. Thanks in advance