I have to say that the most important thing to notice is to participate when the server is not heavily in queue. The problems are not bad but the queue (at least for 2023 when I was a participant and 2021 from what I heard) was unbearable.

I agree. evenvalue orz.

I hope NeroZein doesn't clown like he did in TST day 2

Did he?

CM, xD.

It is because of different timezones.

So that, everybody is at ease and nobody has to stress out to follow the chosen timeslot.
Otherwise, multiple people would have time zones and other scheduling problems.
Also, Read the rules, it says: Every participant is expected to show good sportsmanship by following the rules.

ideograph_advantage

I think we should wait until the contest is over before discussing problems publicly.

First, we can make $$$4$$$ arrays $$$gr, gl, sr, sl$$$ which stores for index $$$i$$$, what's the nearest greater value to the right, to left and smaller value to left and to right. This can be done using stack in $$$O(n)$$$. Now, let's consider the edges (there is an edge between $$$(i, j)$$$ if we can go from $$$i$$$ to $$$j$$$ in $$$1$$$ move i.e all elements in between are between $$$a_i$$$, $$$a_j$$$). Important thing to notice is that, we will take the edge which brings us closest to $$$r$$$ (considering the query $$$(l, r)$$$). Also, another observation is that it is easily determinable that whether $$$a_i$$$ is a min-point or max-point. We can just check that whether $$$a_{i + 1}$$$ is less or greater than $$$a_i$$$ and then we can't have $$$a_i$$$ as min if $$$a_{i + 1}$$$ is less than it (similar for other case).

Assume that $$$a_i \lt a_{i + 1}$$$ since other case is similar. Now, $$$a_i$$$ is min and we want the max points. Note that the edges from $$$i$$$ are going to the changes in the max as we go towards right from $$$i$$$. Now, where will the last edge be? It will be to the maximum in the valid range. What is a valid range? the range will be valid such that the min point $$$i$$$ does not change. So, beyond $$$sr_i$$$ (the first index to the right of $$$i$$$ which have smaller value than $$$a_i$$$)we don't have any edge outgoing from $$$i$$$. So, we just get the max in the range $$$[i, sr_i)$$$. Now, we have $$$O(n)$$$ edges added in $$$O(n \space lg(n))$$$.

We can also do binary lifting and store where do I land when I take $$$2^x$$$ edges.

Now, when the query comes, we just go to the rightmost point we can from $$$l$$$ which is $$$\leq r$$$. What to do after that? We can now just do the same things we did for going in the right direction, for the left direction. Now, we starting going left from $$$r$$$ (using binary lifting). And we want the minimum jumps needed to get $$$r \leq l$$$. Now, we add both of the steps and we are done.

Proofs of the observations are not hard, I believe that you should try them.

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

const int N = 3e5 + 10, LG = 19;
int n, sr[N], gr[N], sl[N], gl[N], pos[N];
int jump_right[N][LG], jump_left[N][LG], MAX[N][LG], MIN[N][LG];

vector<int> a;

int get_max(int l, int r){
    int lg = 31 - __builtin_clz(r - l);
    return max(MAX[l][lg], MAX[r - (1 << lg)][lg]);
}

int get_min(int l, int r){
    int lg = 31 - __builtin_clz(r - l);
    return min(MIN[l][lg], MIN[r - (1 << lg)][lg]);
}

void init_permutation(int N, vector<int> A){
    n = N, a = A;
    for (int i = 0; i < n; i ++)
        pos[a[i]] = i;

    stack<int> st;
    for (int i = 0; i < n; i ++){
        sl[i] = i;
        while (st.size() and a[st.top()] > a[i])
            st.pop();

        if (st.size())
            sl[i] = st.top();
        st.push(i);
    }

    while (st.size()) st.pop();

    for (int i = 0; i < n; i ++){
        gl[i] = i;
        while (st.size() and a[st.top()] < a[i])
            st.pop();

        if (st.size())
            gl[i] = st.top();
        st.push(i);
    }

    while (st.size()) st.pop();

    for (int i = n - 1; i >= 0; i --){
        sr[i] = i;
        while (st.size() and a[st.top()] > a[i])
            st.pop();

        if (st.size())
            sr[i] = st.top();
        st.push(i);
    }

    while (st.size()) st.pop();

    for (int i = n - 1; i >= 0; i --){
        gr[i] = i;
        while (st.size() and a[st.top()] < a[i])
            st.pop();

        if (st.size())
            gr[i] = st.top();
        st.push(i);
    }

    while (st.size()) st.pop();

    for (int i = n - 1; i >= 0; i --){
        MIN[i][0] = MAX[i][0] = a[i];
        for (int step = 1; step < LG && i + (1 << step) <= n; step ++){
            MIN[i][step] = min(MIN[i][step - 1], MIN[i + (1 << (step - 1))][step - 1]);
            MAX[i][step] = max(MAX[i][step - 1], MAX[i + (1 << (step - 1))][step - 1]);
        }
    }

    for (int i = n - 2; i >= 0; i --){
        if (a[i + 1] < a[i]){
            if (gr[i] != i)
                jump_right[i][0] = pos[get_min(i, gr[i])];
            else
                jump_right[i][0] = pos[get_min(i, n)];
        }
        else{
            if (sr[i] != i)
                jump_right[i][0] = pos[get_max(i, sr[i])];
            else
                jump_right[i][0] = pos[get_max(i, n)];
        }

        for (int j = 1; j < LG; j ++)
            jump_right[i][j] = jump_right[jump_right[i][j - 1]][j - 1];
    }


    for (int i = 1; i < n; i ++){
        if (a[i - 1] < a[i]){
            if (gl[i] != i)
                jump_left[i][0] = pos[get_min(gl[i], i + 1)];
            else
                jump_left[i][0] = pos[get_min(0, i + 1)];
        }
        else{
            if (sl[i] != i)
                jump_left[i][0] = pos[get_max(sl[i], i + 1)];
            else
                jump_left[i][0] = pos[get_max(0, i + 1)];
        }


        for (int j = 1; j < LG; j ++)
            jump_left[i][j] = jump_left[jump_left[i][j - 1]][j - 1];
    }
}

int calc_f(int l, int r){
    int ope = 0;
    for (int i = LG - 1; i >= 0; i --){
        if (jump_right[l][i] <= r and jump_right[l][i] > l){
            l = jump_right[l][i];
            ope += (1 << i);
        }
    }

    for (int i = LG - 1; i >= 0; i --){
        if (jump_left[r][i] > l and jump_left[r][i] < r){
            r = jump_left[r][i];
            ope += (1 << i);
        }
    }

    return ope + (l < r);
}

I tried my best to divide the solution into reasonable parts, hopefully it'd be helpful.

P.S: It appears that there are some similarities between my sol and the sol above, which wasn't there when I started writing the comment.

+25 submission limit

Sadly no :(

Although from Monday onwards it can be discussed, so wait for Monday :))))

Yes, there are countries participating now

After 2-3 days of analysis mode. (info source being register@apio2024.org)

But this year the problems were easy, especially problem A

Wow, how dare you get full points on problem C :)

If a person from each country replied with the scores of their official participants there would be less trolling

Since people are apparently too childish, please reply to the comment with your scores and I will add you manually. Thanks.

UZB top 6

Sunnatov — 100 + 40 + 5 = 145
Husanboy — 100 + 10 + 5 = 115
heaven2808h — 100 + 10 + 5 = 115
MardonbekHazratov — 100 + 10 + 5 = 115
Alfa — 100 + 5 + 5 = 110
rshohruh — 100 + 5 + 5 = 110
0gur4ik = 100 + 5 + 5 = 110

Korea

At least 2 300s and at least 1 235

This is in meme territory.

💀

China's that one country where the first rank page is just filled with red users who are prob younger than 16....

I heard 59... did you not count the CHN IOI team?

On the flip side, CHN IOI team member ranks outside top 300? :manual-doge

I wonder how they will decide the official participants. There must be 6 from each country, right?

I think all of the countries finished taking the APIO can you tell me the full solution for C 100 points?

I agree. In my country the competition was only about 15 points because of easy problem A and hard BC. Maybe we have skill issue, but it's still bad to be able to get A in the first 20 minutes and struggle to get anything else the rest of the contest