Really awesome, You try explaining your thought process as well while drafting editorials. Kudos!

great i know the tutorial isnt that great but u r a programmer not youtube ,it takes time don't worry.

Honestly speaking please don't make these videos, these are not helpful.

if ((i <= n) and (n % i) == 0) {
    if ((n / i) <= k)ans = min(ans, i);
    if (i <= k)ans = min(ans, n / i);
}

Try using this block of code... your code is missing the (i<=k) condition

A pair with a difference on 1 contains an odd number and an even number. Therefore removing that pair means that both the count of odd values and the count of even values is decreased by 1. We need both the count of odd values and even values to be even numbers (so that we can make pairs). Therefore if the count of odd values and even values are both odd, we can remove 1 pair with difference 1 to make them both even, and then do the rest of the pairing by parity.

We create pair of those numbers with diff 1 and after that we have even $$$e' = e - 1$$$ and $$$o' = o - 1$$$, then it is first case.

Yes and it's very neat

[user:andr0901]Can you pls explain , how did you apply flows in this .... I know max flow algorithn but not able to figure the way to proceed with that

Worked for me 81291367

can you plz explain!!

Can you please explain after shifting each row by 'a' how are we ending up filling each column by b ones ?

Yes,that works. 81375672

Do you mean Div 3.51-3.99

True dat but this was previously a div 4 contest so yay similiraty is not that uncanny !

You are calculating the maximum value of "count", i.e. the maximum number of pairs that are similar because their difference is 1. This value can be even in some cases. You should stop as soon as you find odd number of such cases (might stop simply at 1). So after subtracting "count" (which is odd) from "x" and "y" (which are both odd), the resultant "x" and "y" will be even.

Lets say you have odd no of even no's and odd no's now as soon as you find a pair with diff 1 you can stop counting as in this case count of both even and odd no's will be (as x -y == 1 if x is even and y is odd or vice — versa ) so once you have gotten one such pair the job is done !
https://mirror.codeforces.com/contest/1360/submission/81251269 you can check this for reference

I was also surprised, first they sort and then use O(n^2) complexity for judging all the pairs. xD

After checking their code, I went to check my code again for checking its correctness.

Totally agreed. Even the last questions were easy go.

can you binary search for factors of a number? not sure if you can

It is a prime no. so O(n) solutions with a break statement would fail. A lot of same test cases as a the solution might barely pass on a single test case.

I don't know much syntax in python but it is looking O(N*max(N,M)) to me. But n and m are small so no need to worry. If n>>m then it would cause problem.

I have done it in O(n*m*m). Initialise your answer with the first string and test 'm' versions of this string such that in version 'i', the ith character can be changed. For testing a version of the string, check all the characters except the one that can be changed. If the strings differ in exactly one place, then the ith character can be fixed according to the string it is being tested with. After you have changed the string, all the characters of the string should be tested. You can refer to my Solution

https://mirror.codeforces.com/contest/1360/submission/81249769

you can check my submission

Explaination: — Assuming s[0] as an answer now change every letter to a to z and check whether it is possible answer or not

Did in O(T * N * M) https://mirror.codeforces.com/contest/1360/submission/81291537

It is because this contest was previously designed as div4 and later converted to div3

check my submission

If we shift d in every row, then total shifts would be n*d. We want these shifts to be cyclic around m. Therefore n*d should be divisible by m, implies (d*n)%m=0.

yes, i did with dfs. Too dumb to realize that observation

Yes, I also solved using DFS. link to solution-81299710

The problem wants you to partition the array in pairs. A pair is valid if both of its elements have the same parity. So if you have an even amount of, for example, odd numbers in the array, it means you can already put all of them in pairs. The issue is when the number of elements of the same parity is odd. If that's the case, you would be left with one element unpaired. So the only other way to pair that element, is if there's an element that's also unpaired, from the set of numbers of the other parity.

So at the end, you can partition the array if the amount of odd numbers and even numbers are both even (as you can pair them between themselves), or if both are odd and if you can find a pair of elements of different parity whose difference is 1, making it a valid pair. Those two you choose would be the unpaired ones I mentioned. Also, this means if the number of odd numbers is even, and the number of even numbers is odd, or vice versa, you can't partition the array as you would be left with one unpaired element.

Knowing all of this, approaching the solution is counting the number of even elements and odd ones, and if you have the special case where both quantities are odd, you can easily sort the array and check for adjacent elements if their difference is 1 (as in that case they would have different parity).

You are using int and stoi.

m can be 60, but int has only 32 bits.

So, you can see stoi throwing an instance of 'std::out_of_range'

You should use long long and stoll instead

At the start, without removing any binary number, the median is 2^(m-1).

Then for each string removed:

1. If it is smaller than the current median, the median either goes up by 1 (if there is an even number of numbers left) or it stays the same (if there is an odd number of numbers left).

2. If it is more than the current median, the median either goes down by 1 (if there is an odd number of numbers left) or it stays the same (if there is an even number of numbers).

Note that you need to skip over all strings which have already been removed when you are going up or down by 1.

Here's my submission if you need it: 81298077.

And I really didn't understand the editorial for D !

You are iterating for 1 to k linearly and k can be as large as 1e9. You can perform upto around 1e8 iterations in 1 second time limit. That is why time limit is exceeded. Find a way to find divisors of n in less than linear time. See editorial for that.

it's awesome, but why?

update:
understand, first n * a == m * b, that is count of '1', we can know that fact:
n * a >= m and n * a mod m = 0 and n * a / m = b.
make n * a divide by m, exactly perm b block, each block have m count of '1', distribute them by index [0, m — 1]. finally we get each index in [0, m — 1] count b times(for column).
for row, distribute n * a by divide a, also get index in [0, n — 1] count a times.

You should put in if condition if (a%i==0 && i<=k) { ans=min(ans,a/i); if (a%(a/i)==0 && a/i<=k) ans=min(ans,a/(a/i) ) }

atcually, it was fastIO is from PyRival https://gist.github.com/ShubhamKJha/f16f5eb7e6da41da5f4b95d004b55d6e

First you must look whether answer is YES/NO. This can be easily be checked if a*n == b*m.

Now as you have asked how to notice the pattern , let me explain my thought process in approaching the answer.

First check on most basic cases. Ex. n=2, m=2, a=1, b=1. You may easily visualize it as a 2X2 matrix which has all the elements along main diagonal = 1 and rest = 0.

Now try a=2, b=2. When you check such 3 to 4 basic cases you will start finding a pattern.

So rather than trying to find answer for some random cases try building it step by step, you will figure out the way. This is not just an answer to a particular question, but rather applies to a variety of problems that require keen observation skills.

I hope this is what you wanted.

Wrong link kid.

In the matrix you can change the order of rows and columns, it is still valid. Which means order does not matter, we just have to distribute the 1 somewhat evenly.

I have similar solution to that of editorial.We have to first check if $$$a.n=b.m$$$ . If it holds we can construct the solution in following way : in first row fill '$$$a$$$' number of 1's . In second row start from a+1 column and fill '$$$a$$$' number of 1's and so on (if anytime position reaches beyond $$$m$$$ , change it to 1) . Since $$$b.m$$$ is divisible by $$$m$$$ , thus 1's are evenly distributed across all the columns. submission

You are only trying the largest factor <= sqrt(n) and n/largest_factor. So, you missed some factors.

Wrong Test Case: 1 36 4

Your Output: 36

Correct Output: 9 (9*4=36)

please make your array char and add this to if

i != n - 1 && j != n - 1

P.S Do not forget a[i][j]=='1' not a[i][j] = 1

I am not able to understand can you explain again, why are we increasing X if a[i] <= X and what if we delete median itself ?

For a matrix of size $$$h * w$$$, let's represent the total number of ones in each column as a frequency array $$$F$$$ of length $$$w$$$ initially filled with zeros and for each time we place a 1 in the $$$i-th$$$ row and the $$$j-th$$$ column we increment $$$F[j]$$$, and let's periodically fill this array as the solution states, for example let $$$h = 4, w = 4, a = 2, b = 2$$$,

Iteration 1: $$$F = {1, 1, 0, 0}$$$ filling the first two columns in the 1st row

Iteration 2: $$$F = {1, 1, 1, 1}$$$ filling the second two columns in the 2nd row

Iteration 3: $$$F = {2, 2, 1, 1}$$$ filling the first two columns in the 3rd row

Iteration 4: $$$F = {2, 2, 2, 2}$$$ filling the second two columns in the 4th row

If a solution exists for a matrix of size $$$h * w$$$, we know for a fact that $$$h * a = b * w$$$. Observe from the example above that the total number of times we iterate $$$F$$$ (the number of times we iterated all $$$w$$$ elements of $$$F$$$) is equal to the total number of ones we have to place in the matrix divided by the size of $$$F$$$ which is equal to $$$(h * a) / w = b$$$, therefore, after we're done filling the matrix we know that for all $$$ (1 <= i <= w)$$$ $$$F[i] = b$$$