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

As a participant, I hope the problems are interesting!

As a tester, Imakf 🤤🤤🤤

omg 3 subtasks round

As a tester, I can say that the problems are all very interesting. Thank you for your participation.❤️❤️❤️

As a tester, I must say that the problems are all very nice.

Genius lgm problemsetter imakf, I'm a big fan of yours! orz imakf, orz waaitg, orz Cocoly1990!

So basically everyone who solves $$$G2$$$ and $$$G3$$$ gets $$$150$$$ more points each.

As we all know, a problem can be split into subtasks only when it's difficult to solve completely.

No matter how the round turns out, had to upvote for the emojis 😌

As a tester, I have to say that all the problems are very interesting!

orz Cocoly1990, Imakf and waaitg!

Note unusual timing

As a writer,i want contribution.

omg emoji round

As a tester I can say that you will really enjoy the problemset. I would suggest you to read all the problems. Problemsetters and errorgorn have tried their best to make statements easier to understand.

As a tester, Orz Cocoly1990.

Editorial filled with emotes lol... My reaction for the Global Round as usual ^,^

Orz Imakf <《^,^》>

The last line is completely illegal, how will be the ratings gonna balanced than?

As a tester, i think that the problems are all very interesting.

All the problems are very interesting!

orz Cocoly1990, Imakf and waaitg!

Consecutive rounds! :O

Too many emojis, downvoted. Hope the contest is good tho.

As a tester, I'm still curious how the authors found me for testing, I didn't know any of authors :D
btw, don't miss this great, well prepared round from such awesome authors!

As a first time tester, this is definitely the best round I ever tested

Note :: UNUSUAL TIME OF CONTEST

Brillant use of emojis

omg emoji round

Oops

as a participant I hope I will get +100 delta.

I want another ConstructForces like 836 div.

There are 10 subtasks, but I have a feeling only 4 would be doable by < master. Let's see, excited. Hopefully master tomorrow!

Thank you coddeforces

hoping to solve upto D!! :)

hopefully no choking this round

Celtic /se

Chinese round! /tyt

Hello everyone, I am a beginner programmer. I don’t know about the difficulty of Global round 24 . Anyone could explain about difficulty of problem in this round.

Because of my university online exam in contest time. I can't participate in this round. Feeling sad.

https://codeforces.com/contestInvitation/e949aed8ba775616b4e21b10a0c1480426f6ff8a

Emojforces ☺️

Hope for fun with the interactive one and (3 subtasks) one .Best of luck everyone.

nice emoji

Does score distribution imply that I should skip to G1 after D.

Everyone for good luck!

omg Imakf round

As a participant, this round is my decisive battle.

don't expect much you will do better.

G1 easier than F, E .. intersting :)

So G has 3 subtasks? XD

The problems are good quality.It suprised me very much.I am looking forward to more contests!

Solution videos for problem B on youtube combined have over 1600 views.

Unfortunately, people who uploaded videos didn't show their usernames, but one of them has to be vedantkakade.

MikeMirzayanov

The top standings in this contest are a good example of why the scoring system needs to be reformed, in my opinion.

:|

Why is div1+2 D so hard again?

the solutions to the first three problems were on youtube before the test was over, I think this interferes with the scoring of the round as many can copy and paste the solutions.

What was the logic in number B?

How could C be approached?

Scariest problem D

How to solve D?

how to solve B?

Anyone has the answer in D.(answer like O(1))?I mean an explicit formula

What a tough contest :(((

C was quite tough to spot the right answer.

Solved problem F in a Div 1+2 Round for the first time! Yay

How to solve Problem D when n % 2 = 1?
In even cases, ig we had to consider diagonals, so, in the odd ones triangles?

D actually ended up being fun lol

Only solved till C but my best div 2 round so far.

Any hint of problem C , (PLEASE DON'T GIVE COMPLETE SOLUTION)

182673131

what was the problem in this approach can anyone tell ? i was checking if all were divisible! if then ans is max/min else ans is max why i got WA in this approach didn't understand

Here is some feedback on the problem set:

• A: Nice easy problem. First time in my life I submit without checking the correctness on the examples.
• B: Somewhat standard, but ok (set of integers, operations, what can you get? -> gcd). I enjoyed it.
• C: Ok problem. I did not prove my solution, though I think that I can prove it in 5 minutes.
• D: Standard problem, appropriate difficulty. I am not a fan since I knew what to do immediately after reading the statement (and then I did a mess... but that's another story).
• E: Wonderful. I sent 3 solutions, and I thought I had a proof for all of them. But the first two were wrong (not a bug, the algorithm was wrong). I really enjoyed this one. One is naturally lead to try and "get the biggest possible number" but the correct strategy is to go backward and I needed quite some time to understand it.
• F: Ok problem. The statement is far from interesting. The observation that we can understand if $$$i,j$$$ are adjacent by looking at $$$f(i,\cdot)-f(j,\cdot)$$$ is cool (I was lucky and it was the first thing I tried). Then, I passed the pretests with a randomized solution which I am not 100% should pass the tests (since it may be too slow).
• G: Thought about this one for 30 minutes straight. Not a single idea. I cannot solve it even with $$$n$$$ queries. Truly seems impossible, great problem. [edit] After reading the solution, I don't think anymore it is a great problem, still a very nice one though (because it seems totally impossible without the right idea).
• H: Not read.

Overall the contest was very well prepared, the problems were nice, and the difficulties were on the spot. Congratulations to the authors!

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

Please dont do cheating guys,it hurts alot especially in rankings and ratings

Why does taking gcd of the whole array and then dividing it by the last number work in Problem B?

Who else agrees that the 2nd sample test case for problem C should be explained as well

So close to solving D.

if n is even, go over all pairwise points, pretend this is the arc when it first touches the blue pin. We know that this can only happen with the smaller arch, and that the last point removed before it gets to this arc must be one of the opposite pin with the smaller arc. From there just do nCk and multiplies with factorial of two sets of points.

if n is odd, solve similarly, except the outer arcs count before getting to this arc is the number of edges of adjacent pin instead of the number of points.

a similar problem as problem B: https://codeforces.com/contest/347/problem/C

Thanks for the fast editorial! Also thanks for the round.

Problem E:

How can the answer of input

1

3 5

3 2

2 1

1 2

be "YES"?

I got WA2 and this is the case I failed :(

Thank you for problem G!
Actually reloaded the page a couple of times to make sure it's $$$\le 30$$$ queries, not $$$30 n$$$ or something.
The feeling of just how impossible the problem seems at first... priceless.

Ratings updated preliminarily. We will remove cheaters and update the ratings again soon!

B is pretty hard for usual B imo. It’s an easier version of a 1800 rated problem. And that problem has negative numbers

it’s so bizarre that B has so many submission.

finally a round i enjoyed :)...

Completely forgot that on resubmission previous submissions are skipped, Resubmitted D for stupid reason, got -50 and +25 minutes.:(

Thanks for the great problems and well-balanced round!

The only negative thing I noticed is score distribution. Complexity jumps between A-B and B-C is definitely smaller then the ones between C-D and D-G1 (cannot say about other problems), but the point difference is two times bigger.

Anyways, kudos to the problem setters and testers for an awesome job!

Thanks for the round! I think F is incredible, and C is fun too.

Problem D really pegged me.

Intially I thought of Bipartite Solution

">" -> Red edges, "<" -> blue edges and then For "=" I did not understand which color to assign and thought Bipartite wouldn't fit.

To add Fire to above thought. I came up with a pattern which is giving solution for 2nd example

1) sort the array 1 2 2 4 5 5 In Most of Hill and valley problems this pattern helps 2) And use the pattern [a1,a2,a3,a4,a5,a6] => [a1,a4,a2,a5,a3,a6] 3) In above pattern if we connect edges to adjacent and also connect each vertex with every vertex alternatively I got all the edges so dumped the idea of bipartite and tried to code the above approach

What is that C question ?. I tried it for almost one day. I went nowhere

UnRated?

For me, E is very very easy, even easier than C. I can't understand why people struggle with it. When I saw problem E I was like, well, this problem can't be just a straightforward greedy problem, there must be something that I missed, but indeed it is. You just sort the colors by $$$x$$$ and then find the maximum position that could be colored by colors other than $$$1$$$. I did struggle a lot on C and D. In C I didn't realize that the resulting graph could only be a bipartite graph, In D I ended up with a much more complicated approach using Inclusion-Exclusion Principle. To be clear, I'm not complaining, I'm just curious that maybe some people would have the same feeling as mine.

I think my F would be a little better than std.
The beauty of this problem lies in $$$f(x,x)$$$. It is not difficult to find that the closer the point to $$$x$$$, the more times the point is repeated, and the different $$$x$$$, the different times each edge is repeated ~~ (isn't it obvious) . So we can actually figure out the distance between any two points based on this property. Here's an example (in the figure, the red number indicates the number of counts) :

You will find that all the edges are repeated the same number of times except for the number of times that the edges between the two $$$x$$$are repeated, so you can consider the inclusion repulsion, which is actually $$$dis_{x_1,x_1}+dis_{x_2,x_2}-2 \times dis_{x_1,x_2}$$$. This should make sense, and when you're done, you actually find that the point between the two $$$x$$$has been calculated exactly $$$n$$$. In fact, it is easy to prove that for $$$2 \times dis_{x_1,x_2}$$$the middle of the two $$$x$$$must not be counted because it is already looped, And then $$$dis_{x_1,x_1}+dis_{x_2,x_2}$$$actually understands that every point is on the edge between these two $$$x$$$, so repeat the $$$n$$$ calculation. So we've figured out the distance between any two points, and now we want to generate a tree, and in order to satisfy the distance that we figured out before, we need to minimize each edge, so we need to minimize the spanning tree.

Congratulations to tshirts winners! In a few weeks you will be contacted via private messages with instructions to receive your prize.

As usual, we used the following two scripts for generating random winners, seed is the score of the winner.

#!/usr/bin/python3

import requests

contests = [1764]

# [1, rank_start) get tshirts with no random
# [rank_start, rand_end] get random tshirts
rank_start = 31
rank_end = 500

n_random_tshirts = 20

def is_eligible(contest, party_name, rank, points, problems, last_submission_time):
    return (rank <= rank_end)

def get_party_name(party):
    if 'teamName' in party:
        return party['teamName']
    else:
        return party['members'][0]['handle']

class Party:
    def __init__(self, contest, name, rank, points, last_submission_time):
        self.contest = contest
        self.name = name
        self.rank = rank
        self.points = points
        self.last_submission_time = last_submission_time
    
    def __lt__(self, other):
        if self.contest != other.contest:
            return self.contest < other.contest
        if self.rank != other.rank:
            return self.rank < other.rank
        if self.last_submission_time != other.last_submission_time:
            return self.last_submission_time < other.last_submission_time
        if self.name != other.name:
            return self.name < other.name
        return False

eligible = []

for contest in contests:
    rows_to_fetch = 20000
    r = requests.get('https://codeforces.com/api/contest.standings?contestId=%d&from=1&count=%d&showUnofficial=false' % (contest, rows_to_fetch))
    if r.status_code != 200 or r.json()['status'] != 'OK':
        print('Error: failed to fetch results of contest %d.' % contest)
        exit()
    results = r.json()['result']['rows']
    if len(results) == rows_to_fetch:
        print('Error: results are too long in contest %d, increase limit.' % contest)
        exit()
    for row in results:
        party_name = get_party_name(row['party'])
        rank = row['rank']
        points = row['points']
        problems = 0
        last_submission_time = 0
        for problem in row['problemResults']:
            if problem['points'] > 0:
                problems += 1
                last_submission_time = max(last_submission_time, problem['bestSubmissionTimeSeconds'])
        if is_eligible(contest, party_name, rank, points, problems, last_submission_time):
            eligible.append(Party(contest, party_name, rank, points, last_submission_time))

eligible = sorted(eligible)

for i in range(1, len(eligible)):
    if not eligible[i - 1] < eligible[i]:
        print('Error: unable to sort eligible at positions {} {}.'.format(i, i, i + 1))
        exit()

#print('Eligible for tshirts are:')
#for idx, party in enumerate(eligible):
    #print('{} {} {} {} {}'.format(idx + 1, party.contest, party.rank, party.name, party.last_submission_time))


seed = eligible[0].points

print('Total %d eligible, seed is %d.' % (len(eligible), seed))

import subprocess
testlib_rand = subprocess.run(['./randgen', str(seed), str(len(eligible)), str(rank_start - 1),    str(n_random_tshirts)], stdout=subprocess.PIPE)
winners = list(map(int, testlib_rand.stdout.split()))

print()
print('Winners are:')
for place in winners:
    print('{}'.format(eligible[place - 1].name))

#include "testlib.h"
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    if (argc < 4)
    {
        cout << "Command line arguments are: seed length prefix nwinners" << endl;
        return 1;
    }
    int seed = atoi(argv[1]);
    int len = atoi(argv[2]);
    int prefix = atoi(argv[3]);
    int nwinners = atoi(argv[4]);
    rnd.setSeed(seed);
    
    set<int> winners;    
    while ((int)winners.size() < nwinners)
        winners.insert(rnd.next(prefix + 1, len));

    for (int i = 1; i <= prefix; ++i)
        winners.insert(i);
    
    for (auto winner: winners)
        cout << winner << " ";
    cout << endl;
    
    return 0;
}