Thanks for participating in the round! I hope you enjoyed the problems!

1794A - Prefix and Suffix Array

**Solution**

Tutorial is loading...

**Code**

```
#include <bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int t; cin >> t;
for(int test_number = 0; test_number < t; test_number++){
int n; cin >> n;
vector <string> long_subs;
for(int i = 0; i < 2 * n - 2; i++){
string s;
cin >> s;
if((int)s.size() == n - 1){
long_subs.push_back(s);
}
}
reverse(long_subs[1].begin(), long_subs[1].end());
if(long_subs[0] == long_subs[1]){
cout<<"YES\n";
}else{
cout<<"NO\n";
}
}
return 0;
}
```

**Solution**

Tutorial is loading...

**Code**

```
#include <bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int t; cin >> t;
for(int test_number = 0; test_number < t; test_number++){
int n; cin >> n;
vector <int> a(n);
for(int i = 0; i < n; i++){
cin >> a[i];
}
for(int i = 0; i < n; i++){
if(a[i] == 1){
a[i]++;
}
}
for(int i = 1; i < n; i++){
if(a[i] % a[i - 1] == 0){
a[i]++;
}
}
for(auto i : a){
cout << i << " ";
}
cout << "\n";
}
return 0;
}
```

**Additional comment**

Actually, the maximum number of operations performed by this algorithm is $$$\frac{3}{2}n$$$. Try to prove it!

**Solution**

Tutorial is loading...

**Code**

```
#include <bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int t; cin >> t;
for(int test_number = 0; test_number < t; test_number++){
int n; cin >> n;
vector <int> a(n);
for(int i = 0; i < n; i++){
cin >> a[i];
}
vector<int> res;
for(int i = 0; i < n; i++){
int l = 1, r = i + 1;
while(l <= r){
int m = (l + r) / 2;
if(a[i - m + 1] >= m){
l = m + 1;
}else{
r = m - 1;
}
}
res.push_back(r);
}
for(auto i : res){
cout << i << " ";
}
cout<<"\n";
}
return 0;
}
```

1794D - Counting Factorizations

**Solution**

Tutorial is loading...

**Code**

```
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
//checks if n is prime
bool is_prime(ll n){
if(n == 1){
return false;
}
for(ll i = 2; i * i <= n; i++){
if(n %i == 0){
return false;
}
}
return true;
}
//computes b ** e % MOD
ll fast_pow(ll b, ll e){
ll res = 1;
while(e > 0){
if(e % 2 == 1){
res = res * b % MOD;
}
b = b * b % MOD;
e /= 2;
}
return res;
}
vector<pair<ll, ll>> primes;
const int MAXN = 5050;
ll dp[MAXN][MAXN];
ll fact[MAXN], fact_inv[MAXN];
ll f(ll x, ll y){
ll &res = dp[x][y];
if(res >= 0){
return res;
}
if(x == (int)primes.size()){
return res = (y == 0);
}
res = fact_inv[primes[x].second] * f(x + 1, y) % MOD;
if(y > 0){
res = (res + fact_inv[primes[x].second - 1] * f(x + 1, y - 1)) % MOD;
}
return res;
}
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
//reading the input
int n; cin >> n;
vector<ll> a(2 * n);
for(int i = 0; i < 2 * n; i++){
cin >> a[i];
}
sort(a.begin(), a.end());
//compressed version of a, pairs {value, #occurrences}
vector<pair<ll, ll>> a_comp;
for(int i = 0; i < 2 * n; i++){
if(a_comp.size() == 0u || a_comp.back().first != a[i]){
a_comp.push_back({a[i], 1});
}else{
a_comp.back().second++;
}
}
//computing factorials and inverses
fact[0] = 1;
for(ll i = 1; i < MAXN; i++){
fact[i] = fact[i-1] * i % MOD;
}
fact_inv[0] = 1;
for(ll i = 0; i < MAXN; i++){
fact_inv[i] = fast_pow(fact[i], MOD - 2);
}
//adding only primes for the dp
for(auto i : a_comp){
if(is_prime(i.first)){
primes.push_back(i);
}
}
memset(dp, -1, sizeof(dp));
ll res = f(0, n);
//we have to consider the contribution of non-primes too!
for(auto i : a_comp){
if(!is_prime(i.first)){
res = res * fact_inv[i.second] % MOD;
}
}
res = res * fact[n] % MOD;
cout << res << "\n";
return 0;
}
```

**Additional comment**

It is possible to solve the problem with greater constraints, like $$$n \leq 10^5$$$. Try to solve it with this new constraint!

1794E - Labeling the Tree with Distances

**Solution**

Tutorial is loading...

**Code**

```
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 200005;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
//Hashing stuff
const ll MOD[3] = {999727999, 1070777777, 1000000007};
ll B[3];
vector<ll> shift(vector<ll> h, ll val = 0){
for(int k = 0; k < 3; k++){
h[k] = (h[k] * B[k] + val) % MOD[k];
}
return h;
}
vector<ll> add(vector<ll> a, vector<ll> b){
vector<ll> res(3);
for(int k = 0; k < 3; k++){
res[k] = (a[k] + b[k]) % MOD[k];
}
return res;
}
vector<ll> sub(vector<ll> a, vector<ll> b){
vector<ll> res(3);
for(int k = 0; k < 3; k++){
res[k] = (a[k] - b[k] + MOD[k]) % MOD[k];
}
return res;
}
//Tree stuff
vector<int> g[MAXN];
bool vis[MAXN];
int parent[MAXN];
vector<ll> dp[MAXN], dp2[MAXN];
void dfs(int x){
vis[x] = true;
for(auto i : g[x]){
if(!vis[i]){
parent[i] = x;
dfs(i);
dp[x] = add(dp[x], shift(dp[i]));
}
}
dp[x] = add(dp[x], {1, 1, 1});
}
void dfs2(int x){
if(x != 0){
dp2[x] = sub(dp[parent[x]], shift(dp[x]));
dp2[x] = add(dp2[x], shift(dp2[parent[x]]));
}
for(auto i : g[x]){
if(i != parent[x]){
dfs2(i);
}
}
}
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
for(int k = 0; k < 3; k++){
B[k] = rng() % MOD[k];
}
//reading the input
int n; cin >> n;
vector<int> occurrences(n);
for(int i = 0; i < n - 1; i++){
int a; cin >> a;
occurrences[a]++;
}
for(int i = 0; i < n - 1; i++){
int u, v; cin >> u >> v;
u--; v--;
g[u].push_back(v);
g[v].push_back(u);
}
//calculating possible list hashes
vector<vector<ll>> list_hashes;
vector<ll> h = {0, 0, 0};
for(int i = n - 1; i >= 0; i--){
h = shift(h, occurrences[i]);
}
vector<ll> extra = {1, 1, 1};
for(int i = 0; i < n; i++){
list_hashes.push_back(add(h, extra));
extra = shift(extra);
}
//calculating possible tree hashes
for(int i = 0; i < n; i++){
dp[i] = {0, 0, 0};
dp2[i] = {0, 0, 0};
}
parent[0] = -1;
dfs(0);
dfs2(0);
vector<pair<vector<ll>, int>> tree_hashes;
for(int i = 0; i < n; i++){
if(i == 0){
tree_hashes.push_back({dp[i], i});
}else{
tree_hashes.push_back({add(dp[i], shift(dp2[i])), i});
}
}
//calculting the answer
sort(list_hashes.begin(), list_hashes.end());
sort(tree_hashes.begin(), tree_hashes.end());
vector<int> res;
int pos = 0;
for(auto lh : list_hashes){
while(pos < n && tree_hashes[pos].first < lh){
pos++;
}
while(pos < n && tree_hashes[pos].first == lh){
res.push_back(tree_hashes[pos].second);
pos++;
}
}
sort(res.begin(), res.end());
cout << res.size() << "\n";
for(auto i : res){
cout << i + 1 << " ";
}
cout << "\n";
return 0;
}
```

E was doable :/

Why don't we need to check if the remaining distance is not too far away in problem E? (nvm got it)

Please share the explanation

It could only be wrong in case of a collision, which gives a probability of at most $$$\dfrac{N}{MOD}$$$ of it being wrong for a single vertex, using two hashes solves this.

O(n) solution for problem C. https://codeforces.com/contest/1794/submission/196020227

C can be done in O(N) using two pointers.

The two-pointers technique is an easier and more intuitive solution.

You could actually just use greedy for C using a pq. Add the new element at each prefix and while the lowest element in the given series is less than the size of the array, you will remove it. 196022463. Very easy implementation.

Even simpler solution using

`queue`

: 196042147This is literally the same solution as the two pointers (and it works for exactly the same reasons).

But as the array is sorted you don't need the priority queue.

Oh, I didn’t even realize the array was sorted lul.

Priority queue was my initial idea, but it didn't come to me that i should insert and delete elements at the same time.

can someone explain in problem B why can't we iterate from right to left basically how addition form left to right is making sure correct answer and not right to left

Because the constraint is from left to right

Let me explain, draw the elements of the array from left to right in increasing order of the indices. For each i, add a directed edge from the i-th element to the (i+1)-th element. As you can see, the value of the i-th element is constraining the value of the (i+1)-th element to be not divisible.

If you wanted to fix the issues by starting from right, then it would change a[i+1] for it not to be divisible by a[i] but then when you change a[i] for it not to be divisible by a[i-1], the fact that the value of a[i] changed might make a[i+1] divisible by a[i].

While if you do it from left to right, the changes you do on the (i+1)-th value will not affect the values from 0 to i

Amazing to see so many solutions for C!

Nice Contest

As always good contest and good quality questions.

Great problems (even though I did pretty bad)

You are so close to expert. Bad luck this time, better luck next time!

Anya

O(N) solution for div2 C. Basically if a[i] = j, then for all k from i to i+a[i]-1, this index i will be the "bottleneck" i.e. our max length score will be k-i+1. We can iterate on i and maintain 2 pointers to avoid overlaps.

196049334

Somehow I always assumed that hashing based solutions will never work on codeforces, now feeling stupid :/

You can always choose the modulo randomly to defend against hacks

Just use two hashes

composite modulo can be a problem if you have to do modular inverse, and I don't know an easy way of choosing a random prime

https://codeforces.com/blog/entry/50984?#comment-348756

We can tweak Errichto algorithm in the above comment to generate a uniformly random prime.

Just choose a random no in range and check if it's prime. If it isn't, keep choosing another random no in the range.

A range of length N has $$$N/logN$$$ primes so that this algorithm will end after $$$O(logN)$$$ iterations, and this will be a uniformly generated prime no.

I agree.

Disclaimer though: after generating a random prime, the computations modulo that prime are very slow. Do it only in CF, where you can be hacked. Otherwise, using a constant modulo is faster.

Instead of choosing the modulo randomly, you could also choose the base as a random integer from the interval $$$[0, MOD-1]$$$, which is what they do in the editorial.

This round needs an extra problem F.

Less than 20 people in Div 2 solved E, less than 10 people in Div 2 solved E with 10+ minutes left.

I won't say that this isn't a good round or the last problem isn't interesting, but for most Div.2 rounds these numbers would be 1 or 0.

A problem F that is usually solved by 1 or 0 people in Div 2 satisfies the desire of unofficial participants from Div 1 but will be ignored by most Div 2 participants during the contest, as if it never existed. Maybe I will have a different view/desire once become more advanced, but currently feel such F will add more stress and intimidation, at least during the contest.

See this.

Thanks for the strong tests. I got lots of WA and had a chance to fix them.

Yet another DP problem that I can't solve within the contest time. :(

I solved E by adding heuristics until I got AC. I challenge anyone to hack my solution: 196038364.

Here is what my solution does:

For each node

If at the end, there are $$$\leq 200$$$ candidates, check all of them individually. Otherwise, check any one of them. If that node is good, every candidate is good, otherwise they are all bad.

SpoilerThe blog I'm talking about

(Including the speed of posting the editorial,) what a great contest!

I liked these problems (especially C & D) because their implementation will be quite simple if we could find out the essence.

Also the number of problems was just nice for a rated participant (like me) to solve them all in time (though I couldn’t solve E).

O(n) solution for problem C ==> https://codeforces.com/contest/1794/submission/196041871

How to calculate the probability of a hash failing for hashes like problem E?

I did the same as the editorial with $$$5$$$ hashes, with $$$P = 10^9 + 7$$$ and $$$5$$$ randomized bases. With a polynomial hash like this the chance of a collision is basically the same as the chance that for an arbitrary polynomial of degree $$$n$$$, if you evaluate at a uniformly random $$$x$$$ that it is equal to $$$0\mod P$$$. A polynomial $$$\mod P$$$ has at most $$$n$$$ roots (if $$$P$$$ is prime). So the chance of a false positive for one hash is $$$n/P$$$. In this problem we actually check equality for $$$n^2$$$ pairs implicitly. So this means that the final probability of failure on one test with $$$5$$$ hashes is $$$ \leq 1 - (1 - (n/P)^5)^{n^2} \approx 1.3 \times 10^{-8}$$$. But seeing that solutions with fewer hashes also passed I think in general the $$$n/P$$$ is a big overestimate.

Are you sure that a polynomial mod P of degree n has at most n roots? That doesn't seem trivial to me. Also about the N^2 thing, if the values of b^e mod P are different, you're left with only 1 candidate per vertex after hashing once. That whole N^2 thing seems different from what I have in mind but it might be just different solutions.

I think it's true for polynomials in arbitrary fields. The proof relies on the fact that if you have a root of a polynomial, then you can write the polynomial $$$f(x) = (x- \texttt{root}) \times g(x)$$$, where $$$g(x)$$$ has degree $$$1$$$ less. By induction you can easily see it that the maximum number of roots is $$$n$$$.

Nice. I was afraid of things not working as usual because x^(P-1) == x^0.

Assume the answer for a testcase should be 0. Then for your answer on the testcase to be wrong, it only has to happen once, that any of the hashes of the $$$n$$$ rooted trees coincides with any of the hashes of $$${ H+b^k, \text{for}\ 0 \leq k <n }$$$ (using editorial notation). So these are two (multi)sets of $$$n$$$ items, for each of the $$$n^2$$$ pairs, you are basically subtracting the corresponding polynomials, evaluating the polynomials at random points, and hoping that the result is not $$$0$$$, because then you mistakenly output some number of good roots $$$>0$$$.

Lagrange's theorem says that

https://en.wikipedia.org/wiki/Lagrange%27s_theorem_(group_theory) this? I see no relation.

no, this: https://proofwiki.org/wiki/Lagrange%27s_Theorem_(Number_Theory)

Formal statement for arbitrary fields — Schwartz-Zippel Lemma

D can be solved in $$$O(n\log n)$$$ time using convolution + D&C. My submission.

Edit: Time complexity is not $$$O(n\log n)$$$. It is $$$O(n \log^2n)$$$.

Can you provide resources about these topics, please? What is D&C?

Divide and Conquer I suppose

Convolution is multiplying two polynomials using FFT. D&C is Divide and Conquer. They are very standard topics, you can Google them.

Isn't it $$$O(n \log^2(n))$$$?

Oops, my bad. You are right.

Can you please explain further why fft and D&C come into play here?

Since $$$c^{'}_i = c_i-1 \text{ or } c_i \implies \frac{c_i!}{c^{'}_i!} = c_i \text{ or } 1$$$

We want to calculate sum of $$$\frac{1}{c^{'}_1! \cdot c^{'}_2! \dots c^{'}_t!}$$$

Let us multiply and divide the summation by $$$(c_1!\cdot c_2! \dots c_t!)$$$

We get $$$\frac{(c_1!\cdot c_2! \dots c_t!)}{(c_1!\cdot c_2! \dots c_t!)} \cdot \sum \frac{1}{c^{'}_1! \cdot c^{'}_2! \dots c^{'}_t!} = \frac{1}{(c_1!\cdot c_2! \dots c_t!)} \cdot [\sum (c_{i_1}\cdot c_{i_2} \dots c_{i_n})]$$$ where $$$c^{'}_{i_j} = c_{i_j}-1$$$

So now we want to select $$$n$$$ elements from {$$$c_1, c_2, \dots, c_t$$$}, calculate its product, and then sum it over all ways of choosing $$$n$$$ such elements.

To do that consider the polynomial $$$f = (1 + c_1 x)\cdot(1 + c_2 x) \dots (1 + c_t x)$$$. The coefficient of $$$x^n$$$ in this polynomial is exactly the value we are trying to calculate.

Multiplying two polynomials of length $$$k$$$ can be done in $$$O(k \log k)$$$ time using FFT. But here we have $$$O(n)$$$ polynomials. So if we just keep multiplying from left-to-right it will take $$$O(n^2 \log n)$$$ time. One solution is to use a priority queue and keep multiplying the smallest two polynomials in the product.

The other solution is to use divide and conquer. Recursively calculate the product of the first $$$\lceil\frac{t}{2}\rceil$$$ polynomials and the last $$$\lfloor \frac{t}{2} \rfloor$$$ polynomials. Both polynomials are of size at most $$$n$$$. Now use FFT to calculate product of the left-half and right-half in $$$O(n \log n)$$$. Overall time complexity can be proved to be $$$O(n \log^2 n)$$$

Simple loop and if condition check solves C in O(n) time.

196053649

how u arrived at this one , plz give some hints

I did observations from my local test case experiments. Whenever ans++, following condotion must met.

Proof of $$$\frac{3}{2}n$$$ operations in problem B.

ProofLet us say that first phase is making $$$a_i \mathrel{+}= 1$$$ if $$$a_i$$$ equals 1 and the second phase is making $$$a_i \mathrel{+}= 1$$$ if $$$a_i$$$ is divisible by $$$a_{i - 1}$$$.

Consider $$$k$$$ is the number of positions which equal $$$2$$$ after first phase. In first phase we will make $$$\leqslant k$$$ operations (because we need to change only 1). In the second phase we don't know anything about other $$$n - k$$$ elements. That is the reason why we will do at least $$$n - k$$$ operations in the second phase. But what about our elements which equal two?

Consider the segment of our array where each element equals two. I say that in the second phase we will do $$$\leqslant \frac{k}{2}$$$ operations on this segment. Why? If we changed element $$$i$$$ (now $$$a_i = 3$$$) then element $$$i + 1$$$ isn't divisible by $$$a_i$$$ (because $$$2$$$ is not divisible by $$$3$$$). This is why the total number of operations in the second phase will not more then $$$n - k + \frac{k}{2}$$$.

Total number of operations in both phases: $$$k + n - k + \frac{k}{2} = n + \frac{k}{2} \leqslant \frac{3}{2}n$$$

Could some explain the reasoning behind the dp in question D?

You can watch my video analysis: https://www.youtube.com/watch?v=jFSUQmxCoUI

Nice explanation

I think E can be solved without the $$$dp2$$$ array: let the hash of the current root be $$$cur$$$, then the hash for its child $$$u$$$ is $$$(cur - b \cdot dp_u) \cdot b + dp_u$$$, code: 196075156.

It seems that the author's solution for E has been hacked... https://codeforces.com/contest/1794/hacks/894254

I should have chosen a non-hackable solution to publish in the editorial. It is fixed now.

HOW TO SOLVE PROBLEM D with N = 10^5 ?

Following the same setup as the editorial, we need to find the sum of all the terms of the form $$$\frac{1}{c'_1!c'_2!c'_3!...}$$$, where $$$c_i$$$ is the frequency of the ith prime and $$$c'_i$$$ is the frequency after we've chosen the bases. Let's look at this problem another way, let's look at the polynomial $$$P(x) = (\frac{1}{c_1!}+\frac{1}{(c_1-1)!}x) * (\frac{1}{c_2!}+\frac{1}{(c_2-1)!}x) * ...$$$

or in other words $$$P(x) = \Pi_{allprimes} (\frac{1}{c_i!}+\frac{1}{(c_i-1)!}x)$$$

The coefficient of $$$x^n$$$ in this polynomial represents choosing the $$$x$$$ term $$$n$$$ times and the constant term the rest of the times, which is exactly what we want to do, we want to choose the prime as a base $$$n$$$ times. So if we choose our coefficients properly, this essentially gives us our answer. To calculate $$$P(x)$$$ you can use FFT (actually NTT) and Divide and Conquer to do it in $$$O(nlog^2(n))$$$

Submission

Problem E — I am getting WA on TC 178, I used the same base and mod as that in the editorial. Can someone help? My submission : 196096531

That was the previous editorial solution. Check the new one.

Hashing strategy in problem E is very nice. I want to say thanks to the author for being a reason to learn this strategy.

This code is giving random output on TC 6 pls help https://codeforces.com/contest/1794/submission/196113923

Just had to correct the size of the dp array.

The max value of n is 2022, but the max number of input elements is (n * 2), i.e., 4044. And since the value of the array elements can be up to 10^6, it is possible that we have 4044 distinct primes in the input.

Thus, changing the size of the array to [4045][4045] made the code pass: 196195253

Thank you, i shouldn't have missed that. :)

That's alright mate, happens sometimes :-)

IN PROBLEM B: CAN ANY ONE EXPLAIN WHY MY CODE DIDN'T WORKED:

196123474

if(( arr[i]%arr[i-1]==0) ){

#define r(i,n) for(int i=1;i<=n;i++)

i = n then arr[n] but len(arr) = n !!

Not able to figure out why i am getting correct ans in test 5 but WA in test 9 for problem D.

I have used a bottom-up dp.

could someone please help, my code

Problem D is nice!

Can anyone help me make sense of something in problem E?

This submission got Wrong answer : https://codeforces.com/contest/1794/submission/196157777 but this one got Accepted : https://codeforces.com/contest/1794/submission/196160146

The only difference between them is that they have different primes numbers. I thought that the cause is a collision but i used the prime numbers of the judge's solution on the one that got wrong answer so the occurrence of collision doesn't make sense.

I would appreciate if anyone can help me understand the cause of that.

Edit: Hacked. but i still know why my code is wrong if someone can help?

Collision. Use 3+ mods and/or random bases to avoid hacks.

I'll provide my generator for generating hacks on E, if anyone else wants to do more (and I know for certain that there are a lot more hackable solutions out there). Look for solutions that use some fixed pairs of base and modulo and place them in the pairs variable in the code. There were a few special cases that required another idea to hack but I won't describe the details unless requested.

GeneratorCan you explain how this generator works?

For simplicity, consider a version of the problem where instead of $$$n-1$$$ distances being given, all $$$n$$$ distances are given. It's pretty similar when it comes to hacking. A solution takes the following form: pick some $$$r$$$ and $$$p$$$, and mark a vertex $$$v$$$ as good if

where $$$d(u, v)$$$ is the distance from $$$u$$$ to $$$v$$$.

We'll try to make vertex $$$1$$$ a false positive. Let $$$P$$$ be the polynomial defined by

Then we should make it so that $P$ is not identically zero, yet $$$P(r)\equiv 0\pmod{p}$$$. Additionally, $$$P(1)=n-n=0$$$.

There are pretty much no further constraints on the polynomials $$$P$$$ we can use now, aside from the coefficients not being too large so that the number of vertices is at most $$$2\cdot 10^5$$$. For example, if we have the polynomial $$$P(x)=-10+13x-3x^2$$$, then we can write it as a difference

which means a graph with $15$ vertices where $$$13$$$ vertices are at distance $$$1$$$ from $$$1$$$, one vertex is at distance $$$2$$$, and the wrong distances consist of $$$11$$$ zeroes and $$$4$$$ twos. The graph is easy to construct from here. (For the actual version of the problem, just delete one copy of $$$0$$$.)

To construct the polynomial, note that we can first find a polynomial with $$$P(r)=0\pmod{p}$$$ and then multiply it by $$$(x-1)$$$ to have $$$P(1)=0$$$. With $$$p$$$ on the order of $$$10^9$$$, we can use a birthday paradox approach. Generate random polynomials with small coefficients and check the residues $$$P(r) \pmod{p}$$$ until you find a collision $$$P_1(r)\equiv P_2(r)$$$ where $$$P_1\neq P_2$$$. Then we can use $$$P=P_1-P_2$$$ as our polynomial. Assuming the residues are uniformly random, this should take about $$$\sqrt{p}$$$ tries which is fine.

To handle multiple hashes $$$(r_i, p_i)$$$, find a polynomial for each pair and then multiply them together. This works because if $$$P_i(r_i) \equiv 0 \pmod{p_i}$$$ then any multiple of $$$P_i$$$ also satisfies the same property. At some point the product polynomial's coefficients are too large but I was able to hack 5 hashes pretty easily.

Wow, this is really cool — thanks for the detailed explanation!

Can somebody help me on problem D,this is my submission 196227451,thanks!

I make a mistake and su.ccessfully solve D now,haha.

In problem D, my code is giving correct output on all small test cases. But it is failing on large test cases. I am getting 'WA on Test 5' verdict. Please someone help me in correcting my code. Submission Link — https://codeforces.com/contest/1794/submission/196218425

You seem to have accidentally declared N to be 2002 instead of 2022.

Changing just that made the code pass: 196296912

C by fenwick link

I had the same solution, but changing elements in the array filled with zeroes and then calculating the prefix sums at the end was enough. It works in $$$O(n)$$$.

I'm stuck on problem A. I tried using the following code to find two substrings of length n-1 and check if one of them is equal to its reverse, but it didn't pass the test. Can someone help me

it fails for string "bba" (sequence b b a bb ba)

Has anyone found a way (or, is it possible) to solve problem E without hashing or heuristics?

I really like the hashing approach, but I'm just curious about alternative solutions :)

I enjoyed this contest. Thanks for nice problems.

E is interesting. I figured out all parts except the hash, thought there might be a collision.

MateoCV Thank you for such good problems and good round

my idea for problem C using queue

Thanks... :)

C can be done in O(N) in an easy way To get an answer as t we need to have at least t elements which are greater then or equal to void solve() { int n; cin >> n; int t = 0, mx = 0; vector mp(n+1, 0); for(int i = 0; i < n; i++) { // to get ans as t shold have at least t elemetms which is >= t int d; cin >> d; mp[d]++; t++; int tmp = t; t -= mp[tmp-1]; mp[tmp-1] = 0; mx = max(mx, t); cout << mx << " "; } cout << endl; }

In B, Instead of going from left to right can't we go to left from right like this? - 258836011