Competitive Programming

Choose a competition language (C++ recommended), master its STL, and learn fast input/output techniques to avoid TLE on large inputs.

Learn to enumerate all possible solutions systematically. Understand when brute force is viable and how to prune the search space.

Understand the greedy paradigm: making locally optimal choices and proving they lead to globally optimal solutions via exchange arguments.

You can solve ad-hoc and implementation problems, use greedy reasoning, and handle I/O efficiently.

Analyze algorithms using Big-O notation. Learn to estimate whether a solution will pass within time and memory limits before coding it.

Understand how to analyze sequences of operations where individual steps may be expensive but the average cost is low, such as dynamic arrays and union-find.

Master linear data structures, their operations, and classic applications like matching parentheses, next-greater-element, and sliding window problems.

Use balanced BSTs and hash maps for fast lookup, counting, and coordinate compression. Understand when to choose ordered vs unordered containers.

Learn heap operations and applications: Dijkstra's algorithm, event simulation, greedy scheduling, and the k-th element pattern.

Implement DSU with path compression and union by rank. Apply it to connectivity queries, Kruskal's MST, and online graph problems.

You can choose the right data structure for a problem and implement it correctly under time pressure.

Apply binary search on sorted data and on the answer space. Recognize monotonic predicates and use binary search to optimize brute-force solutions.

Use sorting as a preprocessing step. Learn merge sort for inversion counting, custom comparators, and coordinate compression via sorting.

Solve subarray and subsequence problems in linear time by maintaining two pointers or a sliding window over sorted or sequential data.

Understand memoization vs tabulation, identify overlapping subproblems and optimal substructure, and solve classic problems like Fibonacci, knapsack, and LCS.

Master common DP patterns: interval DP, digit DP, bitmask DP, and DP on subsets. Learn to define states and transitions for each pattern.

Speed up DP using divide-and-conquer optimization, Knuth's optimization, convex hull trick, and the SMAWK algorithm for specific recurrence structures.

You can model most problems as DP, identify the right state representation, and optimize transitions when needed.

Represent graphs with adjacency lists. Implement BFS for shortest paths in unweighted graphs and DFS for cycle detection, topological sorting, and connected components.

Implement Dijkstra, Bellman-Ford, and Floyd-Warshall. Know when to use each based on graph properties (negative weights, all-pairs, sparse vs dense).

Find MSTs using Kruskal's (with DSU) and Prim's algorithms. Understand applications and properties like the cut and cycle properties.

Solve problems on trees: diameter, LCA (binary lifting), Euler tour, subtree queries, and rerooting technique for tree DP.

Implement max-flow algorithms (Ford-Fulkerson, Dinic's) and understand min-cut duality. Apply to bipartite matching and assignment problems.

You can model real problems as graphs and apply the right traversal, shortest-path, or flow algorithm.

Perform arithmetic under a modulus: fast exponentiation, modular inverse, and handling large numbers that require mod 10^9+7.

Generate primes efficiently, factorize numbers, and apply prime-related techniques like Euler's totient function and divisor enumeration.

Compute combinations, permutations, and Catalan numbers. Apply inclusion-exclusion and the pigeonhole principle to counting problems.

Analyze combinatorial games using Grundy numbers and the Sprague-Grundy theorem. Solve Nim variants and impartial games.

Use polynomial rolling hashes for fast substring comparison. Handle collision avoidance with double hashing and apply to pattern matching and palindrome detection.

Find pattern occurrences in linear time using prefix functions (KMP) or Z-arrays. Understand failure function construction and applications.

Build prefix trees for efficient string lookups, autocomplete, and XOR-maximum queries. Extend to persistent tries when needed.

Construct suffix arrays in O(n log n) and use LCP arrays for substring problems. Understand suffix automata for advanced string tasks.

Build segment trees for range queries and point/range updates. Master lazy propagation and apply to problems like range sum, min, max, and GCD.

Use BIT for prefix sum queries and point updates in O(log n). Understand its simplicity advantage over segment trees for certain problems.

Divide data into blocks of size √n for offline range queries. Apply Mo's algorithm to answer range queries without updates efficiently.

Implement point, line, and polygon operations. Solve convex hull, line intersection, and closest pair problems with robust floating-point handling.

You can handle hard competition problems requiring advanced data structures, string algorithms, and mathematical reasoning.

Develop a systematic approach: read carefully, identify problem type, consider edge cases, estimate complexity, and choose the right technique before coding.

Write brute-force solutions and random test generators to find bugs via stress testing. Learn to debug efficiently under time pressure.

You have the algorithmic toolkit and practical skills to compete effectively in Codeforces Div 2, ICPC regionals, and similar competitions.