Remember this idiot? This guy has 100+ 2200 solves and two weeks ago his max rating was 1654, now he has reached CM in four contests and his current rating is 1942! Turns out 100+ 2200s was good enough.

What do you think? How did his fake 2200 submissions get him to CM. bigSchrodinger, looking forward to your wise opinion

Look at this pathetic dude. He has 125+ 1900R solves, 100+ 2200R solves, and his highest rating is 1654! Don't be like him.

Pffft... What an idiot. I bet his actual rating is like 1400.

Hello everyone, recently I have decided that I am going to start solving 2400R problems. Now, I am a bit hesitant to start, because last time I saw, there seem to be many advanced DP concepts I haven't yet learnt about, like divide and conquer DP, Component DP and some other stuff. Since I don't look into editorials before solving problems, it's a big problem for me if I have to constantly worry about missing topics. So, what are the all advanced dynamic programming topics I need to learn before starting 2400, also any other advanced ds and algo I should look into. For 2400R specifically, higher difficulty topics are not important right now.

For offline queries, we can sort them using sqrt decomposition to minimize query traversal costs. This is very useful especially in situations where query answers can be generated using two pointers method. For this, we first divide the total query range in sqn = sqrt(n) sections. We first sort the queries in order of which section the starting point fell in, than in each section we sort the queries based on the order ending point from large to small or (small to large). I used a slightly altered implementation for this problem. Instead of using large to small or small to large endpoint at section. I sorted them in an altering structure. Therefore, if in section 1, we sort them from large to small, in section 2 we sort them from small to large, then in section 3 we again sort them from large to small. I think this implementation is quite faster on average, and in the problem I tested both the default and customized implementation. The latter proved to be almost twice as fast as the former. The implementation is as follows

struct Qry{
    lli l, r, ind;
    Qry(lli _l, lli _r, lli _ind){
        l = _l, r = _r, ind = _ind;
    }
};
 
bool cmp(Qry &a, Qry &b){
    if (a.l / sqn < b.l / sqn) return true;
    else if ((a.l / sqn == b.l / sqn)){
        if ((a.l / sqn) % 2 == 0){
            return a.r < b.r;
        }
        else {
            return a.r > b.r;
        }
    } 
    return false;
}

I want to practice solving 2200-2400 rating problems, and I want to rely on guides as less as possible. But every time I am stuck on one problem, I have to worry about whether I am missing an observation or I just need to learn a new topic to solve this problem. I want to know and learn the topics and problem solving techniques that are common in problems of this range, so that the chances of me missing a topic when trying to solve a problem is as low as possible. What are the common topics that I need to learn

I wasn't happy with the time complexity of my solution. So, I was looking for a solution with improved time complexity. And I found this. This guy solved this problem by only checking the first 200 elements after each index and comparing GCD of each pair . He won with the power of probability!

His submission: 184781213

Test Case result should be Yes. His solution prints No

C. Engineer Artem I solved this pathetic excuse of a 2000R problem yesterday. I have been trying to find the relation of this problem with FFT and CRT. The guide doesn't say anything related to CRT or FFT. Can anyone explain

These problems usually rely on keen observation and I had fun solving them. Many of these problems also taught me new things. It's mainly personal, others may find use of it too. Will keep updating this post in the future.

R2100:

• F. Ant Colony: https://codeforces.me/contest/474/problem/F

• C. Ciel the Commander: https://codeforces.me/problemset/problem/321/C

• E. Array Shrinking: https://codeforces.me/problemset/problem/1312/E

R1900:

• F. Kirei and the Linear Function: https://codeforces.me/contest/1729/problem/F

• D. Reset K Edges: https://codeforces.me/contest/1739/problem/D

• D. Paths on the Tree: https://codeforces.me/problemset/problem/1746/D

• D. Zigzags: https://codeforces.me/problemset/problem/1400/D

• B. Zuma: https://codeforces.me/problemset/problem/607/B

• D. TediousLee: https://codeforces.me/problemset/problem/1369/D

• C. Guessing the Greatest (hard version): https://codeforces.me/problemset/problem/1486/C2

• E. Replace the Numbers: https://codeforces.me/problemset/problem/1620/E

• E. String Reversal: https://codeforces.me/problemset/problem/1430/E

• D. Score of a Tree https://codeforces.me/problemset/problem/1777/D

R1800:

• D. Maximum AND: https://codeforces.me/contest/1721/problem/D

• B. Unmerge: https://codeforces.me/contest/1381/problem/B

• D. Yet Another Minimization Problem: https://codeforces.me/problemset/problem/1637/D

• A. Extreme Subtraction: https://codeforces.me/problemset/problem/1442/A

• D. Same GCDs: https://codeforces.me/problemset/problem/1295/D

• A. Book: https://codeforces.me/problemset/problem/1572/A

• D. MUH and Cube Walls: https://codeforces.me/problemset/problem/471/D

• D. Rescue Nibel!: https://codeforces.me/problemset/problem/1420/D

R1700:

• A2. Prefix Flip (Hard Version): https://codeforces.me/problemset/problem/1381/A2

• D. Valid BFS?: https://codeforces.me/problemset/problem/1037/D

• D. Ehab the Xorcist: https://codeforces.me/problemset/problem/1325/D

R1600:

• C. Carrying Conundrum: https://codeforces.me/contest/1567/problem/C

• A. Parsa's Humongous Tree: https://codeforces.me/contest/1528/problem/A

• C. Strange Function: https://codeforces.me/contest/1542/problem/C

• A. Linova and Kingdom: https://codeforces.me/problemset/problem/1336/A

• D. Constructing the Array: https://codeforces.me/problemset/problem/1353/D

• C. Carrying Conundrum: https://codeforces.me/problemset/problem/1567/C

  • The base problem is easy, try solving it assuming higher constraints (length of n, 1 < |n| <= 2*10^5, total length of all numbers doesn't exceed 2*10^5). You will need to calculate it as modulo M (i.e M = 1000000007) for such constraints as the result would be too big.

• C. Strange Test: https://codeforces.me/problemset/problem/1632/C

• C. Longest Simple Cycle: https://codeforces.me/problemset/problem/1476/C

R1500:

• Weights Assignment For Tree Edges: https://codeforces.me/contest/1611/problem/D

My solution got hacked in the past contest. While it is generally true that being hacked means your solution is wrong. But this is not the case here. My solution is not wrong. It's because of the language I am using to solve my problem I am getting TLE. The algorithms I used are alright, and I got TLEd by 210 ms only. It could have worked if I used a different language like cpp. Although I could use pypy, but note that pypy isn't nearly as fast as cpp even though faster that python. This issue needs to be worked on. Please don't say "just learn cpp". Competitive programming should be about solving problems the right way, not the right language. If cpp is not my primary language, I shouldn't need to learn it just to do competitive programming. And there's to note that, my reason to do cp is not to become a competitive programmer, but to get good at solving problems. And I am sure most people feel the same. If there is support for a language, there should also be support for TLE in that language. Unless there's a reason it can't be implemented