Educational Codeforces Round 108 [Rated for Div. 2]

4 years ago, # |

+12

I hope I get that scolarship ...

→ Reply

RakibJoy

4 years ago, # |

← Rev. 3 →

+56

I think preliminary rating change in educational rounds will be great.

→ Reply

antontrygub

4 years ago, # ^ |

-108

Wow! such big brain! and after every hack, rating changes of all 25,000 participants will be recalculated! No problem sir! I will put the word through to Mike

→ Reply

weebsdontdie

4 years ago, # ^ |

← Rev. 2 →

+91

Uhm no? Just do it twice. Once after the contest ends, and the second one when the hacking phase ends. Stop trying to act smart you idiot.

PS — We have rating predictor extensions so prelim rating changes are not really needed.

→ Reply

primus7

4 years ago, # ^ |

It would be helpful if you could share the extension you find good.

→ Reply

_Kana_

4 years ago, # ^ |

+14

Search cf-predictor on your favorite search engine.

→ Reply

primus7

4 years ago, # ^ |

thanks.

→ Reply

ADO

4 years ago, # ^ |

now, from this case, I'm not sure that having predictor extension with such difference is enough :)

→ Reply

Madhur_V

4 years ago, # |

9th rated contest of the month. Hail Codeforces!

→ Reply

corpulent

4 years ago, # |

+26

A long break bruh, Codechef also postponed the Lunchtime.

→ Reply

Odysseus96

4 years ago, # ^ |

Lunchtime is Tomorrow. And Amazon is hiring via Lunchtime.

→ Reply

nitesh.dtu

4 years ago, # ^ |

Did anyone ever recieved any message from companies hiring through codechef ?

→ Reply

4 years ago, # ^ |

Yup I did recieved ... and one of my friend landed an interview too

→ Reply

r-tron18

4 years ago, # ^ |

Explain. What was your rank in cookoff and April long. what about your friend

→ Reply

4 years ago, # ^ |

← Rev. 2 →

Not in april ...through jan;s long chanllege . We both were under 200 , I was in div.1 and he was in div 2

→ Reply

archishman1808

4 years ago, # ^ |

Is this from cookoff or long challenge? because you know what long challenge means :)

→ Reply

4 years ago, # ^ |

-6

You can get selected from long too ... if there is no plag in your codes. Codechef do check for plag you know.

→ Reply

archishman1808

4 years ago, # ^ |

and the hiring is internship or full time?

→ Reply

4 years ago, # ^ |

They were hiring for internship n full time ... Time time I guess it is for coders with experience

→ Reply

4 years ago, # ^ |

Lol Came for editorials, But stayed for the joker.

This is his solution https://www.codechef.com/viewsolution/43852245

this are other coders solutions https://www.codechef.com/viewsolution/43852488 https://www.codechef.com/viewsolution/43852283

see how there all there codes contain roast, lund and other stuff.

Seems like u got interviews even after cheating

Please Flag this person People. I am 100% sure he has bought the solution over telegram. The user is arpit0891 https://www.codechef.com/viewsolution/43852283

and i also have his linkedin.

Please flag this user. he might have cheated in codeforces too

→ Reply

vj12

4 years ago, # ^ |

Actually It was me who took his solutions and sold it on telegram . He gave me his password for some work.

→ Reply

4 years ago, # ^ |

Nope. You can check submission time on codechef. He submitted 40 minutes before the contest expired. Also i know this is a fake profile vj12. so do that someplace else. You sure have a lot of time arpit0891 to do this fake stuff and upvote your own comment from different profile.

But assuming you are genuine. This is still bad. Indulging in cheating is as bad as letting others cheat. Thanks for making it more easy for us. Regards

→ Reply

4 years ago, # ^ |

After this leak I stopped using that account . I made a newone and participate though that only .

→ Reply

4 years ago, # ^ |

That happened in January 2021,Feb 2021 and then March 2021, I hope all are leaks else they will be cheating.......

→ Reply

4 years ago, # ^ |

The account is closed as of now .

→ Reply

nitesh.dtu

4 years ago, # ^ |

And which division ? Like i can participate in div3 and get a lot better rank than div1

→ Reply

4 years ago, # ^ |

-6

You can't compete between divisions

→ Reply

4 years ago, # ^ |

He is in the cheating division

→ Reply

4 years ago, # |

i am very excited to participate the contest,wooooooo~

→ Reply

sdh

4 years ago, # |

Almost every edu round I was "educated", but I still participate in every round...

→ Reply

4 years ago, # ^ |

your spirit deserves me to learn

→ Reply

your.nemesis

4 years ago, # |

"The penalty for each incorrect submission until the submission with a full solution is 10 minutes"

Does this mean that only time will be taken and there wont be a -50 or -100?

→ Reply

Sundaram_Sharma

4 years ago, # ^ |

yes

→ Reply

pratikraut0000

4 years ago, # |

Today codeforces educational round. Tomorrow codechef lunchtime. Day after Tomorrow CodeJam Round 1C. Practice & Compete & Improve.

→ Reply

4 years ago, # ^ |

waoooo~

→ Reply

TarTagLia

4 years ago, # ^ |

then day after global

→ Reply

madhav._.maddy

4 years ago, # |

hope i remain expert after this contest :)

→ Reply

wizzzzzard

4 years ago, # ^ |

It'll be alright, Ron!

→ Reply

4 years ago, # ^ |

me too,good luck bro

→ Reply

wargang

4 years ago, # ^ |

You say this in every contest.

→ Reply

ChinmayKarnik

4 years ago, # |

+36

Time to start the vacations with an educational round. Excited!

→ Reply

https://mirror.codeforces.com/contest/1519/submission/114607388

4 years ago, # ^ |

+26

wish to have a good vacation

→ Reply

Bunik

4 years ago, # |

+12

I wish B/C not to be a observational shit like printing the array upto k and then upto n-k lol.

→ Reply

dash_______

4 years ago, # |

+18

Hakcers will try to hack the solution in 12 hrs, while cheat busters will try to match the solutions in 12hrs.......

→ Reply

dm89f11

4 years ago, # |

i hope i do best in the contest and happy coding to everyone

→ Reply

Harsh1610

4 years ago, # |

Have a great rating change

→ Reply

Horcrux1729

4 years ago, # |

Nice contest!

→ Reply

newbie_forever_at_cp

4 years ago, # |

← Rev. 3 →

+122

Today's Problem Difficulty. Pls forgive me for not enlarging the image as I dont know how to do that.

Today's Problem Difficulty

→ Reply

zarif_2002

4 years ago, # ^ |

-27

B and D is almost same difficulty level though

→ Reply

krazy8

4 years ago, # ^ |

-10

B<A<C<<D<<<<<<E/F

→ Reply

JulSjlv

4 years ago, # ^ |

+16

C took me an hour... D took me 10 mins...

→ Reply

I_will_never_cheat_again

4 years ago, # ^ |

← Rev. 3 →

-7

How did you do it? I did similar to longest palindromic substring. fixed pivot for both odd length subarray and even length subarray and then extended both sides.
Time complexity: n^2

→ Reply

JulSjlv

4 years ago, # ^ |

← Rev. 5 →

Basically, yeah, what you did.

For each position in the array i I tried generating an even length subarray and uneven length subarray that begins with that position as the middle or one of the middle elements. At each iteration add one more in each end so that the new subarray is continuous. Notice that moving through them like this maintains the position of the ones inside, so you just have to see what difference the new ends would make. O(n^2) time, O(n) memory.

→ Reply

Durgeshmaurya07

4 years ago, # |

-81

sometimes unexpected bruteforce works . Today it worked for problem C for me

→ Reply

AlexLorintz

4 years ago, # ^ |

+15

Can you wait till the end and not spoil solutions?

→ Reply

Dan4Life

4 years ago, # ^ |

Its not "unexpected" since its not hard to figure out why it doesn't tle

→ Reply

rkguptagkp462

4 years ago, # ^ |

← Rev. 2 →

yes and I coded only after I got n*root(n) bound for it :(. If we do only, take contribution from 1 to size of students in university for Ks. As, if the size of such universities is more than root(n), then their number will be less than root(n), so n*root(n) here and if the size of universities is less than root(n), then O(n) such universities can be there but k:1 to root(n) for such, so again n*root(n). So, overall complexity is n*root(n). The complexity might be less than this, but this was enough.

→ Reply

jimm89

4 years ago, # ^ |

He did TLE after the hacking phase with the additional tests

→ Reply

alexrider

4 years ago, # ^ |

i too did bruteforce in C. Got TLE. can you tell me where I went wrong? I can't think of any more optimisation. :/

link to my submission.

→ Reply

warr

4 years ago, # ^ |

← Rev. 2 →

Your brute force solution works in O(n^2) time as you try every n university for every possible k (which k==n), it won't pass since n^2 = 10^10 ~ 100 seconds. But if you observe the problem, you will see that after the number of people in university > k, you don't need to check it again as the number of teams will be 0. You can somehow remove that university from your checking list (effectively). This will improve the solution a lot. My submission: https://mirror.codeforces.com/contest/1519/submission/114578952

→ Reply

Sundaram_Sharma

4 years ago, # ^ |

But why doesn't n^2 work when time limit is 2 seconds. I have encountered this situation in some other problems as well. Sometimes, n^2 works for 2 seconds sometimes it doesn't. Is it because of the heavy calculations ?

→ Reply

prasanna2425

4 years ago, # ^ |

Whether n^2 works in 2 seconds or not depends upon the size of n. Although I would try to give a rough idea that what kind of solution can run in 2 seconds. In one seconds a normal loop would run near about 10^8 times in c++. It is only a rough estimation. In C the value of n was 2 * 10^5. If we square it, the result goes to 4 * 10^10. To run this solution at least, 400 seconds are required (again a rough estimation). So it definitly won't run in 2 seconds. Your assumptions that sometimes an n^2 solution runs in two seconds would be right when n is small. For n valued this large, an n^2 solution would never run, if the test cases are good.

→ Reply

4 years ago, # ^ |

Probably You are getting TLE due to a very little mistake. Do check it out here. Link to Explanation

→ Reply

PhantomAssassin

4 years ago, # |

+48

Speedforces

→ Reply

Mayank0811

4 years ago, # ^ |

true lol

→ Reply

polingram

4 years ago, # |

+18

Does anyone with O(2*n^2) space got MLE in D?

→ Reply

rahulpkvij

4 years ago, # ^ |

← Rev. 2 →

You will get MLE because final answer can be equal to 5*10^17 which needs to be stored in long long int. 2*5000*5000*8 contiguous allocation is not possible (In case you used DP).

→ Reply

polingram

4 years ago, # ^ |

YA right but my O(N^2) python also getting MLE in 11 , I wonder why?

→ Reply

https://mirror.codeforces.com/blog/entry/54604 F

4 years ago, # ^ |

← Rev. 3 →

Because Test 11 forces python into long arithmetic. If you will different algorithm to get rid of O(n**2) memory allocation you'll get TLE on 11 test. Then you'll need to do a little math, to get rid of excess of multiplication in your formula. Python often turn out to be pain here on codeforces :)

→ Reply

wargang

4 years ago, # ^ |

Same happened with me. MLE

cost me atleat 400 rank.

→ Reply

AlexLorintz

4 years ago, # |

+45

Probably there's like around 5 people right now writing "SPEEEED FORCES"(joking of course:)). I think this problem could have been avoided if E was more "div2-solvable", I mean around 60 people solved it and a good amount of them are red coders. There's no point I think in making A-D so standard(especially D) and E that hard.

→ Reply

kwangg

4 years ago, # ^ |

+25

Pretty crazy variance. Solving A through D could either get you 60th place (with an implied rating of about 2250 according to cf-rating-predictor, which is orange), or as low as 2400th place (with an implied rating of about 1640, which is blue).

→ Reply

AwakeAnay

4 years ago, # |

+75

Really liked $$$E$$$. I wonder if everyone solved it the way I did.

My Solution

→ Reply

an0nym0us_m0use

4 years ago, # ^ |

+19

Interesting. I just used a known algorithm, which is given a graph cover it with paths of length 2 using a DFS. Seems most other people did it this way as well.

→ Reply

16204

4 years ago, # ^ |

+28

Can you describe said algorithm? I wasn't aware of it's existence.

→ Reply

dorijanlendvaj

4 years ago, # ^ |

+22

→ Reply

4 years ago, # ^ |

← Rev. 2 →

+11

Interesting! I didn't know about this algorithm.

As I understand (after reading the Editorial to the task dorijanlendvaj posted), to apply this algorithm you transform the task in the following way: Each line through the origin will be a node. Each Point will be an edge and it connects the two lines to which it can be moved. Now we want to find edge-pairs which are connected to the same node. Those pairs should be mutually disjoint.

While I was thinking about this problem I somehow was only thinking about the other way round: For me each point was a node. Two nodes are connected, if the corresponding points can be moved onto the same line through the origin. Now I tried to find the maximum amount of disjoint node-pairs connected by an edge. (This is the Line Graph of the first interpretation).

So what I learned: Sometimes you should switch edges and nodes in your analysis/interpretation of a problem, maybe this will make the problem easier.

→ Reply

buriXzura

4 years ago, # ^ |

← Rev. 3 →

If we consider the points as vertices and connect two vertices iff they'll lie on the same line passing through origin after shifting them. Then this problem will reduce to finding maximum matching in the graph, right? But that is too general. As in our graph let's say a is connected to b,c,d then a is a part of at most 2 cliques which is ({a,b,c,d}) or ({a,b},{a,c,d}) , or, ... etc .

So by considering a line as a vertex, we have somehow used this property, right?

→ Reply

4 years ago, # ^ |

← Rev. 2 →

Hey Zura,

Theanks for pointing me to the maximum matching problem . That is exactly what should be solved in the second interpretation!

Im not sure about your other comments though. Which property do you mean? I feel like we lose properties by looking at the linegraph, because the problem can't be solved with a simple DFS anymore.

Maybe it's good to look at an example? e.g. {(1,2),(2,3),(3,4),(4,5),(5,6),(1,6)} (The first 5 points all can be moved on the main diagonal, and the 1st and 6th point can be moved on a common line) would have those two graphs in the corresponding interpretations:

The possible solutions are the same in both cases. Could you explain again what you meant, possibly with the example (or an own example)?

→ Reply

buriXzura

4 years ago, # ^ |

1st and 6th can't be moved on the same line as the first ones' slope would be (2+1)/1=3 and for 6th it is (1+1)/6=1/3.

Other than that as I was pointing out 1,..,5 forms a clique.

If 6th point were (2,5) and 7th were (3,8) then 1 is contained in two cliques 1,..,5 and 1,6,7. So by considering when we use a line as vertex we are basically accounting for this whole clique.

I am unable to understand any further than that though, so waiting for the tutorial.

→ Reply

4 years ago, # ^ |

Oops, i meant (1,6) instead of (6,1). Fixed it in my post.

→ Reply

4 years ago, # ^ |

Why switch if you reduced problem to kuhn-munkres algorithm? You mean that you could do better with dp than O(n*m)?

→ Reply

buriXzura

4 years ago, # ^ |

← Rev. 3 →

No, The property that I stated in the previous comment, at most 2 cliques, will help us as we have not utilized all the components of the problem. I don't know how to model this property, but these additional bits help us, and hence we can do better than Blossom's as that is for general graphs.

Blossom's is for general graphs.

→ Reply

4 years ago, # ^ |

Could you elaborate? Do you mean kuhn-munkres ? This sounds to be an algorithm for bipartite graphs, but the second interpretation doesn't yield a bipartite graph.

→ Reply

4 years ago, # ^ |

Yep, you are right. My mistake.

→ Reply

4 years ago, # ^ |

You can use the Blossom Algorithm though with $$$O(V^2E)$$$ or $$$O(\sqrt{V}E)$$$ with "the much more complicated algorithm of Micali and Vazirani".

Guess we should stay with the first interpretation, or somehow use the information that the graph in the second interpretation is a line graph of some other graph (of the first interpretation).

→ Reply

4 years ago, # ^ |

← Rev. 3 →

Couldn't get it when I read it first time, (an0nym0us_m0use, czhang2718) but now I think I understand :) Looks like it will really work greedily with every connected component as stated above: While doing DFS on a graph until you met visited vertex or deadend-vertex, then you come out of current vertex and connect all unconnected pairs of children (those that were left unconnected when you left them). And if there 1 left — you connect it to current vertex, else — you return in to it's parent as "unconnected" yet. Then parent repeat the process. And the number of unconnected points in answer will be the number of even-numbered-components.

And that will work for any of two graphs. It's nice that they delayed editorial :)

→ Reply

https://www.codechef.com/APRIL21A/problems/PAIRFLIP/

4 years ago, # ^ |

Yes exactly that! I also did my submission 114692979 that way and it got accepted right away. The DFS-logic is in the "dfs" method and does exactly as you explain. :)

But what do you mean with "any of two graphs"?

→ Reply

CoderAnshu

4 years ago, # ^ |

+17

Two almost same problems :

https://mirror.codeforces.com/problemset/gymProblem/102001/K

→ Reply

Saransh_30

4 years ago, # |

B destroyed my confidence.

→ Reply

LinkinPony

4 years ago, # |

Could we solve D with $$$n$$$ times FFT? My $$$O(n^2 \log n)$$$ solution can't pass this TL :(

→ Reply

rguy23

4 years ago, # ^ |

Numbers were very large, how will you apply FFT?

→ Reply

LinkinPony

4 years ago, # ^ |

Just brute-force points of the reversed subarray $$$[L,R]$$$.

For each $$$R \in [1,n]$$$, we calculate $$$C = A[0..R-1] * B[0..R-1]$$$, and $$$*$$$ presents convolution. Then $$$C[i-1]$$$ is the value of reversed subarray $$$[i - R + 1,R-1]$$$, it's easy to calculate the max contribution of all reversed subarray ended at $$$R-1$$$.

The single round's time complexity is $$$O(n\log n)$$$ and the total is $$$O(n^2\log n)$$$. You can see my code here: 114607269

→ Reply

rguy23

4 years ago, # ^ |

Yes, you are right. I wanted to say that FFT will have precision issues while handling large numbers. The sum can go upto $$$10^{19}$$$ for subarrays. Such large values cannot be handled.

→ Reply

LinkinPony

4 years ago, # ^ |

I found that issue later xD. At first I even didn't consider precision,and long double has no hope to squeeze in this TL.

→ Reply

Plasmatic

4 years ago, # ^ |

FFT has a large constant factor. But also, for $$$n=5000$$$ I think it should be quite difficult to get any $$$n^2 \log{n}$$$ solution to pass, much less FFT.

→ Reply

steinum

4 years ago, # ^ |

my solution didn't pass also. 114602456 . looking for a AC solution with FFT. or its impossible with such time limit !!

→ Reply

Stream_Cipher

4 years ago, # |

how to solve D

→ Reply

EJOI_Gold

4 years ago, # ^ |

I solved this problem using DP.Here is the link of my submission: https://mirror.codeforces.com/contest/1519/submission/114578483

→ Reply

shivamSha_123

4 years ago, # ^ |

Can u please explain the logic behind the DP solution?

→ Reply

EJOI_Gold

4 years ago, # ^ |

Let dp[l][r] be the sum of ai*bi ( i is between l and r) when we reverse subsegment [l,r].Sum of ai*bi(i is between l+1 and r-1) when we reverse subsegment [l,r] is same when we reverse subsegment [l+1,r-1]. Then dp[l][r]=a[l]*b[r]+a[r]*b[l]+dp[l+1][r-1]; Pref[i] is sum of ai*bi(i is between 1 and i),suff[i] is sum of ai*bi(i is between i and n). Than,we check if we reverse subsegment [l,r] than result is : pref[i-1]+dp[l][r]+suff[r+1]; Maximum of all of these results is our final answer.

→ Reply

4 years ago, # ^ |

I have solved in O(n^2) time using DP. Video Explanation and Solutions

→ Reply

TarTagLia

4 years ago, # ^ |

D is similar to finding the longest palindromic substring, suppose you want to find ans why reversing index i to j, so instead of calculating whole i to j we can make use of ans of i+1,j-1 and add it to ans of end points(i,j).

for mode detail here: my soln :https://mirror.codeforces.com/contest/1519/submission/114607034 here's the link of classic problem which I think my soln is based upon:https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/

→ Reply

cobax

4 years ago, # |

+18

In E, I was able to group together the points that can be taken together in one move. But, how to make pairs? is it some sort of matching problem?

→ Reply

czhang2718

4 years ago, # ^ |

I'm not sure what intended is, but we can do tree DP: think of each point as connecting two slopes. Then, create the DFS tree from this graph. Now, the question is what's the maximum number of 2-length paths we can partition this graph into. Then, for each subtree, let's greedily partition it. Let dp[x]=whether we need to reserve the edge going to x's parent. Then we can greedily match x's immediate children with DP value 1, and back edges leading up to x. dp[x]=[whether the count of such nodes is odd].

Now, we can easily obtain our answer by keeping track of which edges refer to which original points. This is optimal because the number of extra/unused edges at the end is 0 or 1.

→ Reply

4 years ago, # ^ |

This graph doesn't look like a tree.

→ Reply

czhang2718

4 years ago, # ^ |

Yeah it isn't necessarily a tree- we construct a DFS tree out of it.

→ Reply

Video Solutions For Problems A — D

4 years ago, # ^ |

Ah, got it.

→ Reply

WitchOfTruth

4 years ago, # |

+22

D was so easy compared to C

→ Reply

Stream_Cipher

4 years ago, # ^ |

can you please explain your approach

→ Reply

WitchOfTruth

4 years ago, # ^ |

← Rev. 2 →

There are n^2 subarrays, get answer for all of them and print the max

Probably the best way to iterate over them is by iterating all possible centers

Use the fact that you can calculate answer for A[0:10000] for O(1) if you know the answer for A[1:9999]

→ Reply

Continuous

4 years ago, # ^ |

Pls don't make me feel stupid :(

→ Reply

JulSjlv

4 years ago, # ^ |

Maybe you need to work on your dynamic programming skill a bit? I personally just thought dynamic programming initially and then realised I can do without the extra memory.

→ Reply

Matuagkeetarp

4 years ago, # ^ |

Can you tell me how to do D without extra memory?

→ Reply

mychecksdead

4 years ago, # ^ |

In D, i think the best solution is iterating over centers of subarrays and calculating the difference between new and old values. It takes O(n^2) time and O(n) space complexity (just a and b arrays). My submission is here: 114594546

→ Reply

spookywooky

4 years ago, # ^ |

D is simple implementation once you see how the dp works. But getting that idea is not so simple.

C on the other hand is the opposite. The idea is simple to see, but the implementation has some pitfalls.

→ Reply

WitchOfTruth

4 years ago, # ^ |

The opposite for me

Took me quite a while to get the idea what to do in C to avoid time limit

And instant idea in D

→ Reply

EJOI_Gold

4 years ago, # |

Nice problems

→ Reply

pooty

4 years ago, # |

Is Question E a MCBM problem? I was thinking of modelling both of the possible moves as a fraction x/y then try to do matching between points with the one of the same fractions. However, this is potentially O(n^2) so I am not sure if there is a way to optimize it.

→ Reply

BlueBlisteringBarnacles

4 years ago, # |

memory limit was too tight in problem D

→ Reply

ghost-zen

4 years ago, # ^ |

Am I the only one who did it in O(n) space?

→ Reply

anil9717

4 years ago, # ^ |

+29

→ Reply

epsilon_573

4 years ago, # ^ |

Yeah, you can do it O(n) space and O(n^2) time complexity. Iterate over all points as pivots and iterate over length of subarray to reverse. Then do the same for all gaps i.e. even length subarrays.

→ Reply

rgnerdplayer

4 years ago, # ^ |

No additional memory other than the original array was needed actually.

→ Reply

BlueBlisteringBarnacles

4 years ago, # ^ |

well , my O(n^2 * 2) DP didn't pass , but I realized after the contest was over that I can change it to only n^2 space , and i coded it and got AC. welp , thats my rating going.

→ Reply

rananjay23

4 years ago, # ^ |

← Rev. 2 →

could you please elaborate on how to do this. I used two addition arrays of size $$$n$$$ to store answer for subarrays of size $$$i-2$$$ and $$$i-1$$$. This is because we need to have answer for subarray of size $$$i-2$$$ if we are going to calculate answer for subarray of size $$$i$$$.

→ Reply

rgnerdplayer

4 years ago, # ^ |

If you already understood the solution, take a look at my submission 114616116.

→ Reply

arujbansal

4 years ago, # |

+16

→ Reply

Hsomniac

4 years ago, # |

I used n^2 Space to solve D but it exceeded memory limit. I still wonder how it is possible.

My Code

#include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstring>
#include <chrono>
#include <complex>
#define priority_queue < ll, std::vector<ll>, std::greater<ll> > mnheap;    // mnheap.push(), mnheap.top(), mnheap.pop()
#define REP(i,a,b) for (auto i = a; i != b; i++)
#define ll long long int
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vvi vector < vi >
#define pii pair<int,int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001
#define all(c) c.begin(),c.end()
#define rall(c) c.rbegin(),c.rend()
#define mp(x,y) make_pair(x,y)
#define mem(a,val) memset(a,val,sizeof(a))
#define eb emplace_back
#define f first
#define s second
#define pb push_back
#define SQ(a) (a)*(a)
 
using namespace std;
            
        
void read(int n,vector<int>& x)
{
    x.clear();
    x.resize(n);
    for(int i = 0;i<n;i++)
    {
        cin>>x[i];
    }
    
}
void read(int n,int m,vector<vector<int>>& x)
{
    x.clear();
    x.resize(n,vector<int>(m));
    for(int i = 0;i<n;i++)
    {
        for(int j = 0 ;j<m;j++)
            cin>>x[i][j];
    }
}
void read(int n,vector<vector<int>>& x)
{
    x.clear();
    x.resize(n+1);
    for(int i = 0;i<n-1;i++)
    {
         int a,b;
         cin>>a>>b;
         x[a].pb(b);
         x[b].pb(a);
    }
}
void read(int n,vector<vector<int>>& x,int m)
{
    x.clear();
    x.resize(n+1);
    for(int i = 0;i<m;i++)
    {
         int a,b;
         cin>>a>>b;
         x[a].pb(b);
         x[b].pb(a);
    }
}
void read(int n,vector<ll>& x)
{
    x.clear();
    x.resize(n);
    for(int i = 0;i<n;i++)
    {
        cin>>x[i];
    }
}
int main()
{
    std::ios::sync_with_stdio(false);
    int T = 1;
    // cin>>T;
    
    for(int t = 1;t<=T;t++)
    {
        // cout<<"Case #"<<t<<": ";
        int n;
		cin>>n;
		vector<ll> a(n);
		vector<ll> b(n);
		read(n,a);
		read(n,b);
		vector<vector<ll>> mul(2*n);
		// vector<vector<ll>> pref(2*n);
		vector<ll> pref1(n);
		for(int i = 0;i<n;i++){
			if(i == 0){
				pref1[i] = a[i]*b[i];
			}
			else{
				pref1[i] = pref1[i-1] + a[i]*b[i];
			}
		}
		for(int i = 0;i<n;i++){
			for(int j = 0;j<n;j++){
				mul[i+j].pb(a[i]*b[j]);
			}
		}
		for(int i = 0;i<mul.size();i++){
			reverse(all(mul[i]));
			for(int j = 0;j<mul[i].size();j++){
				if(j == 0){
					continue;
				}
				else{
					mul[i][j] += mul[i][j-1];
				}
				// cout<<mul[i][j]<<" ";
			}
			// mul[i].clear();
			// cout<<endl;
		}
		ll bestsum = pref1[n-1];
		ll sum = pref1[n-1];
		ll diff = 0;
		// for(int i = 0;i<pref1.size();i++){
		// 	cout<<pref1[i]<<" ";
		// }
		// cout<<endl;
		ll x = 0;
		ll y = 0;
		ll z = 0;
		for(int i = 0;i<n;i++){
			for(int j = i+1;j<n;j++){
				
				if(i == 0)
					x = pref1[j];
				else{
					x = pref1[j] - pref1[i-1];
				}
				// ll y = 0;
				if(i+j < n){
					if(i == 0){
						y = mul[i+j][j];
					}
					else{
						y = mul[i+j][j] - mul[i+j][i-1];
					}
				}
				else{
					z = i+j - n + 1;
					if(i == z){
						y = mul[i+j][j-z];
					}
					else{
						y = mul[i+j][j-z] - mul[i+j][i-z-1];
					}
				}
				diff = max(diff,y-x);
			}
		}
		cout<<bestsum + diff<<endl;

    }

    return 0;
}

→ Reply

PhantomAssassin

4 years ago, # ^ |

try to replace the vector with an array

→ Reply

dryice

4 years ago, # ^ |

In D, any n^2 memory takes 200 MB in worst case. So even if you had 2 such types of memory, it will MLE.

→ Reply

4 years ago, # ^ |

My O(n^2) Space and time dp passes all TC. Video explanation

→ Reply

rananjay23

4 years ago, # ^ |

I will be thankful if someone makes video editorial of E. Why everyone posts editorial of problems solved by 1000's of people.

→ Reply

4 years ago, # ^ |

Actually, You can see I 've just posted for only Problem D for this contest, and I'm trying to post for video explanation of problem E too asap.

→ Reply

4 years ago, # ^ |

← Rev. 2 →

Because there 8000 people interested in A and B, 15000-19000 in C and D, and only then there 2000 who solved D and interested in E, and 50 interested in F :)

→ Reply

old._.monk

4 years ago, # |

← Rev. 4 →

How to solve Problem C. I ran into TLE. This is my solution using Heap. I also tried using sorting the vectors, which too ran into TLE. Kindly help

→ Reply

This Video Explanation might help you.

4 years ago, # ^ |

→ Reply

old._.monk

4 years ago, # ^ |

Prefix sum! I couldn't come up with this approach. Thanks btw.

→ Reply

sniper97

4 years ago, # |

Hi, Can someone help me with my submission for problem C . I am getting a run time error for the first test-case which is already given but running that test-case on my laptop is not giving any error and the output is also correct . The link to my submission My_Submission. Thanks in advance.

→ Reply

4 years ago, # ^ |

Link to Explanation

→ Reply

4 years ago, # |

← Rev. 2 →

+84

Problem D was super not Python friendly. This is the shit I did to get accepted 114611359.

The reason for the TLEs in Python is basically that PyPy2 and PyPy3 is only 32 bit on Windows. So on Problem D you are forced to use big integers everywhere, which is super super slow. However in the latest update of PyPy (version 7.3.4), PyPy switched to supporting 64 bit on Windows.

MikeMirzayanov Would it be possible to update the PyPy version (to version 7.3.4)? All of these issues with big integers would go away, and it would make PyPy a lot more useable and beginner friendly.

→ Reply

epsilon_573

4 years ago, # ^ |

Maybe post this as a different blog, that will get it noticed faster.

→ Reply

https://mirror.codeforces.com/contest/1519/submission/114576707

4 years ago, # ^ |

+14

Good idea! I just made a blog about it https://mirror.codeforces.com/blog/entry/90184

→ Reply

huikang

4 years ago, # ^ |

For Python, others did something like ans+=(a[left]-a[right])*(b[right]-b[left]) to get accepted

→ Reply

anshul_129

4 years ago, # |

In question C, the description was ambiguous, there were not exactly 'n' universities always, rather nothing should've been mentioned about universities!:)

→ Reply

StArChAn

4 years ago, # ^ |

Why not? They never said each university had a competetive programmer. It is possible for a university to have no competetive programmers.

→ Reply

anshul_129

4 years ago, # ^ |

Ohh..I got it now....thanks for clarifying.....I forgot this statement of yours!:)

→ Reply

UnfinishedSentenc

4 years ago, # |

-25

Hello everyone, this was my first ever contest on any coding platform , and I was able to solve just 4 questions and got around 1500 rank. Can anyone tell me whether it is considered good performance or not? Also , what should I do in order to improve? Thanks a lot.

→ Reply

rkguptagkp462

4 years ago, # ^ |

Keep giving contests

→ Reply

StArChAn

4 years ago, # |

-11

Why was B so easy? Usually B is twice as good as A(even for an edu round). We can basically induct on $$$m+n$$$ and B is solved.

→ Reply

4 years ago, # ^ |

+12

That's once you guess what the answer is. And then you can defer the proof until after the contest.

→ Reply

Ra09

4 years ago, # |

https://mirror.codeforces.com/contest/1519/submission/114599717 how can i optimize it?

→ Reply

nagasaisujan160998

4 years ago, # ^ |

store indices where ans[j].size()>0 and then run loop on those indices only

→ Reply

Fatherboard

4 years ago, # |

Question regarding Problem B: How can we prove that no matter which path we take it will always result in the same cost of N * M — 1 ?

→ Reply

4 years ago, # ^ |

← Rev. 2 →

We can prove by induction that regardless of the path you chose, the cost at any point (x,y) along that path will be x*y-1.

→ Reply

TheScrasse

4 years ago, # ^ |

← Rev. 2 →

+14

The path can be described by a sequence of R (right) and D (down).
It's easy to prove that swapping a R and a D doesn't change the answer.
You can reach any sequence, starting from a fixed sequence (e. g. RR...RRDD...DD), with a finite number of swaps.

→ Reply

4 years ago, # ^ |

← Rev. 2 →

You can visualize it by realizing that at each point $$$(x,y)$$$ of the path the cost is equal to the area of the rectangle with a diagonal $$$(1,1) -(x,y)$$$ with cell $$$(1,1)$$$ removed. When you move right you add a column to the rectangle, and when you move down you add a row.

→ Reply

AwakeAnay

4 years ago, # ^ |

+26

You can also prove it like this:

Consider the conservative field $$$\vec{E}=y\hat{i} + x\hat{j}$$$. Observe that the value required is just the work function. As potential function is $$$U = xy$$$, work done will always be $$$nm - 1$$$.

→ Reply

4 years ago, # ^ |

A stupid question — are you applying continuous calculus to a discrete problem?

→ Reply

AwakeAnay

4 years ago, # ^ |

← Rev. 2 →

Yes. I proved that work done will be same regardless of how you move the particle from $$$(1, 1)$$$ to $$$(n, m)$$$. The problem just asks to consider specific ways to displace the particle, using only the vectors $$$(1, 0)$$$ and $$$(0, 1)$$$.

→ Reply

_siummy

4 years ago, # |

Can someone please explain the proof why for problem B, the answer is k==(n*m-1)?

I solved with DP and got surprised to see it could be formulated.

→ Reply

rgnerdplayer

4 years ago, # ^ |

+17

Consider any RD from (x, y) to (x+1, y+1), you can see that changing the sequence to DR does not change the cost, and thus any sequence will have the same cost.

→ Reply

__invariant__

4 years ago, # ^ |

Prove by induction. You can assume the proposition true for m×n grid , and establish for (m+1)×n grid.

→ Reply

VaibhaveS

4 years ago, # ^ |

Can you provide the inductive proof please?

→ Reply

__invariant__

4 years ago, # ^ |

← Rev. 3 →

Inductive hypothesis: path value is x×y-1 for any grid such that x <= m && y <= n.

We try to prove the same for (m+1)×n grid.

Suppose you are at m×j cell and take downturn to (m+1)th row.

You need (n-j) more right turns to reach (m+1)×n cell.

Total : (m×j-1) + j + (m+1)×(n-j) = (m+1)×n-1 , which was to be proved.

→ Reply

maghrabyJr_

4 years ago, # ^ |

← Rev. 2 →

I did some few examples on paper and found out that the answer is unique, for every n, m. I couldn't find the formula so just calculated it step by step and checked the cost if it equals k.

→ Reply

Ritwin

4 years ago, # ^ |

I calculated the way going through two opposite corners (algebra), got that both were $$$n \cdot m - 1$$$, and then didn't bother trying to prove it.

→ Reply

anil9717

4 years ago, # ^ |

← Rev. 3 →

+10

Proof for problem B that answer is k==(n*m-1).

Proof

→ Reply

dorijanlendvaj

4 years ago, # ^ |

← Rev. 3 →

+56

Another possible proof:

Instead of it costing $$$x$$$ or $$$y$$$ burles, say that it costs $$$x+y$$$ burles and then you get $$$y$$$ or $$$x$$$ burles back.

In each move, $$$x+y$$$ increases by 1 so the total sum of $$$x+y$$$ is $$$\frac{(n+m-1)(n+m)}{2}-1$$$, the total amount of burles you get back with the increase of $$$x$$$ is $$$\frac{n(n-1)}{2}$$$(you do one with each $$$x$$$ from $$$1$$$ to $$$n-1$$$) and the total amount of burles you get back with the increase of $$$y$$$ is $$$\frac{m(m-1)}{2}$$$(you do one with each $$$y$$$ from $$$1$$$ to $$$m-1$$$). In total the cost is $$$\frac{(n+m-1)(n+m)}{2}-1-\frac{n(n-1)}{2}-\frac{m(m-1)}{2}=nm-1$$$.

→ Reply

anil9717

4 years ago, # ^ |

oh,nice. I made it hard for myself.

→ Reply

4 years ago, # ^ |

+14

You are using wrong currency.

→ Reply

dorijanlendvaj

4 years ago, # ^ |

Fixed.

→ Reply

4 years ago, # ^ |

+11

Consider an arbitrary path from $$$(1, 1)$$$ to $$$(n, m)$$$.

We claim that at any point $$$(x, y)$$$ along that path the cost will be $$$x \cdot y-1$$$.

Proof by induction.

At the start the cost is $$$1 \cdot 1 - 1 = 0$$$ — the condition holds.

The induction step.

Assume that the statement is true at a point $$$(x, y)$$$ along the path. The next point in the path is either $$$(x,y+1)$$$ or $$$(x+1, y)$$$.

In the first case the cost will be $$$x \cdot y-1 + x = x \cdot (y+1) - 1$$$. Similarly, in the second case the cost will be $$$x \cdot y-1 + y = (x + 1) \cdot y - 1$$$.

→ Reply

4 years ago, # |

What is the meaning of the Problem B title?

→ Reply

krazy8

4 years ago, # ^ |

I guess constraints make this ques harder. If it were around 1e9, all would have tried to thought of general formula.

→ Reply

BERNARD

4 years ago, # |

Very happy to see some good ad-hocs like ABCD.

→ Reply

Um_nik

4 years ago, # |

+106

Screencast with commentary aka Um_nik staring at problem F for 40 minutes in silence

→ Reply

jhaatBarabar

4 years ago, # |

My python submission for problem C is getting TLE on Tc 5, I tried implementing it as the same way other people implemented and got AC. MY SUBMISSION FOR PROB C

please help. Thanks in advance.

→ Reply

a modified version of your submission using the std ceil function

4 years ago, # ^ |

Your code takes O($$$n^2$$$) time because of

for ii in d:
  for k in range(1,n+1):

If you change it to

for ii in d:
  for k in range(1,len(d[ii])+1):

then the loops run in O($$$n$$$) time 114686648.

→ Reply

Dio

4 years ago, # |

← Rev. 3 →

+66

I think the official generator for task E is broken since none of the 26 pretests have n > 1e5! Therefore, It'd be best if the authors cut the limit on n to 1e5 and rejudge all the solutions to respect the spirit of competition. awoo

→ Reply

AmShZ

4 years ago, # ^ |

+18

Knowing that there were 26 pretests for E find it strange as well, it's common sense that the only fair option is to reduce n to 1e5 and rejudge everything, if not including max tests in pretests was intentional then the authors are sadistic and should die a painful and slow death.

→ Reply

awoo

4 years ago, # ^ |

-48

Nah, I don't think that's necessary. I admit I made a mistake while generating tests, but you aren't really promised the strongest tests anywhere. The constraints are in sync with what the validator checks, so I see no issue.

Sorry that you got caught by it, be careful the next time.

→ Reply

jerdno

4 years ago, # ^ |

+10

Fully agree. A lot of people here are interchanging pre-tests with system tests for some reason...

→ Reply

Clix

4 years ago, # ^ |

+68

I think you have to be carefull next time

→ Reply

Dio

4 years ago, # ^ |

+31

Exactly!

→ Reply

awoo

4 years ago, # ^ |

Sure, I'll try as well.

→ Reply

judgme_nt

4 years ago, # |

This contest was actually educational for me. I learned 2 things: 1) Never trust the ceil function. 2) Don't write iterative dp like it's recursion, always check the order of computations... goddammit D.

→ Reply

AmmarDab3an

4 years ago, # ^ |

I trust the ceil function:

→ Reply

AmmarDab3an

4 years ago, # ^ |

and if you want to write a ceil function that doesn't need to convert its arguments into doubles, you can write something like this:

int ceil(int x, int y){
    return (x+y-1)/y;
}

→ Reply

judgme_nt

4 years ago, # ^ |

← Rev. 2 →

Oh yeah, that's a smart expression. I always did this subconsciously when dividing by 2 (e.g. $$$\frac{x+y+1}{2}$$$) but it never crossed my mind that it could be generalized. Perhaps ceil isn't as untrustworthy as I first thought, thanks for the tip!

→ Reply

pranjalsoni

4 years ago, # |

I solved problem b but not able to solve a :(

→ Reply

_Nocturnal

4 years ago, # |

← Rev. 3 →

Hey! In C problem, I was using comparator on a vector of vectors. When I used '>=' in the comparator it gave a runtime error while using only '>' gave the 'Accepted' verdict.

Runtime code : https://pastebin.com/WQwxwrCd

Working code : https://pastebin.com/sf1e1BTk

Both codes are same except on the 18th line where there is difference of '>' and '>=' in the respective codes. Can anyone explain why this happens?

→ Reply

Ray_Striker

4 years ago, # ^ |

Read this blog

→ Reply

_mentalist_

4 years ago, # |

How to get rid of MLE in problem B using Dp can anyone please help? Here is my submission 114621015

Thanks in advance :)

→ Reply

kaiyu

4 years ago, # ^ |

B can be solved using 2D dp. Store true/false in DP states.
See this sub : https://mirror.codeforces.com/contest/1519/submission/114557667

→ Reply

_mentalist_

4 years ago, # ^ |

How storing 2 states will cover all possible states there might be different k values for different states right? could you elaborate, please...

→ Reply

Kawaii

4 years ago, # ^ |

B is math not dp ;-;

→ Reply

kaiyu

4 years ago, # ^ |

Yes its math.

But can be solved using DP too. I agree DP is an overkill lol.

→ Reply

bluescorp

4 years ago, # ^ |

if (k == (m-1 + m*(n-1))) cout<<"YES\n"; else cout<<"NO\n"; There, that gets you an AC.

→ Reply

Lihwy

4 years ago, # ^ |

Can you explain why?

→ Reply

bluespex

4 years ago, # ^ |

You have used long long int as the data type for the dp array. You could have avoided the MLE if you had used 16bit-int or 8bit-int as the data type. You can check it out in my submission 114563484.

→ Reply

_mentalist_

4 years ago, # ^ |

That's cool thanks buddy :)

→ Reply

9Curd1Cream

4 years ago, # |

speedforces :P

→ Reply

real1

4 years ago, # |

Can anybody tell how to optimize my C's solution further ? 114617580

→ Reply

4 years ago, # ^ |

← Rev. 3 →

There can be n lists of size == 1, but you'd still check every of them for i = [2..n]. That would be O(n^2) ~ 10^10. Kick them off from map when their len == i, and stop cycle when i > max_len(m[i]) (map should be empty at this time). But first kick those with len <=2.

→ Reply

abansal755

4 years ago, # |

← Rev. 2 →

I guess, the test cases were weak for problem C. Sorting the vector of vectors based on their size and stopping once the size becomes less than K can get your solution accepted.

→ Reply

PoIar_

4 years ago, # ^ |

← Rev. 3 →

There's an explanation for that actually. If you iterate from each $$$k$$$ from $$$1$$$ to $$$n$$$, you will find at most $$$\frac{n}{k}$$$ vectors that have size at least $$$k$$$.

That leads to a known sum which is $$$n logn$$$.

→ Reply

4 years ago, # ^ |

There is a trick to even get it down to O(n).

    out = []
    for k in range(1, n + 1):
        teams = [t for t in teams if len(members[t]) >= k]
        score = 0
        for t in teams:
            score += prefix_sum[t][k * (len(members[t]) // k)]
        out.append(score)

This part will run in O(n) time, not O(n log n). This is because a team with $$$m$$$ members will be filtered out of teams after $$$m$$$ iterations. And since the sum of the sizes of all teams are $$$n$$$, the code runs in O(n) time.

→ Reply

jlr.terceiro

4 years ago, # ^ |

I did like that in my ugly code, its good to know that it is O(n), i thought it would be something like N*sqrt(N).

→ Reply

4 years ago, # ^ |

← Rev. 4 →

Nice trick. Wouldn't it be "cheaper" to kick them from the set, instead of generating new list all the time?

→ Reply

4 years ago, # ^ |

This is probably the intended solution and it's $$$O(nlogn)$$$. It's not about the test cases, it is indeed $$$O(n)$$$ except sorting. Because, if done so, we will consider a university with size $$$s$$$ in only $$$s$$$ different $$$k$$$'s. Since the sum of all $$$s$$$'s is $$$n$$$, complexity is $$$O(nlogn+n)$$$, that is, $$$O(nlogn)$$$.

→ Reply

not.derwes.at.all

4 years ago, # |

Please explain how to make problem C using Two points method, i made it using Prefix sums.

→ Reply

4 years ago, # ^ |

I guess you'll need prefix sums anyway. From now on, assume that the universities are sorted in non-decreasing order by size. The thing with the "two pointers" must be that when you encounter a university with size smaller than current $$$k$$$, you have to move your "left pointer" (you shouldn't evaluate universities on the left of the left pointer because their size are smaller than $$$k$$$). As with the right pointer, it just doesn't exist.

P.S. : It is my understanding of this tag.

→ Reply

turzo_sawroop

4 years ago, # |

How to solve D?

→ Reply

4 years ago, # ^ |

← Rev. 2 →

Maintain a 2D DP array. Here, $$$dp[i][j]$$$ means the value we'll get in interval $$$[i,j]$$$ if we reverse the interval $$$[i,j]$$$. It is not hard to see that $$$dp[i][j] = dp[i+1][j-1] + a[i]*b[j] + a[j]*b[i]$$$ because when we reverse an interval $$$[i,j]$$$ , interval $$$[i+1,j-1]$$$ gets reversed and we swap $$$a[i]$$$ and $$$a[j]$$$. Now, maintain a prefix and a suffix array $$$pre$$$ and $$$suf$$$. Here, $$$pre[i]$$$ denotes the answer for prefix $$$[1,i]$$$ without any reversing and $$$suf[i]$$$ denotes the answer for suffix $$$[i,n]$$$ without any reversing. The answer is maximum of $$$pre[i-1] + dp[i][j] + suf[j+1]$$$ for all intervals $$$[i,j]$$$.

→ Reply

turzo_sawroop

4 years ago, # ^ |

thank yo so very much....I understood..you explained it really well

→ Reply

4 years ago, # ^ |

You're welcome!

→ Reply

nipun753

4 years ago, # ^ |

I think there is typo it should be dp[i][j]=dp[i+1][j-1]+a[i]*b[j]+a[j]*b[i]

→ Reply

4 years ago, # ^ |

Sorry, you're right. Fixed that.

→ Reply

Link to detailed video explanation

4 years ago, # ^ |

-7

→ Reply

nubidy

4 years ago, # |

Can someone explain why the first submission gets TLE while the second one gets accepted?

114581044 114630025

Only difference is how I sort a vector.

→ Reply

piCoder314

4 years ago, # ^ |

In the first submission, you have used a lambda expression to sort the vector. The problem here is that you have 'captured' the variables using "=" which is slower. I replaced that with "&" and uncommented the "#define int ll" line. The code gets AC after this.

114639136

→ Reply

Thallium54

4 years ago, # ^ |

← Rev. 2 →

Capturing variable using = is by value which means you copy a new vector every time the sort function compares two numbers. Use & to capture by reference.

→ Reply

rananjay23

4 years ago, # |

How to solve C ? I solved using factorization in O(nsqrt(n)) but it seems lot of people have solved in some different way.

→ Reply

oneninetyfive

4 years ago, # ^ |

idk

→ Reply

Murtaza1112

4 years ago, # ^ |

You can solve problem C using Prefix Sums . Divide all the students by their corresponding cities . For each city , if number of students in my current city is $$${m}$$$ and size of teams is $$${k}$$$ , then $$${m\%k}$$$ lowest skilled students will be not be in any team .$$${\newline}$$$ So for each city , sort the array of students ,calculate the prefix sums , and then iterate over the size of teams ($$${1}$$$ to $$${m}$$$ ) , take sum of skills of all students who can be teamed up ( $$${pref[m]-pref[m\%i]}$$$ ) and add to the final answer array .
Hope it helped !
Submission Link : https://mirror.codeforces.com/contest/1519/submission/114643205

→ Reply

Ozymandias_Orz

4 years ago, # ^ |

So, let say there are $$$n$$$ university and each university has only $$$1$$$ student then don't you think your solution will be $$$O(n^2)$$$? I was trying to do same but this case stuck in my mind

→ Reply

Murtaza1112

4 years ago, # ^ |

The the number of students is $$${n}$$$ , the only thing I did is distribute those $$${n}$$$ students across the cities . There are two loops but the sum of total operations of the inner loop is still $$${\mathcal{O}(n)}$$$ (because I am iterating over the students and only n students exist across all the cities ) .

In your example case , the inner loop will perform $$${\mathcal{O}(1)}$$$ operation for each outer loop iteration , summing upto $$${\mathcal{O}(n)}$$$ . (Also you'll need to account for sorting , which takes $$${\mathcal{O}(nlogn)}$$$ ).

→ Reply

Pub

4 years ago, # |

Speedforces.

Many people solved ABCD.

→ Reply

MR_MECHANICAL

4 years ago, # |

Need Help in problem D: **** I have solved Problem D using Python. i wrote the same logic in two different ways 1st way got Accepted but the 2nd way got TLE. both are exactly same as other only I changed the calculation part of the code and I believe it should not affect the run time. please help me out.

TLE Submission : https://mirror.codeforces.com/contest/1519/submission/114646999 Accepted Submission : https://mirror.codeforces.com/contest/1519/submission/114647073

→ Reply

PoIar_

4 years ago, # ^ |

I think this blog might be helpful.

→ Reply

Kawaii

4 years ago, # |

← Rev. 2 →

weak test in C

→ Reply

Chanandler_Bongg

4 years ago, # |

← Rev. 2 →

Can anybody please tell me why i'm getting TLE in C? Like i used the same approach as many the people who got accepted did, till today morning my solution was accepted by now it's showing TLE
here is the link to my submission https://mirror.codeforces.com/contest/1519/submission/114596588

→ Reply

suyashc222

4 years ago, # ^ |

← Rev. 2 →

I too had same problem. But, the thing here is, for each k you are checking each university even if k>sizeof(university[i]). This makes your solution time complexity O(N^2).

Better approach is to go for each university and then add its answer to k( which is less than sizeof(university[i])). To do this we need only O(N) time complexity.

Here are my solutions:

This is similar to your approach but got TLE: https://mirror.codeforces.com/contest/1519/submission/114653177

Here I modified it as stated above and got AC: https://mirror.codeforces.com/contest/1519/submission/114659364

→ Reply

Chanandler_Bongg

4 years ago, # ^ |

← Rev. 2 →

if it's becoming O(n^2) then how come it passed TC:7 because which is some what similar to TC:8(on which i'm getting the TLE)

→ Reply

AmeTxx

4 years ago, # ^ |

← Rev. 3 →

Let's define n as the max number of the students in one university and m as the number of universities. The last loop in your submission will run n*m times. It seems that there is only one university which is numbered 200000 in the 7th testcase. However, there may be 100000 different universities in your TLE testcases, where the first university has 100001 students and every other university only has one student.

→ Reply

invincible_M15

4 years ago, # |

← Rev. 2 →

OH C ! You broke my little heart

→ Reply

4 years ago, # ^ |

-9

hhhh

→ Reply

Kitrak_rev

4 years ago, # |

Can Someone figure out why I am getting random values instead of 0, for problem C MyCode(https://mirror.codeforces.com/contest/1519/submission/114659037)

→ Reply

melks

4 years ago, # ^ |

← Rev. 4 →

→ Reply

4 years ago, # ^ |

+21

i can't sorry bro

→ Reply

robostac

4 years ago, # ^ |

sum = sum + (v[j][((long long)(v[j].size() / i) * i — 1)]);

When i > v[j].size() the second index becomes -1 so you read memory outside of the vector (v[j][-1])

→ Reply

KeepMoving

4 years ago, # |

when the ratings update cannot wait for more time??

→ Reply

tuananh238

4 years ago, # |

← Rev. 2 →

+11

In Problem E, why doesn't the following greedy solution work?

I first order lines by their angles with Ox and iterate them by counter-clockwise order. For each line, find two points that can reach the line, and always take points under the line first. Of course, I remove selected points after each step.

→ Reply

DarkTigerFAF

4 years ago, # ^ |

I did the same but got stuck on test 7 because there's a test case that ruins this approach. Let's say a specific angle has 3 points and other have 4 points and another one with 1 point. You're gonna choose any 2 of the 3 but what if the 2 points you choose were in the other 4 points ? It won't be chosen there (at the 4 points's angle). So, you have to choose 2 points out of the 3 that won't interfere with the 4 points to get the maximum number of moves and it would just interfere with that 1 point because it won't be chosen anyway. Hope you understand my explanation.

→ Reply

tuananh238

4 years ago, # ^ |

I got your points. Thanks!

→ Reply

uttaran_das

4 years ago, # |

Time limit exceeded on test 8 :(

→ Reply

mees

4 years ago, # |

C was a pretty cool problem. Never seen anything like it, requires some thinking, yet not too difficult. Props!

Why not just pick n=2000 for D, so it can be solved in Python? Now I had to go back and rewrite my solution in C++ for no particular reason, just because the Python implementation barely times out. I actually thought it was a very nice problem other than that annoying detail.

→ Reply

blue_meth

4 years ago, # ^ |

I assume n=2000 might have allowed some O(n^3) solutions to pass by virtue of vectorisation. That might be the reason setters kept n=5000.

→ Reply

_siummy

4 years ago, # |

-7

Is it rated?

→ Reply

swiftc

4 years ago, # ^ |

Yes

→ Reply

AmeTxx

4 years ago, # |

← Rev. 2 →

Problem C raises my doubt about how vector<vector<int> > works in different versions of cpp compilers. After calling push_back() for serveral times, sometimes the result is unexpected but sometimes it looks fine. It seems that this error is related to the version of the compiler. Could someone please explain why?

→ Reply

priyanshu_x

4 years ago, # |

+12

MikeMirzayanov Please update the rating change, please...

→ Reply

cherau

4 years ago, # |

I've got a nasty bug in the implementation of D which gives WA on Test 27. Can somebody help me figure it out ? 114670308

Test case 27

39
2272444 3698012 5125012 7166709 3503029 1727871 7293835 4189398 3200693 3241014 8609749 6932236 3343904 8116213 1958622 6714272 8223889 8038950 1022157 8865228 6268599 7674195 9542567 3949141 8069361 2085276 9394838 6938364 1494858 2742785 7992600 3754931 3199011 4125593 9684890 2329734 5106836 2143245 8971071
9005537 7867356 8592781 1211906 3953852 9483166 4708038 5157649 4947712 1505811 8112182 3295947 7153949 9936840 8184380 3081882 9265570 8959815 5190532 9659942 1243298 7690386 9497105 3664620 8537001 7554794 2121292 1628003 5036215 2381356 1811254 3935828 9965608 3296624 2748440 7073046 5400382 2509524 2799639

→ Reply

freepointer

4 years ago, # ^ |

You are not considering the case when the entire array a needs to be reversed.

→ Reply

cherau

4 years ago, # ^ |

Thanks!

→ Reply

BaluconisTima

4 years ago, # |

+21

Does anyone know why the rating change in the CF predictor is so different from the actual rating change?

→ Reply

ADO

4 years ago, # |

+17

hm? why so big delta between predictor and real rating changes?

→ Reply

Yoav

4 years ago, # |

+16

Finally, after 14 months and 57 contests I have reached CM. Feels good :)

→ Reply

lior5654

4 years ago, # ^ |

Congratulations! Well Played :D

→ Reply

srinjoy_ray

4 years ago, # |

+16

Why is the rating change so less than cf predictor?

→ Reply

mcGyver

4 years ago, # ^ |

Ask the predictor creators. Its not an issue of cf

→ Reply

ADO

4 years ago, # ^ |

why so confident? Actually almost always real rating changes are greater than predictor changes, in this case it's vice versa.

→ Reply

shahil_005

4 years ago, # ^ |

Use Carrot, It is better and more accurate than CF-predictor.

→ Reply

srinjoy_ray

4 years ago, # ^ |

Sure, will try it

→ Reply

saurxbh

4 years ago, # |

+16

How come CF-Predictor is showing +79 rating change but the actual rating change is only +48 for me while there are other accounts who have seen increase in their actual rating change :(

→ Reply

Mr.HITMAN

4 years ago, # |

+16

I think the positive delta is really low even after getting 2899 rank considering My previous ratings i should have got +120-130 but i only got +81. is it normal ?

→ Reply

saurxbh

4 years ago, # ^ |

+15

No.. of all the contests I have given this is the first time I have seen the actual rating change is less than the predicted rating change..

→ Reply

4 years ago, # |

About the ongoing discussion about rating predictions in cf-predictor being wrong, I'd like to say something. The ratings of the people I've checked (including mine) are not up-to-date, that's probably the reason why the calculations of deltas are incorrect.

→ Reply

Mr.HITMAN

4 years ago, # ^ |

By not up-to-date do you mean there will be a rating roll back soon and new ratings will be published ?

→ Reply

https://mirror.codeforces.com/contest/1519/submission/114668130

4 years ago, # ^ |

I mean, I'm talking about "cf-predictor extension" and the calculation of yesterday's contest is based on our previous ratings, like the system is literally missing two last contests' rating changes. I don't know about any rating roll back and I didn't mean that.

→ Reply

AhmadShahal

4 years ago, # |

← Rev. 4 →

+15

Can anyone explain how did my code pass the tests on problem B? I accidentally wrote: int dp[102][102][250]; instead of: int dp[102][102][10100]; The submission: 114572709 The problem: 1519B - The Cake Is a Lie

→ Reply

swiftqwq

4 years ago, # ^ |

← Rev. 3 →

Your program used 102 as the size of the array instead of 101 so that you have some unused memory(1*102*250=25500>10000),so when you use index out of bound like dp[100][100][10000],the program actually use dp[101][40][...] without getting an Runtime Error.

However,I think it will cause some reuse of the element,but I don't know how to hack it so far.

→ Reply

Restricted

4 years ago, # |

Why does my solution for problem C TLE in java?

My code is clearly O(n*log(n)) (the log is from sorting, O(n) otherwise) because when I reach k > than the size of a university I don't revisit this university just as other people (above) described. The exact same code in C++ gets AC. I know that Java is slower but usually in problems like this it should pass the time limit...

Java Submission: 114570376 CPP Submission: 114677079

→ Reply

adarshraj365

4 years ago, # |

Can anyone tell me why I'm getting TLE in the 8th test case in Problem C.

Here is my code:-

→ Reply

4 years ago, # ^ |

← Rev. 2 →

Your last working cycle runs mx*n == n * n = 4*10^10 times, because in this test case it looks like there 200K students from only one university and you are checking n-1 empty universities n times.

→ Reply

piCoder314

4 years ago, # ^ |

Consider a case where n/2 students are from university $$$1$$$ and the rest are from distinct universities. In this case, mx = n/2 and tmp = n/2+1. So your last loop takes O(n^2) time to run which exceeds the time limit.

→ Reply

SravanthJanga

4 years ago, # |

Hello I'm new here. where can I find editorial for this contest? Thanks in advance.

→ Reply

4 years ago, # ^ |

On the Problems Site in the bottom right you will find them in the "Contest Materials". Right now theres only the Announcement, you need to wait till the authors publish the editorial.

Till then you can look through the solutions of other participants (double click the entries) or read the comments here.

→ Reply

awoo

4 years ago, # |

Auto comment: topic has been updated by awoo (previous revision, new revision, compare).

→ Reply

Kawaii

4 years ago, # |

Not in the top of the best hacker :(

→ Reply