Hello, Codeforces!

We start a new season of the Coding Club! This year, things will be different from the last one. Every week, livlivi and I will post a short lecture and a themed contest. Then you will have one week to solve it. If you have any troubles, we will have several teaching assistants, who will help you personally.

The plan for this season is to cover these topics (not sure if we will have enough time, but we will try):

• Core techniques (prefix sums, binary search)
• Dynamic programming
• Graph algorithms (DFS, BFS, MST, shortest paths)
• Data structures (stacks, queues, DSU, segment trees)
• Tree algorithms (DP on tees, LCA)
• String algorithms (tries, KMP, hashing, Aho–Corasick)

The club is starting this week! If you are interested, register here. See you!

The best summer school is back! This time in a new country and with a brand new track!

We’re happy to invite you to the upcoming ACTS in Germany 2026.2, the best summer camp full of learning, problem-solving, and fun.

• Date & location: July 10-20, 2026 at Constructor University, Bremen, Germany
• Participants: High school students aged 16-19
• Organizers: Constructor University Bremen, Neapolis University Pafos, with support from the JetBrains Foundation.
• Tracks: Competitive Programming & Software Engineering
• Costs: Accommodation, meals, and the academic program are fully covered by the organizers. Participants' only costs are travel and a camp fee of 100 EUR.
• Entrance Contest: April 26, 8:00-11:00 UTC.

Competitive Programming track. For students who love algorithms and contests

• Teachers: Top coaches, including me (pashka), meshanya, and KAN.
• What to expect? You’ll have lectures and practice for both core and advanced topics, train for olympiads up to IOI level, with a great team contest in the end.

Software Engineering track. For students who love building projects and winning hackathons

• Teachers: JetBrains experts: the best software engineers creating the best developer tools.
• What to expect? You’ll build a team project from scratch learning necessary tools along the way, and present your final result at the end of the camp.

If this sounds like your kind of summer — apply, spread the word, and come spend 11 amazing days with us!

Register here by April 25

Hello Codeforces!

Very soon, on November 2, we will have the JetBrains Academy Youth Challenge. Registration deadline is October 28, so go register now!

The Youth Challenge will be also an entrance exam to our Algorithm and Code Training School (ACTS). This winter we will have two schools.

First, ACTS in Romania 2026.1. Our top-tier camp for top-tier students. Last year ACTS participants won 29 IOI medals! We cover accommodation, meals and academic program. Note that we only invite students aged 16 to 19 years.

Second, ACTS Online 2026. This is online intensive, covering fundamental topics. Great to train for national olympiads and other contests. Here we invite students aged 13 to 19 years.

See you there!

Hello, Codeforces!

The most popular question I get asked here is: "How can I get better in competitive programming?". And I usually answer that you just need to solve more problems: the more problems you solve, the better you get at it.

But solving problem alone is boring, so last year we started JetBrains Youth Coding Club.

During the last year, I prepared 25 contests, which we discussed in live classes every week. If you missed it, here are all the contests, and here is a playlist with all discussions.

This year I plan to do basically the same thing, maybe adding more contest on specific topics, but mostly solving random problems, learning to read statements, recognize familiar patterns and build solutions out of it.

The club will start in October. If you are interested, register here. See you!

P.S. We also have Math Club and AI Club!

Hello Codeforces!

If you are a high school student and want to prepare for IOI and other olympiads, we are happy to invite you to ACTS 2025, our summer training camp in Romania.

We will bring best teachers, including me (pashka), meshanya, cdkrot, niyaznigmatul, and others.

• Location: Romania.
• Dates: June 27 – July 7, 2025.
• Participants: High school students between the ages of 16 and 20.
• What to expect: 11 days of intensive training, contests, and fun. 
• Organizers: High Edu, Constructor University, and Neapolis University Pafos, with support from the JetBrains Foundation.
• Costs: The organizers will cover accommodation and meals. The only thing you have to pay for is the travel costs and the camp fee of 100 EUR.

Here's how to take part:

• Fill out the application by April 27.
• Solve many problems in the entrance contest on May 4.
• Get your invitation and come to camp!

Hope to see you there!

Hello Codeforces!

Two great announcements from our team for high school students.

First, very soon, on November 24, we will have the JetBrains Academy Youth Challenge. We will prepare some cool problems, come and participate!

Second, this winter we will have the Algorithm and Code Training School, the great place to master your skills for IOI and other olympiads. Top students from the Youth Challenge will be invited to the ACTS.

See you there!

The first contest of JetBrains Youth Coding Club has started.

If you want to join, register here.

See you!

Hello, Codeforces!

We start a new educational project: JetBrains Youth Coding Club.

In this club I will focus not on algorithms, but on real contest problem solving.

The plan is simple:

• Every week I will prepare a mashup contest from old Codeforces problems.
• You can solve it as a virtual contest at any time during the week.
• In the end of the week we will discuss the solutions and approaches.

I think I will mostly focus on div. 3 problems, but maybe will extend it to div. 2 (or even div. 1, who knows).

The first contest will start next week. If you are interested, register here. See you!

P.S. We also start Math Club and AI Club!

Hello! On Feb/18/2024 15:05 (Moscow time) will start Codeforces Round 927 (Div. 3), the next Codeforces round for the third division.

The round is based on problems from JetBrains Academy Youth Challenge. If you participated in it, please don't participate in this round.

Problems for this round are prepared by denk, step_by_step, goncharovmike, ikrpprppp, pashka, Vladosiya and MikeMirzayanov.

Thank you very much awoo, BledDest, buyolitsez, EgorUlin, Gojova, GrandFruit, Hello_zoka, petyb, scanhex, ibraevdmitriy, shnirelman, SomethingNew, Toy_mouse, Zandler for testing the round.

As usual for the third division rounds:

• there will be 6-8 tasks in a round
• round duration is 2 hours 15 minutes
• the round follows the ICPC rules, penalty for an incorrect submission is 10 minutes
• round is rated for participants with ratings up to 1600
• after the round there will be a 12-hour open hacking phase

Remember that only the trusted participants of the third division will be included in the official standings table. As it is written by link, this is a compulsory measure for combating unsporting behaviour. To qualify as a trusted participant of the third division, you must:

• take part in at least five rated rounds (and solve at least one problem in each of them)
• do not have a point of 1900 or higher in the rating.

Regardless of whether you are a trusted participant of the third division or not, if your rating is less than 1600, then the round will be rated for you.

Good luck to all!

UPD: Editorial

1921A - Square

Idea: goncharovmike, prepared: pashka

t = int(input())
for _ in range(t):
    a = [[int(x) for x in input().split()] for i in range(4)]
    x = [p[0] for p in a]
    dx = max(x) - min(x)
    print(dx * dx)

1921B - Arranging Cats

Idea: pashka, prepared: ikrpprppp

t = int(input())

for _ in range(t):
    n = int(input())
    start = [int(x) for x in input()]
    finish = [int(x) for x in input()]
    pairs = list(zip(start, finish))
    add_amnt = sum(int(a < b) for a, b in pairs)
    rmv_amnt = sum(int(a > b) for a, b in pairs)
    print(max(add_amnt, rmv_amnt))

1921C - Sending Messages

Idea: step_by_step, prepared: step_by_step, Vladosiya

t = int(input())
for _ in range(t):
    n, f, a, b = map(int, input().split())
    m = [0] + [int(x) for x in input().split()]
    for i in range(1, n + 1):
        f -= min(a * (m[i] - m[i - 1]), b)
    print('YES' if f > 0 else 'NO')

1921D - Very Different Array

Idea: Vitaly239239, prepared: pashka

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

struct test {
   void solve() {
        int n, m;
        cin >> n >> m;
        vector<int> a(n);
        for (int i = 0; i < n; i++) cin >> a[i];
        vector<int> b(m);
        for (int i = 0; i < m; i++) cin >> b[i];
        sort(a.begin(), a.end());
        sort(b.rbegin(), b.rend());
        vector<int> c(n);
        long long s = 0;
        for (int i = 0; i < n; i++) {
            c[i] = b[m &mdash; n + i];
            s += abs(c[i] &mdash; a[i]);
        }
        long long res = 0;
        for (int k = 0; k <= n; k++) {
            res = max(res, s);
            if (k < n) {
                s -= abs(c[k] &mdash; a[k]);
                c[k] = b[k];
                s += abs(c[k] &mdash; a[k]);
            }
        }
        cout << res << "\n";
    }
};

int main() {
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        test().solve();
    }
    return 0;
}

1921E - Eat the Chip

Idea: ikrpprppp, prepared: ikrpprppp

def solve():
    h, w, xA, yA, xB, yB = map(int, input().split())

    if (xA - xB) % 2 == 0:
        winner = "Bob"
        if xA >= xB:
            win = False
        elif yA == yB:
            win = True
        else:
            if yA < yB:
                n_turns = yB - 1
            else:
                n_turns = w - yB
            win = xB - 2 * n_turns >= xA

    else:
        winner = "Alice"

        xA += 1
        yA += 0 if yB - yA == 0 else 1 if yB - yA > 0 else -1

        if xA > xB:
            win = False
        elif yA == yB:
            win = True
        else:
            if yA < yB:
                n_turns = w - yA
            else:
                n_turns = yA - 1
            win = xB - 2 * n_turns >= xA

    print(winner if win else "Draw")


t = int(input())

for _ in range(t):
    solve()

1921F - Sum of Progression

Idea: Vitaly239239, prepared: Vitaly239239

#include <bits/stdc++.h>

using namespace std;

long long precalc[322][200322];
long long precalci[322][200322];

void solve() {
    int n, q;
    cin >> n >> q;
    vector<long long> a(n);
    int pivot = 1;
    while (pivot * pivot < n) {
        pivot++;
    }
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    for (int i = 0; i < pivot; i++) {
        for (int j = 0; j <= i; j++) {
            precalc[i][j] = 0LL;
            precalci[i][j] = 0LL;
        }
        for (int j = 0; j < n; j++) {
            precalci[i][j + i + 1] = precalci[i][j] + a[j] * (j / (i + 1) + 1);
            precalc[i][j + i + 1] = precalc[i][j] + a[j];
        }
    }
    while (q--) {
        int s, d;
        long long k;
        long long ans = 0;
        cin >> s >> d >> k;
        s--;
        if (d > pivot) {
            for (int i = s; i <= s + (k - 1) * d; i += d) {
                ans += a[i] * ((i - s) / d + 1);
            }
            cout << ans << " ";
            continue;
        }
        long long last = s + d * k - d;
        int first = s;
        cout << precalci[d - 1][last + d] - precalci[d - 1][first] -
                (precalc[d - 1][last + d] - precalc[d - 1][first]) * (first / d) << ' ';
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int tests;
    cin >> tests;
    while (tests--) {
        solve();
        if (tests) cout << "\n";
    }
    return 0;
}

1921G - Mischievous Shooter

Idea: Vitaly239239, prepared: goncharovmike

//ciao_chill
#include<bits/stdc++.h>
using namespace std;
#define int long long

int n, m, k;
vector<vector<int>> a;


bool prov(int i, int j) {
    return 0 <= i && i < n && 0 <= j && j < m;
}

int ans() {
    int cnt = 0;
    int dp[n][m];
    int pref[n][m];
    int pref_up[n][m];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            pref_up[i][j] = a[i][j];
            if (prov(i - 1, j))
                pref_up[i][j] += pref_up[i - 1][j];
        }
    }

    for (int i = 0; i < n; i++) {
        for (int j = m - 1; j >= 0; j--) {
            pref[i][j] = a[i][j];
            if (prov(i - 1, j + 1))
                pref[i][j] += pref[i - 1][j + 1];
        }
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            dp[i][j] = pref_up[i][j];
            if (prov(i - k, j))
                dp[i][j] -= pref_up[i - k][j];
            if (prov(i, j - 1))
                dp[i][j] += dp[i][j - 1];
            if (j < k) {
                int i1 = j - k + i;
                if (i1 >= 0)
                    dp[i][j] -= pref[i1][0];
            }
            else
                dp[i][j] -= pref[i][j - k];
            if (prov(i - k, j))
                dp[i][j] += pref[i - k][j];
            cnt = max(cnt, dp[i][j]);
        }
    }

    return cnt;
}

void solve() {
    cin >> n >> m >> k;
    k++;
    char c;
    bool st[n][m];
    a.resize(n);
    for (int i = 0; i < n; i++) {
        a[i].resize(m);
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++)
        {
            cin >> c;
            st[i][j] = (c == '#');
            a[i][j] = st[i][j];
        }
    }

    int mx = ans();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            a[i][j] = st[n - i - 1][j];
        }
    }
    mx = max(mx, ans());
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            a[i][j] = st[i][m - j - 1];
        }
    }
    mx = max(mx, ans());
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            a[i][j] = st[n - i - 1][m - j - 1];
        }
    }
    mx = max(mx, ans());

    cout << mx << '\n';

}

signed main() {
    cin.tie(nullptr);
    cout.tie(nullptr);
    ios_base::sync_with_stdio(false);

    int tt;
    cin >> tt;
    while (tt--)
        solve();

    return 0;
}

Hello! On Jan/15/2024 17:35 (Moscow time) will start Codeforces Round 920 (Div. 3), the next Codeforces round for the third division.

The round was coordinated by Vladosiya, and prepared by me and the students of Neapolis University Pafos: Vitaly239239, goncharovmike, ikrpprppp, step_by_step.

Thank you very much Alexdat2000, dan_dolmatov, fastmath, FBI, Nickir, nikhil97agra, pavlekn, PMiguelez, JuicyGrape, ibraevdmitriy, Sergey140146659, Sparrow_Guo, Toy_mouse, vladmart for testing the round.

As usual for the third division rounds:

• there will be 6-8 tasks in a round
• round duration is 2 hours 15 minutes
• the round follows the ICPC rules, penalty for an incorrect submission is 10 minutes
• round is rated for participants with ratings up to 1600
• after the round there will be a 12-hour open hacking phase

Remember that only the trusted participants of the third division will be included in the official standings table. As it is written by link, this is a compulsory measure for combating unsporting behaviour. To qualify as a trusted participant of the third division, you must:

• take part in at least five rated rounds (and solve at least one problem in each of them)
• do not have a point of 1900 or higher in the rating.

Regardless of whether you are a trusted participant of the third division or not, if your rating is less than 1600, then the round will be rated for you.

Good luck to all!

UPD: Editorial

Here are the home tasks for the lecture, you can submit your solutions into this form.

Hello Codeforces!

The final semester starts this week! As usual, the live lectures will be on Twitch on Fridays at 18:00 MSK, and the recorded videos will be on Youtube.

Topics of the fourth semester:

• Matchings
  • Bipartite Matching
  • Non-bipartite Matching (blossoms)
  • Assignment Problem
• Network Flows
  • Maximal Flow
  • Minimal Cost Flow
  • Skew-Symmetric Flows
• Linear Programming
• Fast Fourier Transformation
• Plus something more :)

See you!

The last lecture will be tomorrow at 14:00 MSK

• Lecture 13. Suffix Tree
• Lecture 14. Y-Fast Trie

Better late than never...

• Lecture 9. Strings. Hashing. KMP. Z Algorithm
• Lecture 10. Finite State Automata
• Lecture 11. Aho Corasick Algorithm
• Lecture 12. Suffix Array

Here are the home tasks, you can submit your solutions into this form.

Here are the home tasks for the lecture, you can submit your solutions into this form.

Here are the home tasks for the lecture, you can submit your solutions into this form.

Here are the home tasks for the lecture, you can submit your solutions into this form.

Here is the video of the lecture. Thanks to everyone who watched the live stream.

Here are the home tasks for the lecture, you can submit your solutions into this form.

Here is the video of the lecture. Thanks to everyone who watched the live stream.

This week the lecture will be on Wednesday at 6pm MSK

Hello Codeforces!

The third semester starts this week! As usual, the live lectures will be on Twitch on Fridays at 18:00 MSK, and the recorded videos will be on Youtube.

Topics of the third semester:

• Graph Algorithms
  • DFS and its applications
  • MST
  • Shortest Paths
  • Games on Graphs
• String Algorithms
  • Substring Search
  • Suffix Trees
• Plus something more :)

See you!

Here is the video of the lecture. Thanks to everyone who watched the live stream.

Here are the home tasks for the lecture, you can submit your solutions into this form.