こんにちは, Codeforces!

Isn't this quite late for the announcement to come out

what's the score distribution?

i have engineering graphic exam the next day of this round but i am from a warrior race

As a spectator excited to see how many of our talented newbies AK the contest

hope to become CM

The subarashi in Japanese takes you to a random subarashi video. crazy man

May the force be with you to rock on..

All the best everybody :)

what about scores?

As a participant, I hope to solve two or three problems in this contest.

I hope it is not a speed round.

Hope to be Pupil!

Hoping for colour change delta

6 OR 7 problems, where OR means the bitwise "we don't know" operation

Should I be scared?

I'll get orange now

Subarashiiiiii!!!! (¬‿¬)(¬‿¬)(¬‿¬)

Happy May Day!

The OR in the announcement is the bitwise AND operation

As a participant, there will be a lot of blogs about cheaters right after the contest.

hoping for the first time in top 4k in div2 !

Scores? A: 500 B: 1250 -_- Used to seeing A 750 and B 1k guess now that’s the new norm.

Cherry_blossom_ this person used ai in the last educational round and most probably is using ai now

hhh, I have used too many time on problem B. It is a good problem!

me reading problem A .. is this div1 A

me reading problem B .. is this div1 B

I had 30+ seconds remaining, yet the submit button was not clicking. Too bad codeforces.

When is editorial coming out

What's up with these shitty difficulty distributions lately? D is way too hard for its position.

Hi, may someone please explain me D or give me a hint on why I might get TLE?

My submission is: 318015724

At first sight: C<D

In fact: C<<<<<<D

Your explaining pictures are excellent! I like it very much! How did you make it?

B,C=C,B

for the question 2 :

how the answer is 8 or 5 0 can someone elaborate ??

because for length 5 the minimum sum can be 4 1 1 1 1 0

Worst round I have joined yet

personally, I felt like the difficulty order was A > B > C.

casework in B makes it much tougher compared to C, C is just simple observation and sets

What is the question of B, inexplicable！！！！

am i dumb or was c more doable than b?

Did the authors mistakenly perform B^=C, C^=B, B^=C?

Can anyone please help me with this code for problem C. It passed the first pretest but was failing again and again in second pretest. Any help would be appreciated.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

public class ProblemC {
    public static class FastReader {
        private BufferedReader buffer;
        private StringTokenizer tokenizer;

        public FastReader() {
            this.buffer = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(buffer.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() { return Integer.parseInt(next()); }
        public long nextLong() { return Long.parseLong(next()); }
    }

    public static void main(String[] args) {
        FastReader fast = new FastReader();
        final StringBuilder output = new StringBuilder();
        int t = fast.nextInt();
        while(t-- > 0) {
            final int n = fast.nextInt();
            long nums[] = new long[n];
            for(int i = 0; i < n; i++)
                nums[i] = fast.nextLong();
            output.append(solve(n, nums)).append("\n");
        }
        System.out.print(output);
    }

    public static int solve(final int n, long nums[]) {
        Map<Long, List<Integer>> indexMap = new HashMap<>();
        boolean marked[] = new boolean[n];
        for(int i = 0; i < n; i++) {        // Creating a map to store the indices of similar elements
            if(!indexMap.containsKey(nums[i]))
                indexMap.put(nums[i], new ArrayList<>());
            indexMap.get(nums[i]).add(i);
        }
        Arrays.sort(nums);      // Sort the weights array
        int index = n-1, count = 0;     // Start from descending order
        while(index >= 0) {
            for(int marker : indexMap.get(nums[index])) {
                // For each index of the same value
                if(!isMarked(marked, marker, n))     // check whether it can be marked
                    count++;            // If it cannot be marked create a clone there and mark it
                marked[marker] = true;
            }
            index -= indexMap.get(nums[index]).size();      // Subtract the group size to get to the next group
        }
        return count;
    }

    public static boolean isMarked(boolean marked[], int index, int n) {
        if(index > 0 && marked[index-1])        // Left check
            return true;
        else if(index < n-1 && marked[index+1])     // Right check
            return true;
        return false;       // If both check fails then it cannot be marked currently
    }
}

how to solve D, E ?

D seems like binary search problem. I may be wrong.

The gap between C and D is too big!

I spend on A,B,C for only 30 min, but it took an hour and a half on solving D, and there was still no gain from D.

Is this a penalty sitting?

took too long to realize A. and got cooked on B.

I hope the System tests accounts for O(n) sols in D.

In problem D, does there exist a test case that we can find the lengths of arrays A and B in more than 250 queries?

Where is the editorial?

why not swap pB & pC, and it's the worst pB I experienced.

Problem E

In my humble opinion, B was really not fun. I couldn't find a better approach than to enumerate edge cases, which isn't much interesting imo.

who spent time actually figuring out problem A.. I just guessed it will always be even :( very sad.

Edit: Nvm I outputted x+1 instead of x.