01 — Introduction
What is competitive programming?
Competitive programming (CP) is a mind sport where participants solve well-defined algorithmic problems within strict time and memory limits. Think of it as a chess tournament, but instead of moving pieces, you write code — under the clock, against hundreds of other programmers worldwide.
It sharpens your ability to think algorithmically, break down complex problems, and write clean, fast code. Top companies like Google, Meta, and Codeforces-sponsored firms actively seek out high-rated competitive programmers. Beyond jobs, it's simply an intensely satisfying intellectual pursuit.
💡You don't need to be a genius to start. You need curiosity, patience, and a willingness to be stuck — and then un-stuck — repeatedly.
02 — Language
Choose your language
C++ is the de facto standard in competitive programming, primarily because of its speed and the incredibly rich STL (Standard Template Library). Python is beginner-friendly but can be too slow for problems with tight time limits. Java sits in the middle — fast enough, but more verbose.
C++
Fastest. Richest STL. Industry standard for CP.
Python
Easy to learn. Slower. Great for prototyping logic.
Java
Strong for big integers, balanced speed.
If you're starting fresh, learn C++. If you already know Python, that's fine — just be aware of TLE (Time Limit Exceeded) issues and use PyPy where available.
// Classic C++ CP template
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// your solution here
return 0;
}
03 — Roadmap
The beginner roadmap
Progress in CP is non-linear, but there's a logical order to learning. Start narrow and deep, then expand outward. Don't try to learn everything at once — build one layer at a time.
Phase 01
Language fundamentals
Arrays, loops, functions, I/O, basic STL (vector, map, set)
Phase 02
Basic algorithms
Sorting, searching, brute force, complexity analysis (Big-O)
Phase 03
Data structures
Stacks, queues, heaps, segment trees, union-find
Phase 04
Core techniques
DP, graphs (BFS/DFS/Dijkstra), greedy, binary search on answer
Phase 05
Advanced topics
Flows, strings (KMP, Trie), geometry, number theory
Spend at least 2–4 weeks at each phase before moving on. Rushing leads to shaky foundations that collapse under harder problems.
04 — Core topics
Core topics to master
These are the building blocks that appear again and again across thousands of problems. Think of each tag as a tool in your toolkit — the more tools you have, and the sharper they are, the faster you can solve new problems.
Dynamic ProgrammingGraph TheoryBinary SearchGreedy AlgorithmsSorting & SearchingNumber TheorySegment TreesUnion-Find (DSU)Shortest PathsBit ManipulationTwo PointersPrefix SumsString AlgorithmsRecursion & BacktrackingMath & CombinatoricsGame Theory
Dynamic Programming (DP) is often the hardest and most important. Dedicate serious time to it — start with classic DP problems like Fibonacci, Knapsack, Longest Common Subsequence, and Coin Change before tackling DP on trees or bitmask DP.
05 — Platforms
Where to practice
Different platforms have different strengths. Use multiple, but focus on one as your primary home — consistency beats spreading yourself thin.
Codeforces
Best for regular contests & rating system. Essential.
LeetCode
Great for interviews & structured problem sets.
AtCoder
High-quality problems. Excellent for DP & math.
CSES
Best structured problem set for beginners. Free.
HackerRank
Good for topic-by-topic structured practice.
SPOJ
Classic archive of 20,000+ problems. Timeless.
Start with the CSES Problem Set — it's free, well-organized, and covers every major topic from easiest to hardest. Then move to Codeforces for live contests.
06 — Strategy
Contest strategy
Solving problems in a live contest is different from solving them at home. The clock is psychological. Here's how elite competitors approach a contest round:
01
Read all problems first
Skim every problem quickly (1–2 min each) before diving in. Find the easiest one first — don't get stuck on problem A while problem B is trivial.
02
Code fast, not perfect
In a contest, a working solution beats a beautiful one. Write clean-enough code quickly. Optimize later if needed.
03
Test with edge cases before submitting
Before hitting submit, mentally test with n=0, n=1, max n, negatives, and sorted/reversed inputs. Wrong answers cost you penalty time.
04
Don't get trapped on one problem
If you're stuck for more than 20–30 minutes, move on. Returning with fresh eyes often reveals the insight instantly.
05
Upsolve after every contest
This is the most important habit. After a contest ends, solve every problem you couldn't solve during it. This is where the real learning happens.
07 — Habits
Habits of top competitive programmers
Skill in CP is built slowly and compounded over months. The programmers who reach Grandmaster on Codeforces or win ICPC medals aren't necessarily smarter — they're more consistent and deliberate in how they practice.
📌Solve problems slightly above your level. Easy problems build confidence but don't grow your skill. Hard problems you can't solve teach you nothing directly. The sweet spot is problems that take you 30 minutes to 2 hours — difficult enough to stretch you, solvable enough to close the loop.
Keep a problem diary — a simple notes file where you log every interesting problem you solved, the key insight, and what topic it belongs to. After 6 months, this becomes an invaluable personal reference.
Participate in rated contests regularly, even if you feel unprepared. Rating pressure simulates real performance and reveals your weak spots faster than casual practice ever can. Aim for at least 2 contests per week.
Study editorial solutions — even for problems you solved. Often you solved it with a slow O(n²) approach and the editorial shows an elegant O(n log n) solution. That gap is where mastery lives.
"The only way to improve at competitive programming is to do competitive programming — and to think deeply about why each solution works."