Master Competitive Programming
Competitive Programming (CP) is a problem-solving discipline that combines logic, mathematics, and programming to tackle challenging algorithmic problems under time constraints. In this course, you will learn how to think critically, design efficient algorithms, and write optimized code to solve real-world computational problems. We will cover fundamental concepts such as data structures, algorithms, recursion, dynamic programming, graph theory, and more. Along the way, you’ll practice with problems inspired by platforms like coding contests and technical interviews. Whether you are a beginner or looking to sharpen your skills, this course will help you build strong analytical thinking, improve coding speed and accuracy, and prepare you for competitions, internships, and top tech interviews.
Starting from
- Key Highlights
- Structured Learning Path – Beginner to advanced roadmap.
- Live + Recorded Classes – Learn anytime, revise anytime.
- Top Platform Practice – Codeforces, LeetCode, AtCoder problems.
- Weekly Contests – Track progress & improve ranking.
- Interview Focus – Crack MAANG & top tech roles.
- 1:1 Mentorship – Fast doubt solving & guidance.
Syllabus
- Basic Math
GCD (Euclid Algorithm): Efficient way to find the greatest common divisor of two numbers. LCM: Smallest number divisible by given numbers; often computed using GCD. Modular Arithmetic: Performing operations under modulo (important to avoid overflow). Binary Exponentiation: Fast computation of of a^b in O(log n).
- Prime and Factorization
Sieve of Eratosthenes: Precompute all primes up to N efficiently. Segmented Sieve: Find primes in a large range. Prime Factorization: Breaking numbers into prime factors (used in many problems).
- Advanced Number Theory
Euler Totient Function: Counts numbers coprime with n. Fermat’s Little Theorem: Used for modular inverse when modulus is prime. Chinese Remainder Theorem: Solve multiple modular equations. Extended Euclid: Find modular inverses and solve linear equations.
- Combinatorics
nCr(Combinations): Number of ways to choose r items from n. Pascal’s Triangle: Precompute combinations. Inclusion-Exclusion: Count by subtracting overlaps.
- Arrays
Prefix Sum: Precompute sums to answer range queries fast. Difference Array: Efficient range updates. Kadane’s Algorithm: Maximum subarray sum in O(n). Subarray Problems: Core CP pattern (sum, count, max/min).
- Strings
Basic Operations: Traversal, comparison, substring. Palindrome Checking: Symmetry-based logic. String Hashing: Convert string to numbers for fast comparison. Rabin-Karp: Pattern matching using hashing.
- Searching
Binary Search: Efficient search in sorted arrays. Binary Search on Answer: Guess the answer and verify.
- Sorting
Built-in Sort: Optimized sorting (usually O(n log n)). Custom Comparator: Sort based on custom rules. Stability: Whether equal elements preserve order.
- Two Pointers : Traverse array with two indices.
- Sliding Window : Maintain a valid subarray dynamically.
Fixed Sliding Window Variable Sliding Window
- Recursion: Solve problems by breaking into subproblems.
- Subsets/Permutations: Generate all possibilities.
- Backtracking: Try all options and undo (used in constraints problems).
- Basic STL :
Vector: Dynamic array. Set/Multiset: Sorted unique/multiple elements. Map: Key-value storage. Stack/Queue: LIFO/FIFO structures. Priority_queue: Heap (max/min element access).
- Advanced DS :
Fenwick Tree (BIT): Fast prefix sum updates/queries. Segment Tree: Handle range queries and updates. Lazy Propagation: Optimize range updates in segment trees.
- Basics
Graph Representation: Adjacency list/matrix. BFS: Level-wise traversal (shortest path in unweighted graph). DFS: Deep traversal (used for components, cycles).
- Core Problems
Connected Components: Count separate parts of graph. Cycle Detection: Detect loops in graph.
- DAG
Topological Sort: Order tasks with dependencies. Kahn's Algorithm
- Shortest Path
Dijkstra: Shortest path with positive weights. Bellman-Ford: Works with negative weights. Floyd-Warshall: All-pairs shortest path.
- Advanced Graph
MST (Kruskal/Prim): Minimum cost to connect all nodes. DSU: Efficient union-find structure. Bridges & Articulation Points: Critical edges/nodes. SCC: Strongly connected components.
- Traversals: Visit nodes in different orders.
- BST: Ordered binary tree. .
- LCA: Find lowest common ancestor.
- Binary Lifting: Fast ancestor queries.
- Tree Diameter: Longest path in tree.
- Tree DP: DP applied on trees
- Make locally optimal choices.
- Used in:
Interval scheduling Activity selection Sorting-based optimization
- Basics:
Break problems into overlapping subproblems.
- Types:
1D DP: Linear problems. 2D DP: Grid/string problems. Knapsack: Resource allocation problems. LIS: Increasing subsequence. LCS: Common subsequence between strings.
- Advanced DP
DP on Trees Bitmask DP Digit DP
- Work With Binary Representation
- Tricks:
Check/set bits XOR properties Subset generation
- KMP: Efficient pattern matching.
- Z Algorithm: Pattern matching variant.
- Trie: Prefix tree.
- Suffix Array: Advanced string structure.
- Mo’s Algorithm: Offline query optimization.
- Heavy-Light Decomposition: Tree queries.
- Sparse Table: Range queries (static).
- Meet in the Middle: Split problem into halves.
- Flow Algorithms: Network flow problems.
- Prefix + Hashing
- Binary search on answer
- Greedy + sorting
- Graph + DP
- Simulation