Dear participants!

We remind you that until 22:00 MSK on October 21, 2026, you can start your virtual participation. Everyone who starts the contest before this time will be included in the final standings.

We strongly ask you not to cheat. At the moment, we have already noticed several suspicious participants. The disqualification process will begin immediately after all virtual participations end.

The final results will be announced no later than October 23, 2026. A minimum score threshold will be specified for each track in the final standings. If you do not reach this threshold, you cannot claim any prizes. We guarantee that the threshold will be low enough for at least two participants to pass.

Winners must contact the administrator (Arbuzik342) within 7 days after the results are announced. Otherwise, the prize will be passed to the next participant.

Preliminary best results (before the removal of cheaters and virtual participants): * A&DS-1: 700 points, wrong submissions: 5 * A&DS-2: 340 points, wrong attempts: 6

Link to A&DS-1 Final

Link to A&DS-2 Final

Hello, Codeforces!

We, zeyd1234 and Arbuzik342, are glad to present to you the final round of our contest!

Participants will face two independent tracks: A&DS-1 and A&DS-2. The winner of each track will receive prize from the Sirius Educational Center.

Format and Structure

Anyone within the rating limits can participate in the final. * Problems D, E, F, G in the A&DS-1 track and problems A, B, C, D in the A&DS-2 track are shared. * The rest of the problems in each track are unique. * The contest duration is 4 hours.

Each problem is divided into several subtasks and is scored in points. Please note: the problems are NOT ordered by difficulty! We recommend reading all problem statements before starting to solve.

Schedule and Virtual Participation

The contest starts at 18:00 MSK on October 18, 2026.

If you cannot participate in real-time, you can start a virtual contest within 72 hours after the end of the round — your result will still count towards the final standings.

Winner Determination Rules

The final standings are based on the total points. In case of a tie in points, the priority is given as follows: 1. Participants who successfully passed the qualification round. 2. Participants with fewer wrong submissions (a submission is not considered wrong if it fails on sample tests or gets a Compilation Error).

Thank you all, and good luck in the final!

Link to A&DS-1 Final

Link to A&DS-2 Final

The qualification round is over. We are publishing the final results and track distribution.

Results Table

Track Distribution

Advanced to A&DS-2: - shvepsi_ - OG_Maksimchick4 - RHEXAOC - NajmuddinSabr

Advanced to A&DS-1: - fogsmozetvse

Choice — participants may join either of the two parallels (A&DS-1 or A&DS-2) at their discretion: - SalavatMukhamenshin - Aerin - bipki - IsKatel

RLE (Rating Limit Exceeded) — rating exceeds the allowed threshold for A&DS-2: - Ice_man2.0 - wery0 - dooglius

What's Next

Wait for the final round and take part. Everyone can participate in the final, but only those who successfully passed the qualification can compete for prizes. Please note:

• If your qualification track is A&DS-1, but in the final you take 1st place in A&DS-2, you will not receive a prize. This may seem paradoxical, but those are the rules.
• The reverse also applies: if your track is A&DS-2, but in the final you take 1st place in A&DS-1, you will not receive a prize either.

The best in each track will receive prizes.

Thank you all for participating in the qualification round! See you at the final.

Link to A&DS-1 Final

Link to A&DS-2 Final

Link to the EXCEL file with results (Russian version only)

A. Queue for Puffball

Idea: Arbuzik342 Preparation: Arbuzik342, zeyd1234

if (amount[a] != amount[b]) return amount[a] > amount[b];
return firstTime[a] < firstTime[b];

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    vector<int> people(n);
    vector<int> amount(m + 1, 0), firstTime(m + 1, -1);
    for (int i = 0; i < n; i++) {
        cin >> people[i];
        amount[people[i]]++;
        if (firstTime[people[i]] == -1) {
            firstTime[people[i]] = i;
        }
    }
    vector<int> uniqueFamilies;
    for (int x = 1; x <= m; x++) {
        if (amount[x] > 0) {
            uniqueFamilies.push_back(x);
        }
    }
    sort(uniqueFamilies.begin(), uniqueFamilies.end(),
         [&](int a, int b) {
             if (amount[a] != amount[b]) {
                 return amount[a] > amount[b];
             }
             return firstTime[a] < firstTime[b];
         });
    for (int fam : uniqueFamilies) {
        for (int k = 0; k < amount[fam]; k++) {
            cout << fam << ' ';
        }
    }
    cout << '\n';
    return 0;
}

B. No Extra Comparisons

Idea: Arbuzik342 Preparation: Arbuzik342, zeyd1234

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    long long totalSeconds = 0;
    int limit = n - 1;
    while (limit > 0) {
        int lastSwap = -1;
        for (int i = 0; i < limit; i++) {
            totalSeconds++;
            if (a[i] > a[i + 1]) {
                swap(a[i], a[i + 1]);
                lastSwap = i;
            }
        }
        if (lastSwap == -1) {
            break;
        }
        limit = lastSwap;
    }
    cout << totalSeconds << '\n';
    return 0;
}

C. Remember the Alphabet

Idea: Arbuzik342 Preparation: Arbuzik342, zeyd1234

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;
    vector<int> nextLetter(26, -1), prevLetter(26, -1);
    vector<int> appears(26, 0);
    for (int i = 0; i < n; i++) {
        char x, y;
        cin >> x >> y;
        int a = x - 'A', b = y - 'A';
        appears[a] = appears[b] = 1;
        if (nextLetter[a] != -1 && nextLetter[a] != b) {
            cout << "NO\n";
            return 0;
        }
        if (prevLetter[b] != -1 && prevLetter[b] != a) {
            cout << "NO\n";
            return 0;
        }
        nextLetter[a] = b;
        prevLetter[b] = a;
    }
    int start = -1;
    for (int i = 0; i < 26; i++) {
        if (appears[i] && prevLetter[i] == -1) {
            if (start != -1) {
                cout << "NO\n";
                return 0;
            }
            start = i;
        }
    }
    if (start == -1) {
        cout << "NO\n";
        return 0;
    }
    vector<int> visited(26, 0);
    string result;
    int cur = start;
    while (cur != -1) {
        if (visited[cur]) {
            cout << "NO\n";
            return 0;
        }
        visited[cur] = 1;
        result += char('A' + cur);
        cur = nextLetter[cur];
    }
    int totalUsed = 0;
    for (int i = 0; i < 26; i++) {
        totalUsed += appears[i];
    }
    if ((int)result.size() != totalUsed) {
        cout << "NO\n";
        return 0;
    }
    cout << result << '\n';
    return 0;
}

D. Opening Cases Is Profitable

Idea: Arbuzik342 Preparation: Arbuzik342, zeyd1234

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    vector<long long> value(n + 1, 0), best(n + 1, 0);
    for (int i = 1; i <= n; i++) {
        cin >> value[i];
    }
    for (int i = 1; i <= n; i++) {
        int jumpBack = i - m - 1;
        if (jumpBack < 0) {
            jumpBack = 0;
        }
        best[i] = max(best[i - 1], value[i] + best[jumpBack]);
    }
    cout << best[n] << '\n';
    return 0;
}

E. Mountains of Flatland

Idea: Arbuzik342 Preparation: Arbuzik342, zeyd1234

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m, q;
    cin >> n >> m >> q;
    map<int, pair<int,int>> bestCell;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            int h;
            cin >> h;
            auto it = bestCell.find(h);
            if (it == bestCell.end()) {
                bestCell[h] = {i, j};
            } else {
                auto [row, col] = it->second;
                if (j < col || (j == col && i < row)) {
                    it->second = {i, j};
                }
            }
        }
    }
    while (q--) {
        int h;
        cin >> h;
        auto it = bestCell.find(h);
        if (it == bestCell.end()) {
            cout << -1 << '\n';
        } else {
            cout << it->second.first << ' '
                 << it->second.second << '\n';
        }
    }
    return 0;
}

F. Bridge Destruction

Idea: Arbuzik342 Preparation: Arbuzik342, zeyd1234

#include <bits/stdc++.h>
using namespace std;

const int INF = 2e9 + 7;

struct SegTree {
    int n;
    vector<pair<int,int>> tree;
    bool preferRight;
    SegTree(int sz, bool pr) : n(sz), preferRight(pr) {
        tree.resize(4 * sz + 4);
    }
    pair<int,int> combine(pair<int,int> a, pair<int,int> b) {
        if (a.first < b.first) return a;
        if (b.first < a.first) return b;
        if (preferRight) {
            return {a.first, max(a.second, b.second)};
        }
        return {a.first, min(a.second, b.second)};
    }
    void build(int v, int l, int r, const vector<int>& strength) {
        if (l == r) {
            tree[v] = {strength[l], l};
            return;
        }
        int mid = (l + r) / 2;
        build(2*v, l, mid, strength);
        build(2*v+1, mid+1, r, strength);
        tree[v] = combine(tree[2*v], tree[2*v+1]);
    }
    void update(int v, int l, int r, int pos) {
        if (l == r) {
            tree[v] = {INF, l};
            return;
        }
        int mid = (l + r) / 2;
        if (pos <= mid) {
            update(2*v, l, mid, pos);
        } else {
            update(2*v+1, mid+1, r, pos);
        }
        tree[v] = combine(tree[2*v], tree[2*v+1]);
    }
    pair<int,int> query(int v, int l, int r, int ql, int qr) {
        if (ql > r || qr < l) return {INF, -1};
        if (ql <= l && r <= qr) return tree[v];
        int mid = (l + r) / 2;
        pair<int,int> leftPart = query(2*v, l, mid, ql, qr);
        pair<int,int> rightPart = query(2*v+1, mid+1, r, ql, qr);
        return combine(leftPart, rightPart);
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    vector<int> strength(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> strength[i];
    }
    string order;
    cin >> order;
    SegTree treeBerland(n, true), treeFlatland(n, false);
    treeBerland.build(1, 1, n, strength);
    treeFlatland.build(1, 1, n, strength);
    treeBerland.update(1, 1, n, m);
    treeFlatland.update(1, 1, n, m);
    int leftBorder = m;
    for (char c : order) {
        int idx;
        if (c == 'B') {
            idx = treeBerland.query(1, 1, n, 1, leftBorder - 1).second;
        } else {
            idx = treeFlatland.query(1, 1, n, leftBorder + 1, n).second;
        }
        cout << idx << ' ';
        treeBerland.update(1, 1, n, idx);
        treeFlatland.update(1, 1, n, idx);
        leftBorder = min(leftBorder, idx);
    }
    cout << '\n';
    return 0;
}

G. Simple but Not Simple

Idea: Arbuzik342 Preparation: Arbuzik342, zeyd1234

#include <bits/stdc++.h>
using namespace std;

const int MAXV = 10000000;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    vector<int> spf(MAXV + 1, 0);
    vector<int> primes;
    for (int i = 2; i <= MAXV; i++) {
        if (spf[i] == 0) {
            spf[i] = i;
            primes.push_back(i);
        }
        for (int p : primes) {
            if (p > spf[i] || (long long)i * p > MAXV) {
                break;
            }
            spf[i * p] = p;
        }
    }
    int q;
    cin >> q;
    vector<int> divCount(MAXV + 1, 0);
    int conflicts = 0, goodMoments = 0;
    while (q--) {
        string op;
        cin >> op;
        char sign = op[0];
        int value = stoi(op.substr(1));
        vector<int> primeFactors;
        while (value > 1) {
            int p = spf[value];
            primeFactors.push_back(p);
            while (value % p == 0) {
                value /= p;
            }
        }
        if (sign == '+') {
            for (int p : primeFactors) {
                divCount[p]++;
                if (divCount[p] == 2) {
                    conflicts++;
                }
            }
        } else {
            for (int p : primeFactors) {
                divCount[p]--;
                if (divCount[p] == 1) {
                    conflicts--;
                }
            }
        }
        if (conflicts == 0) {
            goodMoments++;
        }
    }
    cout << goodMoments << '\n';
    return 0;
}

Hello everyone!

The qualification round of our contest has ended. We would like to thank everyone who participated!

Results and rejudges

During the round, an issue was found in the test set for one of the problems. The tests were updated, and all solutions have been rejudged. We apologize for the inconvenience.

Virtual participation

If you missed the round, virtual participation is available. Please note:

• Virtual participation can be started within 24 hours after the end of the contest — that is, until 20:35 MSK on October 4, 2026.
• All participants who have already finished, as well as those who start a virtual contest within the specified window, will be included in the final standings.

What to expect on the finals

Please note: during the qualification round we respond to all questions in detail. In the finals there will be no explanations — if you believe something is wrong, you will receive the reply: "The problem statement and tests are correct, look for the mistake in your own solution."

Good luck to everyone in the finals!

Qualification Round

Hello Codeforces!

Lately, I’ve been looking closely at the difficulty distribution in recent Division 4 rounds, and something feels fundamentally off.

When MikeMirzayanov originally introduced Div. 4, the core philosophy was clear: create an accessible, welcoming environment for absolute beginners and lower-rated participants to experience competitive programming without hitting an immediate, insurmountable wall. It was meant for people who are still mastering basic concepts.

But let’s look at the reality of recent contests. We are routinely seeing Problem G (and sometimes F) hitting 1700–1800+ difficulty ratings.

Is this really a natural "evolution" of the platform, or have we completely lost the original purpose of the division?

The Two Sides of the Coin

Like any controversial topic, there are two main perspectives here:

• The "Top Separator" Argument: Supporters argue that the last problem must be difficult. It acts as a hard separator for the top of the leaderboard and challenges those who are on the verge of outgrowing Div. 4.
• The "Beginner Shield" Argument: Div. 4 was created strictly for newcomers. The entire problemset should remain within their theoretical reach.

Personally, I strongly lean toward the second opinion.

Put Yourself in a Newbie's Shoes

Imagine being a true beginner. You are just learning how to handle arrays or basic loops. Then you open the latter half of a Div. 4 round and face a task that requires complex data structures or advanced dynamic programming to process thousands of elements, rather than a simple single-pass iteration. You physically and theoretically do not possess the tools to solve it yet.

If you were that newcomer, would you honestly feel motivated to participate in a contest where the final goals feel completely alien?

Right now, Div. 4 has become the most controversial contest format on the platform. Even though it is explicitly labeled for beginners, the back-end of the problemset is not adapted for them at all. It feels like inviting someone to a friendly introductory run, only to put a marathon-level wall at the very end.

Conclusion: It's Time to Rethink the Concept

We shouldn't just accept 1800-rated problems in a beginner round as a given. If a problem requires an Expert-level skillset, it belongs in Div. 3 or Div. 2, not here.

We need to modify the entire concept of Division 4 to keep it a genuine gateway for the community, rather than a format that intimidates newcomers at the finish line.

What are your thoughts on this? Should Div. 4 strictly cap its difficulty to protect the beginner experience, or is having an 1800-rated "boss fight" at the end healthy for growth?

Let’s discuss in the comments below!

Less than 2 hours left until the Sirius Qualification Round! Register now!

[Prizes RF Only / Statements EN & RU]

⚠️ NOTICE FOR INTERNATIONAL USERS

All problem statements will be fully available in both English and Russian! You are more than welcome to participate and solve the problems. Please note that physical prize delivery is strictly limited to the Russian Federation via Ozon, but everyone can compete for fun, rating, and practice!

Good day, dear Codeforces users!

This is a reminder that in less than 2 hours (at 17:35 Moscow time, UTC+3), the Qualification Stage of our contest series based on Sirius Educational Centre problems will begin!

High Chance to Win a Prize!

Right now, the registration activity is VERY low. This means competition is minimal, and it will be extremely easy to grab the prizes in the final round! Don't miss this perfect opportunity.

IMPORTANT RULE: Users who do not participate in today's qualification round will NOT be eligible for prizes in the finals. Even if you plan to write the final round later, you must go through this qualification to compete for prizes. Register now!

⚙️ About the Scoring System (IOI rules)

The contest runs under IOI rules, which differ significantly from the standard ICPC (Codeforces) format: * Partial Scoring: There are 7 problems, worth 100 points each. Problems are divided into subtasks. You get points for each test case or group of test cases you pass (details are in the problem notes). * Full Evaluation: If your solution gets WA, TLE, MLE, or any other error on a specific test, the grading process does not stop. Your solution will be tested on absolutely all test cases in the set. * No Penalty Time: The submission time and the number of attempts do not affect your final score. You can resubmit your code as many times as you want, and your best score for each problem will be counted. * Standings Ranking: Participants are sorted by the number of problems solved with a score of 80+ points. In case of a tie, the total sum of points is used.

Key Details:

• Format: 7 problems, IOI scoring system.
• Duration: Exactly 3 hours (17:35 — 20:35 MSK, UTC+3).
• Registration Link: Register for the Qualification Stage

For rating restrictions (max rating <=1900 for DSA-Advanced, <=1600 for DSA-Basic) and full rules, check the main announcement.

Acknowledgments

Special thanks to my friend and tester — zeyd1234 for preparing the round! Without his help, none of this would have been possible.

Thank you all, and see you at the round! Good luck!

Qualification Round starts today at 17:35 MSK!

Good day, dear Codeforces users!

We would like to remind you that in less than 8 hours (at 17:35 Moscow time, UTC+3), the Qualification Stage of our contest series based on Sirius Educational Centre problems will begin!

Detailed rules, the scoring system, and track distribution criteria can be found in our main announcement.

Key Details of the Qualification Round:

• Format: You will be given 7 problems.
• Duration: Exactly 3 hours (until 20:35 MSK).
• Registration Link: Register for the Qualification Stage

Important Rating Restrictions for Prizes:

• Absolute Maximum: Users with a maximum rating above 1900 are not eligible for prizes at all.
• Advanced Track (DSA-Advanced): ALL participants with a maximum rating of 1900 or lower can compete for prizes (provided they successfully pass the qualification).
• Basic Track (DSA-Basic): Only participants with a maximum rating of 1600 or lower are eligible to compete for prizes here.

Fair Play and Feedback

• Anti-cheat: We kindly request everyone to follow the fair play rules. In case of any suspicion of plagiarism or AI usage, a participant will receive a warning and may be disqualified, with their results cancelled.
• Results: Passing scores for the second stage will be published no later than 10.10.2026.
• Questions during the contest: During the round, the jury will try to answer all incoming questions as quickly as possible (usually taking no more than 20 minutes).

Acknowledgments

I would like to express my deepest gratitude to my friend and tester — zeyd1234. Without him and his help, none of this would have been possible!

Thank you all, and see you at the round! Good luck!

[Prizes RF Only / Statements EN & RU] Prizes from Sirius Educational Centre: IOI-format Contest!

⚠️ NOTICE FOR INTERNATIONAL USERS

Good news: All problem statements will be fully available in both English and Russian! You are more than welcome to participate and solve the problems. Please note that physical prize delivery is strictly limited to the Russian Federation via Ozon, but everyone can compete for fun and practice!

Good day, dear Codeforces users!

We are glad to present you a contest that is fully identical to the selection process for the computer science educational program at the Sirius Educational Centre. Over the course of three weeks, exciting problem sets await you. The top participants will receive prizes personally from me and the Sirius Educational Centre!

IMPORTANT: Participation Restriction

We kindly request those who have already participated in the official selection for the "Informatics. Regions" program at Sirius: please do not participate in this contest. The problems will be completely identical!

Schedule and Registration Links

• Round 1 (General Selection):
• Date and Time: 03.10.2026 at 17:35 (Moscow time, UTC+3).
• Duration: 3 hours.
• Who can participate: Everyone is welcome!
• Registration Link: Qualification Stage
• Results publication: No later than 10.10.2026.

• Round 2 (Finals by Tracks):

• Date and Time: 18.10.2026 at 17:35 (Moscow time, UTC+3).
• Duration: 1 hour.
• Who can participate: Everyone is welcome (however, only those who passed Round 1 are eligible for prizes).
• Registration Links:
  • Final Stage (DSA-Basic)
  • Final Stage (DSA-Advanced)
• Final results publication: No later than 23.10.2026.

Round 1 Rules and Scoring System

• Format: You will be given 7 problems, with a maximum score of 100 points for each.
• Testing System: The contest uses IOI rules. Each problem contains subtasks with a fixed number of points (details can be found in the problem notes).
• Grading details: WA, TLE, MLE, or any other verdicts on individual tests do not stop the grading process — your solution will be tested on all test cases in the set.
• Standings ranking: Participants are sorted by the number of problems solved with a score of 80+ points. In case of a tie, the total number of points is used.
• Advancement criterion: At least 30% of all participants are guaranteed to advance to the second stage. Passing scores and lists will be published no later than 10.10.2026.

Round 2: Tracks and Distribution

The final round is split into two parallel competitions: 1. DSA-Basic (Algorithms and Data Structures: basic level). 2. DSA-Advanced (Algorithms and Data Structures: advanced level).

Please note: In the second round, the problems on both tracks will also be evaluated using the IOI system with a maximum score of 100 points per problem.

Access to solving problems will be open to all users, but only those who successfully passed Round 1 can compete for prizes. Based on the results of the first stage, you may be assigned one of three statuses:

1. Choice — you scored a high mark and can officially participate in either of the two tracks in Round 2 with a chance to win a prize.
2. DSA-Basic — you passed the selection, but you can only claim prizes if you participate in the basic track.
3. DSA-Advanced — a mandatory status for participants who have ever had a rating of 1600+ and scored enough points to pass. You can only participate in the advanced track.

Based on the results of Round 2, the Top-1 among official participants in each track will receive prizes!

Prize Delivery Information

• Prizes are shipped exclusively via the Ozon delivery service and only within the Russian Federation (no shipping outside the RF).
• If you win a prize, you need to contact me personally and provide the address of the specific Ozon pickup point (PVZ) where the package should be sent.
• If there is no Ozon pickup point in your city, but you live within the RF, the delivery will be handled individually — in this case, you must also contact me to arrange it.

Important Restrictions and Fair Play Rules

• Rating restrictions: We do not recommend participating for users with a rating above 1800. Users with a rating above 1900 are not eligible for prizes.
• Anti-cheat: A strict fair play policy applies to this contest. The use of AI (ChatGPT, etc.), assistance from third parties, and plagiarism are strictly prohibited. Violators will be disqualified, and their accounts will be banned.

Acknowledgments

We express our deepest gratitude to the Sirius Educational Centre for providing the educational materials and problems! Special thanks to my friend and tester — zeyd1234.

If you have any questions regarding the rules, scoring system, or advancement criteria, feel free to ask them in the comments below, and I will surely reply!

Good luck to everyone!

Hello Codeforces! I am glad to present to you a new mashup composed of problems from various April Fools Day contests!I have selected what I consider to be the best and most solvable problems and gathered them into a single contest. I did my best to pick tasks that can either be solved straight away or require just a little bit of brute force — you won't see problems like this one which require massive brute force. Please do not look up or steal solutions from others, solve them on your own! There will be 10 problems in total and a 48-hour window to solve them. The problem indexing also features some April Fools elements, so you could say the problems are not sorted by difficulty. The contest starts on September 12 at 21:00 (UTC+3), right after Codeforces Round 1120 (Div. 1, Div. 2) finishes (well, almost right after, since the author is human too and needs a small break). Good luck and high ratings to everyone in the upcoming official round, and have fun! You can join the contest using this link: https://codeforces.me/contestInvitation/8c00638c42c658c09b39f436f3c7ca1013cadcad Or you can join the group where the contest is hosted and where similar events will be posted in the future: https://codeforces.me/group/uTeivTi6Ym Thank you for your attention, and I hope to see you in the standings!