dope you are such a skibidi sigma rizzler

I_love_I_love_kirill22

i_love_dope

as a participant, I will participate.

LFG!!!

Hello 2025

speedforces?

Simplest E1 ever?

Hope everyone starts with positive delta this year. All the best FOLKS <3 edit- don't downvote please. Get me some contribution yo.

I WILL RETZRN SPECIALIST

hope to get 1800 :)

• hey guys from the two days i won't be able to submit the solution on codeforces when I try to submit it shows a wierd page that return home like that stuff can anyone help me out.

I wish everyone could reach their destination by this contest. Best of luck!

E1 only 1000 points???

E1 = B < C ???

I'm surprised.

I also love Kirill ;)

I_love_kirill22 is the language of communication and lecture in the camp Russian or English?

Hope chenlinxuan0226 can say hello to Expert rating after "Hello 2025".

Very much excited to participate in the first contest of this year!!

dope has a small eggplant

This is the first contest of the year. Happy new year everyone!!

E1 is just 1000 Damn

Will there be problems for div4 programmers?

will it be suitable for me (my first time to participate in a contest)?

let's destroy this contest

quick question, what division is it going to be in?

How many problems will be given? I'm at the beginner level, so are there any beginner-level questions?

does this mean that the authors predict that $$$E2$$$ will be easier than $$$D$$$?

D will be more difficult to me than Ds in other div1+2s

I hope this first contest of 2025 will be fun

Hopefully the problems are as good as Good Bye 2024! A little concerned that the writers were decided so late...

I hope I could Solve at least two questions ......

Is it a good idea to drink coffee before a contest? If yes, how long before contest should I drink it?

Why are there so many unmatched nametags(rating <-> color)? What happened with them

hope i get to expert on this round for a lucky year!

hopefully i don't mess this one up!

How can you conceive splitting the E in this economy?

new year, new hope. Hoping positive delta

_ hello 2025_

What a thrilling and exciting game (forced smile)

(answer $$$q$$$ queries)forces

i am gonna start skipping contest that has anything to do with bit manipulation in c or b. It turns to a game of pattern guessing though brute force.

i have petition to permanently ban bitset problem from rated contest

I'm super confused about the number of points for E1. I thought maybe I should try solving it instead of D, but came up with no solution even after I solved D.

what is the hack for problem B? is it attacking unordered_map solutions?

A: When the MEX value of a set be positive, this set must contain $$$0$$$. WLOG assume $$$n<=m$$$ and $$$a_{1,1}=0$$$, then the answer will be MEX of first row plus MEX of first column. If we let $$$a_{1,j}=j-1$$$, the MEX of first row will be $$$m$$$ and MEX of first column will be $$$1$$$, the answer is $$$m+1$$$. On the other hand, value $$$1$$$ cannot be contained in both first row and first column, so the minimum value of MEX of first row and first column is $$$1$$$, therefore the answer is not greater than $$$\max(n, m)+1 = m+1$$$.

B: Let $$$T$$$ be the number of different values in array $$$a$$$, in each operation we can only reduce $$$T$$$ by at most $$$1$$$ (because all values we remove from $$$a$$$ are equal), and if we choose $$$l=1, r=n$$$ everytime, $$$T$$$ will definitely be reduced by $$$1$$$. So when $$$k=0$$$ the answer is the number of different values in array $$$a$$$. When $$$k>0$$$ we need to reduce $$$T$$$ as more as possible, so we need to find value $$$a_i$$$ with minimum number of occurence annd change their value, until we used up all $$$k$$$ operations.

C: First assume $$$a, b, c \in {0,1}$$$. We can see $$$(a⊕b)+(b⊕c)+(a⊕c)$$$ is 2 when $$$a, b ,c$$$ are not the same, and $$$0$$$ otherwise. To find the answer we look at bits of $$$l, r$$$, start from the most significant: Let $$$j$$$ be the most significant bit where $$$l,r$$$ differ, so for $$$j+1$$$-th bit and higher $$$(a⊕b)+(b⊕c)+(a⊕c)$$$ can only be zero. Let $$$B$$$ be the $$$j+1$$$-th bit and higher part of $$$l$$$ and $$$r$$$, and $$$p=1\lt\lt j$$$, we have $$$l < (B|p) <= r$$$, and because $$$r-l>=2$$$, either $$$B|(p-2)$$$ or $$$B|(p+1)$$$ should be in interval $$$[l, r]$$$. By calculation we can see when $$$a=B|(p-2), b=B|(p-1), c=B|p$$$ or $$$a=B|(p-1), b=B|p, c=B|(p+1)$$$, the value of $$$(a⊕b)+(b⊕c)+(a⊕c)$$$ will be the maximum possible (which is $$$1\lt\lt(j+2)-2$$$).

D: We solve the problem by segment tree: For each node representing range $$$[u, v]$$$ we store these values:

• $$$max_{-}plus = \mathop{\max}\limits_{u<=i<=v}a_i+i$$$
• $$$max_{-}minus = \mathop{\max}\limits_{u<=i<=v}a_i-i$$$
• $$$min_{-}plus = \mathop{\min}\limits_{u<=i<=v}a_i+i$$$
• $$$min_{-}minus = \mathop{\min}\limits_{u<=i<=v}a_i-i$$$
• $$$ans$$$ = the answer we need for range $$$[u, v]$$$

When we need to merge 2 ranges $$$L$$$ and $$$R$$$, we first assume we pick max and min value of $$$a_i$$$ both in range $$$L$$$. In this case we don't need to extend the range outside of $$$L$$$, because we cannot get any better answer, so this case answer is $$$L.ans$$$. Similarly when we pick max and min value from $$$R$$$, the best answer is $$$R.ans$$$. If we pick max value from $$$L$$$ and min value from $$$R$$$, we need to find $$$\mathop{\max}\limits_{i \in L, j \in R}a_i-a_j-(j-i)$$$, which is equivalent to $$$\mathop{\max}\limits_{i \in L}(a_i+i) - \mathop{\min}\limits_{j \in R}(a_j+j)$$$, so the best answer for this case is $$$L.max_{-}plus - R.min_{-}plus$$$. Similarly, for the last case, the best answer is $$$-L.min_{-}minus + R.max_{-}minus$$$.

E2: For a certain query $$$(a, b, k)$$$, let's find how to check whether $$$w_k >= t$$$ for certain $$$t$$$. Let's assume all edges in the graph with $$$w>=t$$$ has cost $$$1$$$, and other has cost $$$0$$$. If we can go along any path, move from node $$$a$$$ to $$$b$$$ with cost $$$\lt k$$$, then $$$w_k$$$ will be less than $$$t$$$ in this path. Otherwise, for every paths from $$$a$$$ to $$$b$$$ we need to pass at least $$$t$$$ edges with $$$w>=t$$$, so we have $$$w_k>=t$$$ for every paths. Therefore to solve this problem, we can sort all edges by $$$w$$$ from lowest to highest, change their cost from $$$1$$$ to $$$0$$$ one by one, and for any query $$$(a, b, k)$$$, if cost from $$$a$$$ to $$$b$$$ dropped down to $$$k-1$$$ or less, we know the answer for this query is $$$w$$$. So the rest we need to do is keep updating value of $$$cost(a, b)$$$ when cost of edges changed. The initial cost can calculated by Floyd's algorithm in $$$O(n^3)$$$, and $$$cost(a,b)$$$ can decrease at most $$$n-1$$$ times, because if nodes $$$a, b$$$ is connected with edges of weight $$$0$$$, adding an edge with cost $$$0$$$ on $$$(a, b)$$$ will not cause any change of cost on this graph. Each time such decreasement occurs we can recalculate $$$cost(u, v)$$$ for all pairs in $$$O(n^2)$$$. So the problem can be solved in $$$O(n^3+ m\log(m) +q\log(q))$$$.

G: If you've planted sugar cane in Minecraft, the answer is easy to come up with: First, we find all positions $$$(i, j)$$$ where $$$-1<=i<=n$$$, $$$-1<=j<=m$$$ and $$$(i+3j) mod 5 = 0$$$, and try to add these positions into $$$S$$$: If position $$$(i,j) \in A$$$, we add it into $$$S$$$ directly, any otherwise for each adjacent position $$$(i', j')$$$, we add it into $$$S$$$ if $$$(i', j') \in A$$$. Therefore we've built a set $$$S$$$ satisfies the second condition. To match the first condition, we repeat this process for $$$r \in [0,4]$$$ and $$$(i+3j) mod 5 = r$$$, and pick the set with minimum size, this set will satisfy the size condition. (Prove by AC)

i hate problems like C

A: I don't know why this works

B: I don't know why this doesn't work (later edit: forgot to pop from priority_queue :(, somehow first pretest passes with this bug X( )

RIP one and a half hour for D LOL. Come back CM anyways.

How to solve C ?

Hi

Very heavily math based contest this time...

I joined an hour late (oops), solved A, B and C. I particularly enjoyed C, but that's just me due to my heavy math background.

This contest might be a bit unpopular with the crowd though... knowing how Goodbye 2023 went...

B: I am sure we were presented a totally different problem... I cannot understand why this happens with this many testers (and why so many contestants "solved" it without trouble), please write a correct statement. The Codeforces rule is also bad and this issue affects too much to the performance.

G (and in general): Why ML 256MB?

H: Chip-firing is well-known. Anyway I needed some observation, so perhaps it is okay.

G is much easier than C. Even 5-year-olds have solved it while building sugar cane farms in minecraft.

i thought C's solution was really cool, im surprised people hate it so much

AB are nice problems.

I don't like bit manipulation constructives so C was kinda hard for me. And also it looks to be above average div2C in terms of complexity.

D is an interesting problem. I would love to have more time to think on D as I even didn't manage to get an idea. Too bad C took all my time.

Ehh well. I guess I need to solve some more bit constructives.

I failed to implement D with segment tree in time.... I just spent too much time doing it the wrong way.

I got 7 CE in F with C++20 and C++23. Didn't manage to fix it during the contest. WTF is that? :) Works on my computer just fine. After the contest, I decided to switch to C++17 in the custom invocation tab and it compiles normally. Is everything ok with the compiler?

can someone hack my solution for C? I just brute force things for a while and actually correctly guessed it. Sub: 299665561

I don't have any proof, my approach is finding the best fit for l ^ r, the third one is anything (I tried through brute force for this observation).

Let's say bl = bit of l, br = bit of r (At bit i). If bl == br:

• if bl == 0 means we need to set bit l[i]
• else (bl == 1) we need to del bit r[i]

The purpose is finding max l ^ r so the goal is 0 ^ 1 == 1 for every bit possible.

i hate the c++ vscode debugger and i hate my life

What a contest man, Please never make such type of contest!!

[deleted]

Russians are setting mathforces and the chinese are now creating good rounds. How the tables have turned.

E1 and E2 are free standard problems, but unfortunately, I am intellectually disabled.

Happy new year!

I especially love problems C and G in some ways. However, people solving ABCDE1E2 have varying performance score from 2000 to 2800, which, looks very scary. I'd say my overall feedback after participating Hello 2025 is: Goodbye 2025.

Problem D is anti python users , 2 Seconds is not fair

Here is some feedback on the problems:

• A: Nice problem!
• B: Bad problem and wrong statement. I agree with hos.lyric that having wrong statements should be more carefully avoided.
• C: Nice problem! It's rare that I have to think for a problem C. This one required me to stop and think and therefore I liked it!
• D: The problem is a bit standard. But it is clean and I appreciate it. I had not written a segment tree in years, so the implementation felt harder that it should have.
• E: After reading the statement, I could immediately solve E1 and I had no idea of how to solve E2. In the end I passed pretests also in E2 with an algorithm that I think should get TLE. I kinda liked thinking about it, but I have one doubt. LOL. Writing this comment I realized how to solve E2 (I guess it's a DSU). I spent more than one hour thinking about it and now, while typing this comment and trying to describe my "doubt" I solved it.
• F: Skipped
• G: The statement is amazing. I thought about it for some 15 minutes. No idea of how to solve it. It seems like a great problem.

Overall I enjoyed participating. I would have had a bit more fun if the statements were a bit more carefully written, but that's fine. Thank you to all those involved in the organization.

For D, I understood that we have to build a Segment Tree for a + i and a — i, but how to find the answer after every query?

If there are some well-known techniques in C

The tasks were ok overall. E should not appear on codeforces, and D is on the edge of being fine. On the other hand, C was nice, and G too (exactly the type of task I will not solve).

E1 absolutely should not appear on CF (and I don't know what it was doing in the original round either), E2 is arguably fine but I dont like it either. Fairly standard, almost ABC-like (infact i remember a similiar trick in a ABC contest)

The preparation seemed somewhat rushed, especially with the major error on B.

Why does my E1 have TLE? I need an explanation

As a Python user, I know it is my fault but I HATE hacks against hash-based data structures :(

Awwww my B got FST because of TLE what the hell??? Is the Counter lib from python collections vulnerable to hacks?

It seems that map passes test in B, whereas unordered_map results in TLE — I don't think this should be the case...

it feels so great to be hacked on b)))

hello, 2025

Thanks for the contest! I like pC very much.

But about problem E, I think it's quite bad to define path to allow going through same vertex multiple times, since it contradict the conventional definition of path, and it's better to call it a "walk" instead of "path".

All solutions for B using unordered_map are getting TLEs. Isn't it supposed to run faster than ordinary map or am I missing something here?

Why is Python collection Counter prune to hashing hacks but not ordinary map regarding problem b ? UPD: never mind

pls do something about problem c. though i used map and my solution got accepted but it is kinda sad for people who used unordered_map instead of map. c was a comparatively harder today making most of them solving only problem A and getting tle at B

My screencast in rust

The use of an unordered map in the second question is making me sad

299698148 Can someone explain me why my B got TLE

I had some seroius troubles with the TLs in this round. Sure, it is about kotlin, but I feel like it could have been a little bit more lenient.

D: The direct $$$O(6C3 q log n)$$$ solution with max-matrix should have passed. I don't think it should be cut.

E: I end up taking the clean $$$O(n^3)$$$ route. I am scared of $$$O(n)$$$ many 01-BFS on $$$O(n^2)$$$ edges, but perhaps I worried too much.

F: My solution that performs O(\log MAX n) ordered set operations are not fast enough, since in many cases I need to perform 3 or 4 searches for every "normal" operation. Though, I did not completely anticipate it being not fast enough, and would have opted for a segment tree/sorting+BS/BIT apporaches instead.

G: The overhead from declaring n different arrays was too much to handle, and I ended up needing to swap n, m when n is large. Allowing extra memory for this case would have been nice. I also see no reason to make the TL this tight -- it is not like there is any significantly easier solutions if an extra log or two are allowed.

Even though it is part of my issues for using Koltin and accepted the TL issues associated with it, I feel like in quite a few cases it was needlessly harsh.