MeToo

4 years ago, # ^ |

← Rev. 2 →

let HI be the highest value that is adjacent to a -1. let LO be the lowest value that is adjacent to a -1. the value of k is equal to (HI + LO) / 2. let DIF be the maximum difference between two adjacent elements that are different from -1. the answer would be the maximum between DIF and the maximum between HI — k and k — LO.

→ Reply

TO_OO_EndGame

4 years ago, # ^ |

I have done what you said but still WA

My WA solution code

→ Reply

4 years ago, # ^ |

I think your code has some bugs and you are not doing exactly what I said. if you try: 5 1 2 3 4 -1 your program outputs something wrong. Try coding again in a simpler way.

→ Reply

pranay_garg

4 years ago, # ^ |

Can you please explain logic behind this solution?.

→ Reply

4 years ago, # ^ |

all the -1's will be replace by k. so you only need to take care of the minimum and the maximum neighbors because the maximum difference between k and any number between LO and HI will always be less than or equal to the maximum between |HI — k| and |k — LO|.

→ Reply

pranay_garg

4 years ago, # ^ |

Thanks.!

→ Reply

charles2307

4 years ago, # ^ |

hey I tried finding the lowest positive and greatest positive numbers and assign the K= average of the two number and then find the maximum adjacent difference what was wrong in this approach

→ Reply

havefunn

4 years ago, # ^ |

lowest positive and greatest positive numbers should be adjacent to -1

→ Reply

Sibin_Thomas

4 years ago, # ^ |

Why are we searching lowest and highest which are adjacent to -1? Why not the whole array except -1?

→ Reply

havefunn

4 years ago, # ^ |

100 99 98 97 96 -1 0 for this case we should put 48 at -1's place but if you search highest and lowest you will put 50 which will be incorrect. Hope this clarifies

→ Reply

Gary2005

4 years ago, # |

Why O(log*m*n*k) got "TLE" on problem F??

→ Reply

Time2000

4 years ago, # |

+10

how to solve C??

→ Reply

dantrag

4 years ago, # ^ |

+10

In fact, you need to minimize the number of pairs $$$(l, r)$$$ such that substring $$$s[l:r]$$$ contains only zeroes. This can be calculated separately for each group of adjacent zeroes. For a group of $$$x$$$ adjacent zeroes it is $$$x(x + 1)$$$. So the problem can be rephrased like this:

$$$\text{Split } n - m \text{ into several numbers } a_i \text{ such that } \sum a_i(a_i + 1) \text{ is minimum possible}$$$

It is easy to see that the solution to this problem is to: (1) split $$$n - m$$$ into as many numbers as possible (keep in mind that you cannot have more than $$$m + 1$$$ groups of zeroes); (2) when splitting, make $$$a_i$$$ as equal as possible.

→ Reply

burt_macklin_

4 years ago, # ^ |

Intuitively I agree with you. But, what’s the formal proof of your last statement i.e. splitting them as much and as equally as possible will yield the lowest desired value?

→ Reply

dantrag

4 years ago, # ^ |

Assume you have the "lowest" splitting. If there are number with difference > 1, you can always make the result lower. Let's say you have $$$a$$$ and $$$a+x$$$ in the splitting, and $$$x$$$ > 1. Then compare:

$$$a^2 + (a+x)^2 \text{ vs } (a + 1)^2 + (a + x - 1)^2$$$

This reduces to

$$$0 < 2 - 2x$$$

In other words, if $x$ > 1, the reduction of the gap between numbers always reduces the sum of squares. Then the minimum sum will be if the largest gap between numbers is 0 (if possible), otherwise 1. You can easily show that such reduction does not take infinite time.

→ Reply

4 years ago, # ^ |

you need to minimize the largest substring that only contains 0's. to do this you just need to distribute the 0's between the ones. for example if n is 8 and m is 2 is should be distributed like 00100100. then to count them you have to count the number of substrings n * (n + 1) / 2 then subtract the number of substrings that contains only 0's, to count that you need to divide the number of 0's by the number of ones + 1, and count separately the regions that contain one more 0 than the others (if the number of 0's is not divisible by the number of ones + 1) for example if n is 10 and m is 2 the distribution would be something like 0001000100

→ Reply

ezdp

4 years ago, # ^ |

Imagine the string as groups of zeroes separated by ones. The answer will be the number of all substrings — the number substrings in each group of zeores(Z). To achieve the highest answer to the original problem we want the number of substrings in each group to be the lowest.

We achieve that by spreading all zeroes in as many groups as evenly as possible. the groups(G) will be n — m if n — m <= m and m + 1 otherwise(write down some cases and you will see why, that how I found that during the contest). The number of zeroes in the groups will be their overall count of zeroes divided by the number of groups. If we have reminder(R) in this division then we can put 1 extra zero in Z % G groups to keep the zeroes as evenly as possible spread.

By now we have G — R groups of Z zeroes and R groups of Z + 1 zeroes and using that we can calculate the answer as ((n + 1) * n / 2) — (G — R) * ((Z + 1) * Z / 2) + R * ((Z + 2) * (Z + 1) / 2).

I hope that was helpful :)

→ Reply

maverick16

4 years ago, # |

← Rev. 2 →

+17

for people looking to improve their algorithmic coding skills, is giving contests based on heavy implementation, of any use?

→ Reply

barun511

4 years ago, # ^ |

I enjoyed the implementation — which has it's own set of puzzles. Unfortunately I forgot to remove a debugging infinite loop counter before submitting, :( I'm gonna kill myself if my code actually passes after removing the counter.

→ Reply

sahil.kalamkar

4 years ago, # |

How to solve B? I tried Binary search on m, but it failed on pretest 2.

→ Reply

mpily

4 years ago, # ^ |

If the largest element that is adjacent to a -1 is a and the smallest element that is adjacent to a -1 is b, then we should set all -1's to be the average of a and b say c and that will minimise the differences. the maximum difference will be max(maximum difference between the elements that were already defined,c-a,b-c )

→ Reply

ritik_patel05

4 years ago, # ^ |

← Rev. 2 →

I solved it with binary search,

You can take a look at my implementation.

A.C Submission

If you have any doubts, you can ask.

→ Reply

bhasky_06

4 years ago, # ^ |

can you explain how you found that the function is monotic so that binary search can be applied

→ Reply

ritik_patel05

4 years ago, # ^ |

I just wrote some cases on paper and observed the pattern.That worked for me.

→ Reply

Bashar

4 years ago, # ^ |

Can you explain how your code works?

→ Reply

ritik_patel05

4 years ago, # ^ |

Consider the point i found while binary searching at current state is 'x'.

Then if, f(x) < f(x + 1) you can observe that the minimum point is lying at lower x than the current one. So I make high = x.

Else if, f(x) > f(x + 1) than the minimum point is lying at higher x than the current one. So I make low = x + 1.

And, to avoid any error. I make answer as the minimum of(low, high).

I hope you understood. I am not that good at explaining.

→ Reply

aliraiisrohani

4 years ago, # |

Can we solve D with euler tour?

→ Reply

4 years ago, # ^ |

I tried it with euler circuit.The conditions of euler circuit are satisfied for all matrices i believe.

→ Reply

architrungta120

4 years ago, # ^ |

Yes. That's what kinda what I did. I found an euler tour that also ran through all the edges.

→ Reply

julianferres

4 years ago, # |

O(t) solution of problem C in Python gets TLE while the same code in C++ AC

→ Reply

Tomii9273

4 years ago, # ^ |

My O(t) solution got TLE in PyPy3 but got AC (795 ms) in Python3. They are the same code. Are there any strange testcases?

→ Reply

okkkk

4 years ago, # ^ |

if you append your answers in an array and print at last, it will pass

→ Reply

at.f

4 years ago, # ^ |

I had no luck on both pypy and python 3. However switching from input() to sys.stdin.readline() made it pass (even though testing on my local machine the latter isn't supposed to be faster, both versions take around 500-600ms).

→ Reply

YashShah

4 years ago, # ^ |

Use the Fast I/O Method As the number of Test cases is about 1e5, So you have to take input 1e5 times. Therefore Fast I/O reduces some time.

→ Reply

Tomii9273

4 years ago, # ^ |

← Rev. 2 →

I tried switching from input() to sys.stdin.readline(), and my solution passed both in PyPy3 (748-779 ms) and in Python3 (701 ms). I'll use this fast I/O method from the next contest. Thank you.

→ Reply

julianferres

4 years ago, # ^ |

I use this fastIO usually. I forgot to use it in this problem, but it helps me a lot with big I/O in several problems:

def fastio():
    import sys
    from io import StringIO
    from atexit import register
    global input
    sys.stdin = StringIO(sys.stdin.read())
    input = lambda : sys.stdin.readline().rstrip()
    sys.stdout = StringIO()
    register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

→ Reply

HanaYukii

4 years ago, # |

← Rev. 3 →

Can anyone tell me if my approach is wrong or i have some implement mistakes.

I just calculate the same color square size of every grid being bottom right.

Then check if every grid can be bottom right with the same color square size * 4.

Then build 2D prefix sum table for query.

submission

→ Reply

DankCommenter

4 years ago, # |

+31

What's up with the problemsetters these days? Are they competing on who can make the worst problems? Then I have to say that they did really well this time.

Congratulations!

→ Reply

thenymphsofdelphi

4 years ago, # |

+98

→ Reply

Vovkaez

4 years ago, # |

Can anybody find out why my C submission is wrong? (https://codeforces.com/contest/1301/submission/71007756)

I see guys with literally same code get AC

→ Reply

Bsher

4 years ago, # |

for a moment I thought I'm in Div1 round

→ Reply

A-m-z

4 years ago, # ^ |

-35

all codeforces rounds are like this recently. also انت طري

→ Reply

4 years ago, # |

Anyone else tried D with Euler Circuit?

→ Reply

4 years ago, # ^ |

There is a constraint in output that $$$a\leq3000$$$. So Euler Circuit doesn't work.

→ Reply

4 years ago, # ^ |

I tried to compress the string formed afterwards.

→ Reply

4 years ago, # ^ |

I mean if you just copy a general implementation of Euler Circuit, 99% $$$a$$$ will be greater than 3000 (even if you compress the euler circuit). So you have to construct the Euler Circuit by yourself. Actually there is a easy way to make $$$a\approx3n$$$.

→ Reply

4 years ago, # ^ |

for a full test case, the lenght of the euler circuit is nearly $$$10^6$$$, it is almost impossible to compress its length into $$$\frac{1}{300}$$$ of the original length.

→ Reply

4 years ago, # ^ |

Yeah i get what you are trying to say but what I did is a tad different from some optimal compression technique.I found that string "RUL" was repeating numerous times in the circuit, and then compressed it afterwards.I didn't know any other way to find some sort of pattern in the graph and brute was a bit too difficult for me.

→ Reply

4 years ago, # ^ |

my code here

(please ignore my heads)

→ Reply

4 years ago, # ^ |

To go through a row, a easy way is to use (m-1,"R") and (m-1,"L"). To optimise, use (m-1,"RDU") and (m-1,"L") if possible. After that, there is no vertical edge left except the first column.

→ Reply

4 years ago, # ^ |

Aah, got it.Thanks!

→ Reply

Devil

4 years ago, # ^ |

"for a full test case, the lenght of the euler circuit is nearly $$$10^6$$$, it is ~~almost~~ not impossible to compress its length into $$$\frac{1}{300}$$$ of the original length" 70990140

→ Reply

longhuenchan

4 years ago, # |

+24

Why are recent rounds be like ManyCasesPerCaseForces?

→ Reply

lego0901

4 years ago, # |

How to solve E?

→ Reply

longhuenchan

4 years ago, # ^ |

← Rev. 4 →

+11

Calculate 2D prefix sums for each colour.

For each possible size $$$i$$$ ($$$1$$$ to half of $$$n$$$ or $$$m$$$) and each possible position, calculate whether you can make the required shape by checking if the partial sums of each colour in respective regions are equal to $$$i^2$$$, and if so mark it down (e.g. on top-left corner). Do partial sums on each possible size.

To answer a query, binary search on the largest possible size. The partial sums you just calculated helps you determine if there exists at least one square of such size.

Time complexity: $$$O(n^3 + q log n)$$$

I realized it can be binary searched after the contest.

→ Reply

lego0901

4 years ago, # ^ |

Wow.. What an amazing solution. I've never thought that was related to binary search. Thanks a lot!

→ Reply