Problem authors: Stepavly, Supermagzzz

**Editorial**

Tutorial is loading...

**Solution**

```
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
void solve() {
ll n;
cin >> n;
if (n & (n - 1)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
```

Problem author: MikeMirzayanov

**Editorial**

Tutorial is loading...

**Solution**

```
#include <bits/stdc++.h>
#include <utility>
using namespace std;
using pii = pair<int, int>;
int main() {
int test;
cin >> test;
while (test-- > 0) {
int n;
cin >> n;
int cnt2021 = n % 2020;
int cnt2020 = (n - cnt2021) / 2020 - cnt2021;
if (cnt2020 >= 0 && 2020 * cnt2020 + 2021 * cnt2021 == n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
```

Problem authors: Stepavly, Supermagzzz

**Editorial**

Tutorial is loading...

**Solution**

```
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
void solve() {
int A, B, k;
cin >> A >> B >> k;
vector<int> a(A), b(B);
vector<pair<int, int>> edges(k);
for (auto &[x, y] : edges) {
cin >> x;
}
for (auto &[x, y] : edges) {
cin >> y;
}
for (auto &[x, y] : edges) {
x--;
y--;
a[x]++;
b[y]++;
}
ll ans = 0;
for (auto &[x, y] : edges) {
ans += k - a[x] - b[y] + 1;
}
cout << ans / 2 << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
```

Problem authors: Stepavly, Supermagzzz

**Editorial**

Tutorial is loading...

**Solution**

```
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
void solve() {
int n, m;
cin >> n >> m;
vector<int> a, b;
vector<int> v(n);
for (int &e : v) {
cin >> e;
}
for (int &e : v) {
int x;
cin >> x;
if (x == 1) {
a.push_back(e);
} else {
b.push_back(e);
}
}
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
ll curSumA = 0;
int r = (int)b.size();
ll curSumB = accumulate(b.begin(), b.end(), 0ll);
int ans = INT_MAX;
for (int l = 0; l <= a.size(); l++) {
while (r > 0 && curSumA + curSumB - b[r - 1] >= m) {
r--;
curSumB -= b[r];
}
if (curSumB + curSumA >= m) {
ans = min(ans, 2 * r + l);
}
if (l != a.size()) {
curSumA += a[l];
}
}
cout << (ans == INT_MAX ? -1 : ans) << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
```

Problem authors: Stepavly, Supermagzzz

**Editorial**

Tutorial is loading...

**Solution**

```
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int mod = 1e9 + 7;
int fast_pow(int a, int p) {
int res = 1;
while (p) {
if (p % 2 == 0) {
a = a * 1ll * a % mod;
p /= 2;
} else {
res = res * 1ll * a % mod;
p--;
}
}
return res;
}
int fact(int n) {
int res = 1;
for (int i = 1; i <= n; i++) {
res = res * 1ll * i % mod;
}
return res;
}
int C(int n, int k) {
return fact(n) * 1ll * fast_pow(fact(k), mod - 2) % mod * 1ll * fast_pow(fact(n - k), mod - 2) % mod;
}
void solve() {
int n, k;
cin >> n >> k;
vector<int> cnt(n + 1);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cnt[x]++;
}
for (int i = n; i >= 0; i--) {
if (cnt[i] >= k) {
cout << C(cnt[i], k) << "\n";
return;
} else {
k -= cnt[i];
}
}
cout << 1;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
```

Problem authors: Stepavly, Supermagzzz

**Editorial**

Tutorial is loading...

**Solution**

```
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
bool check(vector<vector<int>> a, vector<vector<int>> const &b) {
int n = (int) a.size();
for (int j = 0; j < n; j++) {
if (a[0][j] != b[0][j]) {
for (int i = 0; i < n; i++) {
a[i][j] ^= 1;
}
}
}
for (int i = 0; i < n; i++) {
int need_xor = (a[i][0] ^ b[i][0]);
for (int j = 1; j < n; j++) {
if (need_xor != (a[i][j] ^ b[i][j])) {
return false;
}
}
}
return true;
}
void solve() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(n));
vector<vector<int>> b(n, vector<int>(n));
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < n; j++) {
a[i][j] = s[j] - '0';
}
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < n; j++) {
b[i][j] = s[j] - '0';
}
}
for (int times = 0; times < 2; times++) {
if (check(a, b)) {
cout << "YES\n";
return;
}
for (int j = 0; j < n; j++) {
a[0][j] ^= 1;
}
}
cout << "NO\n";
}
int main() {
int test;
cin >> test;
while (test-- > 0) {
solve();
}
return 0;
}
```

Problem author: MikeMirzayanov

**Editorial**

Tutorial is loading...

**Solution**

```
#include <bits/stdc++.h>
using namespace std;
const int N = (int) 2e5 + 100;
int dp[N];
int cnt[N];
void solve() {
int n;
cin >> n;
fill(dp, dp + N, 0);
fill(cnt, cnt + N, 0);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cnt[x]++;
}
for (int i = 1; i < N; i++) {
dp[i] += cnt[i];
for (int j = 2 * i; j < N; j += i) {
dp[j] = max(dp[j], dp[i]);
}
}
cout << (n - *max_element(dp, dp + N)) << endl;
}
int main() {
int test;
cin >> test;
while (test-- > 0) {
solve();
}
return 0;
}
```

F was almost a duplicate of USACO's 'Left Out': http://www.usaco.org/index.php?page=viewproblem2&cpid=942 Really like the idea regardless

`also it makes no sense to apply the same operation more than once (by the property of the xor operation).`

Can someone explain this line in the F editorial? I understand that applying the operation twice on the same row/column would again switch it back to the previous,

but how applying the operation to a row, then to a column, and then again to the same row doesn't make sense?bruh did you reply to my comment just so that it'd appear higher up lol? anyways, that'd be the same as just applying the operation to the column

Haha yes, plus this was the only comment regarding problem F. Thanks a lot, got it!.

in E , i am having trouble while taking mod

when i submitted without taking mod while calculating factorial then i got overflow. 106346070

but when i changed and gave mod while calculaating factorial itself then , i got the answer as 0 106343305

pls someone help me out.

Thanks for the contest! I recorded my participation and narrated over it -- https://www.youtube.com/watch?v=0eZsX0BWtyY (video is done processing + I've added chapter timestamps).

Interesting problemset, not too tough nor too easy. It was definitely more on an easier end, but considering it was a Div3 I enjoyed it.

I especially liked the appearance of many different parts of CP and different topics, not just ad-hoc problems, e. g. binary search, dp, multiplicative inverse/binary exponentation, math, observation...

I think beginners can greatly benefit from this experience regardless of the long queue. Thanks to the problemsetters!

UPD: For those wondering where binary search appeared — apparently I overcomplicated the fourth problem and solved using binary search, Might have not been the best idea, but made it a nice problem for me. :P

Binary was good as well for me

i solved D using dp , never realized it could be done using binary search

Could you please explain your approach?

https://codeforces.com/blog/entry/87188?#comment-753521

solution please!

Here's my solution

Hey,I tried D with priority queues by making different queues more important and less important respectively. But it gave wrong ans with some case.

This is my code https://codeforces.com/contest/1475/submission/105424077

Any suggestion in code or logic will be helpful.

you can see my solution. I have also used the same approach. https://codeforces.com/contest/1475/submission/105382749

Thanks brother got the error, I was doing m-=(r+r1) but acc. to your sol. r1 can be used afterwards or it may happen that it is not used. This is what i thought after seeing your solution, if anything else you wanted to add that you think of or proof of this pls share it would be very helpful in future contests.

no you got it right. It'a a fairly straight greedy problem. You just have to choose maximum memory you can delete with 2 convienience.

okk thanks

Try thinking about this test case:

thanks got the error, i was subtracting two regular apps at a time but it should be one at a time.

if anything you want to add or can we proof this observation, it would be helpful in future contest.

Thanks

what are the DP states and state transitions used in your solution?

initially i calculated the sum of convenience points . divided the memory in two arrays based on the type of application and sorted both the arrays in ascending order . dp states were the convenience points, i calculated what is the maximum application memory that can be removed if i loose k convenience points . dp[i] stored the maximum memory possible , along with how many regular and important applications have been used for it. therefore dp[i] = {max,{index upto which regular have been used,index upto which imp has been used }},here i is the convenience points lost which is (index upto regular + 2*index upto imp) . for transition - dp[i] = max(dp[i-1] + maximum memory from regular array that can be used,dp[i-2] + maximum memory from imp array that can be used) then update the index of regular and important that have been used for that state . After the calculation , i just traversed over the array and found the first index where the memory >= m . here's my solution — https://codeforces.com/contest/1475/submission/105395940

Can you tell me why you choose the dp[i-2] route if both dp[i-1] and dp[i-2] are equal in your solution ?

dp[i-1] will store the maximum sum that can be achieved when i loose i-1 convenience points and dp[i-2] will store the maximum sum that can be achieved when i loose i-2 .so since i am loosing more convenience points in (i-1) rather than (i-2) , dp[i-1] > dp[i-2]. for example if i can loose 4 convenience points and the maximum sum achieved is a , and if i can loose 5 convenience points and the maximum sum achived is b , then b > a .

the subset DP approach? where you each cell in dp shows sum achieved with min convenience points.?

dp[i] stores the maximum sum achieved when we loose i convenience points . along with this it also stores the {index upto which regular applications have been used , ,index upto which important applications have been used} = {a,b} , so we can say that i = (a + 2*b).

i have also solved it but it is giving me memory limit exceeded... as i am taking a dp of size dp[N][sum_of_all_elements] please reply Bhavyashah12050

knapsack dp will give tle coz if n^2 and it will not fit in memory because the sum can be >=1e9 , it is not possible to make an array of this size , so instead iterate on the total sum of the convenience points , my approach was that to loose i convenience points we can say (i-2) + 2 or (i-1) + 1 , this is the maximum sum achieved at (i-2) points + add the highest important application which is available or maximum sum achieved at (i-1) points + add the highest regualar application which is available . this is how i made the transitions , along with this i also stored the index upto which regular and important applications were used . it was o(n)

What will be the time complexity of last question??

Time complexity of editorial solution for problem G is O(n.log(log(n))). But, you can solve it in O(n.sqrt(n)) by finding factor of every elements in a.

thanks

No editorial solution is O(nlogn)

Time complexity will be O(N log N), because, each iteration we were adding N/i where, i is number iterations. In other words, N/1 + N/2 ... N/N ~= N*log(N).

My own set of video solutions, probably with some overcomplications (as usual...)

Check out my explanations of problem F and G — solution

Screencast with narration + Solution Explanations: https://youtu.be/WynaHclse_4

How to solve D if conveniences b[i]<=1e5 ?

My D is giving runtime error on 2nd case. exit code -12343838 something like this. I tried it for many test cases but it is giving me right output as well as i tried it for some cases which are shown for 2nd test-case also. It is working fine. Can anyone help me? submission: 105393105

i = (int)ones.size()-1; j = (int)twos.size()-1;

Thanks, my solution had the same problem.

Runtime error https://codeforces.com/contest/1475/submission/105486312

Accepted https://codeforces.com/contest/1475/submission/105499731

What problem occurs if we don't cast to int?

Anyone want to increase their hack count??

Here you go.... 105318690

For problem D, shouldn't 0-1 knapsack work? I did have a feeling that the convenience values of only 1 & 2 were important, but my initial intuition was to simply calculate the maximum convenience for memory up to (total memory of all applications — m). Then, the minimum convenience lost should be (total convenience of all applications — maximum convenience possible). My solution doesn't seem to work, but I am not sure why this solution would not work for all cases.

It sounds fine to me. Can you point out any case where it doesn't work or any code snippet with WA? I understand it may cause TLE but other than that sounds ok.

Ah yes, it turns out I had a bug because I wasn't handling impossible case (-1) properly. Once I fixed that it seems to work, but it is very inefficient, as I am now hitting MLE and TLE as you predicted. I will try to optimize this solution, but I have a feeling I will just end up with the proposed solution in the editorial anyways. Good learning experience nonetheless!

Yes. Knapsack makes sense with smaller constraints over N and M. These constraints don't look like typical knapsack constraints and usually when the problem is constrained in a new way (example each value is 1 or 2), then there is something else that must be taken advantage of.

I tried D with priority queues by making different queues more important and less important respectively. But it gave wrong ans with some case.

This is my code https://codeforces.com/contest/1475/submission/105424077

Any suggestion in code or logic will be helpful.

Why can't we consider a number (say n) as it's own divisor in problem A? I mean a number is surely its own divisor! I don't think the problem setters have accounted for this, or am I missing something?

There's no restriction like that allowing for prime numbers > 2 to pass

I don't understand then why does 105409438 not work. Maybe you can help me realize my error?

It probably has something to do with the following:

Precision issues

using == for comparing double

the log function probably gives a not so accurate answer

Try solving the problem without floats/doubles

In D why this does not works? Sort the array consistimg of all a[i] ( imp nd regualr both) in inc. order.

Select from beginning apps till the sum does not exceeds m. Then try to replace selected important apps by remaining regular apps.

Does your code work for this example? N=5, M=9

A= 5 5 3 3 3 B= 2 2 1 1 1

Can anybody help me out with the difference between the 2 codes which are almost the same except for the fact in 1st I am directly using vector size and in the second submission I am saving the size in tmp variable and then using it: 105405168 [WA ON TC 7] 105408860 [AC]

size() returns an unsigned integer. It can give unusual output in case when size is 0 or in similar cases. So it is better to typecast it. When you stored the value in temp what you did was basically typecasted it to int and it worked fine.

As many people are posting solutions on their youtube channel. I would love to see 15 minutes video from top performers like tourist. Hopefully he will add some contest video to his channel soon.

Just watch my video on 2x speed.

My first question is hacked by n=1 but in question n>=2. Should I also consider cases which are not in input range

(Regarding Problem C)

Why does this TLE?

Also, in other sources for the same problem where I use a C-like array instead of

`std::vector`

(though this would also apply for`std::vector`

, I think), why is it that`occ[2][MAX_NR + 1]`

is considerably faster than`occ[MAX_NR + 1][2]`

(514 ms. vs. 1357 ms.)? I kind of read about the difference between those two some time ago, but I didn't really remember much.., so it would be great if someone could perhaps give a link explaining this.It TLEs because you are trying to allocate

`MAX_NR`

length for each test case, and there are`10^4`

test cases.I don't quite understand ' if(n & (n — 1))' in the solution to A. I did some research and found that the binary representation of any number that is a power of 2 is 10 to the i and the binary representation of any (power of 2) — 1 is a string of 1's the length of the power of 2 — 1. So performing an AND operation gives a string of 0's in the case that the input is a power of 2 and a string of 1's and 0's in the case that it isn't a power of 2. 1. How can that be used in an if statement? If it's 0's (i.e. the input was a power of 2), is that the equivalent of it being false, and the contrary for a string of 1's and 0's in the case that it isn't a power of 2?

Let's say $$$n$$$ is a power of $$$2$$$. Then, in base $$$2$$$, $$$n$$$ will look something like:

$$$1000000\cdots000$$$

and $$$n - 1$$$ will look something like:

$$$0111111\cdots111$$$

If we bitwise $$$AND$$$ these two, we obtain:

$$$1000000\cdots000\space \&$$$

$$$0111111\cdots111 =$$$

$$$0000000\cdots000.$$$

Which is equal to the representation of $$$0$$$, in base $$$2$$$. That is, if $$$n$$$ is a power of $$$2$$$, $$$n \space \& \space (n - 1)$$$ equals $$$0$$$. It's not hard to see this equals $$$0$$$

onlyif $$$n$$$ is a power of $$$2$$$. In all other cases, it will return somenonzeronumber. In a condition, $$$0$$$ evaluates to`false`

, while anynonzeronumber always evaluates to`true`

. Thus,when $$$n$$$ is a power of $$$2$$$, and

when $$$n$$$ is

nota power of $$$2$$$.For problem E, I had a pure DP approach different from the editorial with no use of combinatorics, which I think works (at least I wasn't hacked yet if it wasn't the case).

Let's call $$$dp[i][j]$$$ the maximum number of followers we can get by choosing $$$j$$$ people in a prefix $$$[0,i]$$$ (the order of the array doesn't matter). Then let's also have another array $$$ways[i][j]$$$ which represents the number of ways to get to the amount of followers indicated by $$$dp[i][j]$$$. As a base case, it's easy to see that the maximum number of followers when choosing $$$0$$$ people is obviously $$$0$$$, and by that reason the number of ways of getting to that result is only $$$1$$$, so $$$dp[i][0] = 0, ways[i][0] = 1$$$ for all $$$i$$$. Then, we can calculate the value for the rest of the states: for each $$$i$$$ and $$$j$$$, $$$dp[i][j] = max(dp[i-1][j-1]+followers[j],dp[i-1][j])$$$. It means that the maximum amount of followers we can get by choosing $$$j$$$ people is already the calculated value for $$$j$$$ in the previous prefix, or choosing the blogger in position $$$j$$$ and adding the corresponding followers to the best way of choosing $$$j-1$$$ followers in the previous prefix. And $$$ways[i][j]$$$ is set to $$$ways[i-1][j-1]$$$ or $$$ways[i-1][j]$$$ in the first or second case respectively. Also, if we get to the case where $$$dp[i-1][j-1]+followers[j]$$$ is equal to $$$dp[i][j]$$$, then we add the corresponding ways from $$$ways[i-1][j-1]$$$ to $$$ways[i][j]$$$, applying $$$\%MOD$$$ to avoid overflow.

Just to be clear, I changed a little bit the wording from what I really implemented so it was easier to explain, but the idea is very similar. Here's the submission: 105415244

IMO easier solution for B: make a bool array DP length of the maximum possible n(1e6, as I remember) and fill it with false. Then make dp[2020]=dp[2021]=true. And for each number in [4040, 1e6] if dp[i — 2020] or dp[i — 2021] is true, than dp[i] = true. This basically means “if it is possible to reach B”. And then for each test case just print dp[n] ? Yes : No!

Anyone stuck at D , can watch this https://youtu.be/c7h4hUdXX1E

Hello

I use:)greedyto solve problem Dyou can see my code here : https://codeforces.com/contest/1475/submission/105374802

My approach was quiet similiar , but I popped two elements of 1 priority (when sum of these two was greater than the sum of priority 2 single element) , couldn't figure out whats wrong in this approach , can you help me ?

This is my solution : https://codeforces.com/contest/1475/submission/105392908

I try hard to find your mistake

for sample input:

your ans will be 6 but my ans is 5

Thanks a lot , can you teach me how to find these test cases by yourself.

Actually I guess ! because you pick up 2 elements each time but think about this input

your program picks up element 1, 3 I think. but it's not necessary to pick up element 3, greedy Guarantees that max1_type1 is best at a time or max1_type2 and not about any other element.

Hey,I tried D with priority queues by making different queues more important and less important respectively. But it gave wrong ans with some case.

This is my code https://codeforces.com/contest/1475/submission/105424077

Any suggestion in code or logic will be helpful.

you can find your bug with this.

Actually the input you given is wrong it should be :-

4 12

4 4 4 1

1 2 2 1

and i am getting correct output for this.

I edit it, thank. I do many tests but I can't find your bug :(

I got my error buddy here https://codeforces.com/blog/entry/87188?#comment-753549

Thanks for contest, I thought D, F and G were very nice problems for beginners.

Can anyone share a more formal proof of F? Why are 2 cases handled in the solution? What is this 'times' variable?

Here is my current algorithm with logic:

We have 2*N control variables: The flip of each row, and flip of each column. Each variable can be 0 or 1 (as the order doesn't matter)

Elements in first row are determined only by the flip of 1st row and flip of all columns. So we look at all possible cases for this that can make first row of A equal to B. We do this for 2 cases: one where first row of A is flipped, one where it isn't. (note that the columns flipped in 2 cases will be complement of each other)

Now, the flip or not of each column is fixed based on step 2. So only remaining variable is flip of each row other than 1st row. We can decide flip of each row by looking at first element in the row. Now all our variables are determined. At this point, A must equal B if the solution exists, in at least 1 of the 2 cases.

But do we need to check both cases? In case 2, the flip of each row and column will be opposite to the flip of each row and column in case 1. Therefore for each(Row,column) pair (i,e. cell). The result will be the same in either case. Therefore, it suffices to check only 1 case.

I follow this deterministic setup: where i first set first row of A as same of B by flipping columns (selecting the case where first row doesn't need flip). Then.I set first column of A as same of B by flipping rows. Then I check the other elements. Based on arguments in 1-4, this is sufficient.

Please help if I am overcomplicating this and there is a simpler understanding.

Sorry for that I will not answer your post, instead I'll describe my solution, because I don't understand editorial.

You should know from properties of XOR order does not matter, so we can reorder all operations into: perform all XORs of rows, and then all XORs of columns. Now, if any of operations is done twice then you can do nothing instead. Therefore you need to know for each of row and column do you need to perform corresponding XOR or not.

For any cell in matrix after all XORs performed value will be changed or not. So, you can make matrix of "should I change value or not" — this is actually XOR of both matrices. You could also came up with this idea if you think of question "with what I should XOR to get from matrix A get matrix B?" Let's call this matrix C! So, C = A XOR B. Also C is "what cells should I flip?". This leads us to following equal problem: if you can make C matrix from zeroes matrix, then you can make B matrix from A matrix.

How to figure out can we make C matrix from zeroes? Well... Let's split into two cases. Case 0: we don't need to XOR first row, then 0 and 1 in this row tells us: should we invert column or not. If any other row is same (identical, all 0 and 1 match first row) then after performing all columns XORs we get all we need. Otherwise, to be able to make it from zeroes, the only chance we have is to perform XOR of those rows, and to be able to make them they should look like our first row inverted.

Case 1: we need to XOR first row, then 0 will tell that we should invert this column, and 1 tell us to not invert. And similarly, if we see same row somewhere else, then we just perform XOR of row and after all XORs of columns we get what we need. And for other rows, the only chance to make them is to NOT invert them, this means they should look like our firs row inverted.

In both cases all rows of matrix C should consist of row 1 and inverted row 1. Therefore, solution is following: make matrix C, check that all rows is either identical to row 1 or identical to inversion of row 1.

Thank you very much. I understand much more clearly now

Thanks to Stepavly and Supermagzzz. The contest went well, but unfortunately, it was delayed.

For Problem G,why let the $$$\mathcal{O(\sqrt{n})}$$$ finding divisors algorithm pass!!!

For problem G, can someone please explain why is it incorrect to calculate dp in reverse. Why dp[i]=max(dp[i], cnt[i]+dp[i*j]) where i*j < 2e5 wrong? 105437344

1

1

200000

You might get a TLE anyways.

Thanks for pointing out the bug. Complexity is O(NlogN), so didn't get TLE. Accepted solution: 105442203 (doesn't require the extra step of applying sieve)

Why I get 'uninitialized value usage' error https://codeforces.com/contest/1475/submission/105439474?

Faced same issue, just move your variables declarations in global scope, outside of solve method.

Since there can be many test cases, you cannot use memory for each one. For reference (declarations outside of test cases loop): https://codeforces.com/contest/1475/submission/105419352

I face the same problem. https://codeforces.com/contest/1475/submission/105442011

your submission with other arrays declared outside of loop too:

https://codeforces.com/contest/1475/submission/105443143

Thanks a lot.

Hello everyone i just want to share my approach for problem C. I used maps to solve this problem. I stored the frequency of boys and girls and also pair of a boy and girl. Now if we want to calculate how many other couple can go with current couple. Say a is boy and b is girl we have in current couple. Then the number of couple that can go with a and b are Total couple-frequency of a in boys -frequency of b in girls + frequency of pair a, b. And do this for all couple and just divide the answer by 2 because we will count every couple 2 times.

105342359 Check this submission.

I just finished my virtual for the contest. I was analyzing my solution for F and found a mistake. But that code had already passed system tests.

105447780

The mistake I found is that I have done this operation:

(1<<1000).

This operation is not practically correct but somehow is giving correct result.

I think the System Tests are weak coz this solution should not have passed.

I'd like to propose a super simple solution for F. Just scan every 2x2 square and count the number of difference in A matrix and B matrix in matching positions, if there exist a 2x2 square in which the count of different numbers is 1 or 3, output NO, otherwise output YES. I got AC but hasn't been able to prove why. I just feel like different numbers can never come in a single square surrounded by same numbers or create an L shape.

Here is my solution, who can prove why this is correct? https://codeforces.com/contest/1475/submission/105455476

I tried D with priority queues by making different queues more important and less important respectively. But it gave wrong ans with some case.

This is my code https://codeforces.com/contest/1475/submission/105424077

Any suggestion in code or logic will be helpful.

For problem G, why can't we replace the N with max element in array a(for each test case)?

actually we can.

I tried doing that but I'm getting wrong answer(for sample test cases as well).

https://codeforces.com/contest/1475/submission/105476589 gets accepted whereas https://codeforces.com/contest/1475/submission/105476674 gets WA on test case 1 itself.

PS: Not my original solution.

Even for the official solution, changing m to max(array) gives WA.

changing m to max(array) in official code gives ac. I don't know what you are doing, but instead of blindly copying the code, try to understand how to solve the problem.

I understood how to solve except for the "m part"(only over here did I differ from the original solution when trying to code it out myself). I found the approach in the solution I linked (it's from Neal's stream) slightly easier to understand and more natural than the official solution.

https://codeforces.com/contest/1475/submission/105485752 I'm getting WA on changing value of m in the official solution too. Any idea why?

idk python well, so i cannot see what's wrong in your submission.

replace m by m + 1

Comment Retracted

I am new to cp, in the problem 3 I was able to follow the editorial to the very end but I didn't get why we are printing ans/2 instead of ans

we are counting each pair twice. We are fixing one pair and seeing all possibilities of second pair. But this first pair will also be counting again when its corresponding second pair is fixed.

If you are doing a different solution where you are counting each pair only once, then you don't need to divide by 2

O(1) solution for Problem B

Link to the solution

please someone help, from last 2 months i started codeforces and i am not able to improve my performance yet i am a on a beginner level, I think the problems on codeforces are on little mathematics side. can anyonle please help me , and suggest me some resources for solving mathematical problems.

just do div.2 a,b,c from last rounds, which most of them are based mainly on maths. If you don't know how to solve the problem, look on a editorial, and try to get an intuition what you've missed before and why you haven't solved this specific problem.

if I fail to understand the editorial, then what should I do?

come to this problem later. (it means that the gap is too huge)

What about codeforces?

https://codeforces.com/problemset?order=BY_RATING_ASC&tags=math

I am getting WA in fourth question, my approach is almost exactly as shown in this editorial code.

Can someone tell me where I am wrong? https://codeforces.com/contest/1475/submission/105487065

Editorial for 1475G - Strange Beauty is masterpiece of utterly bad editorial. Why? dp[x] is following. Here is formula. No explanations at all, why there would be numbers like that, why they indeed pairwise ok and so on.

Can someone help me understand why I got TLE?

contest : Codeforces Round #697 (Div. 3) problem : C. Ball in Berland problem link : https://codeforces.com/contest/1475/problem/C

TLE solution : https://codeforces.com/contest/1475/submission/105347180

I resubmit same code. But I got AC AC solution : https://codeforces.com/contest/1475/submission/105608300

Why did this happen?

[Deleted]

Stepavly In the problem C why did you first decrement the x and y and then increment a and b

Decrement to make indexing from zero, increment to count degree of the vertices.

in E , i am having trouble while taking mod

when i submitted without taking mod while calculating factorial then i got overflow. 106346070

but when i changed and gave mod while calculating factorial itself then , i got the answer as 0 106343305

pls someone help me out.

division doesnt work well with modulo operator, you have to use the modulo inverse instead. tho you could build pascals triangle instead, its a much simpler approach than calculating modulo inverses

oh thanks. I would try that up

I feel problem-B more easier to use these codes.

## include<bits/stdc++.h>

using namespace std; int main(){ int n; cin>>n; while(n--){ int k; cin>>k; int s; s=k/2020; if(k>=s*2020&&k<=s*2021)cout<<"YES"<<endl; else cout<<"NO"<<endl; } return 0; }

Problem C got a 100% binary search solution: 128061064 Idea: sort by boys increasing. Binary search to find first boy has larger value than the current boy. Then binary search again to find the number of boys paired with the current girl (by storing the position of all boys paired for any girl). Then add up.

Can we solve F using 2-SAT?

I tried but facing TLE submission

My Approach: 1. set up 2 SAT with 4 * n nodes. For n verticle, n horizontal and their flips. 2. Whenever we have same value in a cell in both matrix, we add a not XOR edge between that row and column. 3. Otherwise we add a XOR edge between them.

I got it easier than the method in the tutorial

In Problem B, why are we assigningn % 2020(remainder of n divided by 2020) to y (number of 2021s)? I can't intuit how that's helping us.