# RunTimeFix

> RunTimeFix is a practical programming education platform focused on competitive programming, data structures & algorithms (DSA), C++, and software engineering. We provide free books, practice problems, topic guides, and premium courses.

## Documentation and Guides

- [Home](https://runtimefix.vercel.app//)
- [Free Book: Master Competitive Programming with C++](https://runtimefix.vercel.app//book)
- [Practice Problems](https://runtimefix.vercel.app//practice)
- [Topics Hub](https://runtimefix.vercel.app//topics)
- [YouTube Channel](https://runtimefix.vercel.app//youtube)
- [Blog](https://runtimefix.vercel.app//blog)
- [Courses](https://runtimefix.vercel.app//courses)

## Practice Categories

- [Implementation & Ad-Hoc](https://runtimefix.vercel.app//practice/implementation) - Straight-forward coding, simulations, and careful reading of problem statements.
- [Mathematics & Number Theory](https://runtimefix.vercel.app//practice/math-number-theory) - Divisibility, primes, GCD/LCM, modular arithmetic, sieve techniques, and Euler's totient.
- [Sorting & Searching](https://runtimefix.vercel.app//practice/sorting-searching) - Sorting-based reasoning, binary search on arrays, and binary search on the answer.
- [Prefix Sums & Difference Arrays](https://runtimefix.vercel.app//practice/prefix-sums) - Range sum queries, range updates, 2D prefix sums, and XOR prefix.
- [Two Pointers & Sliding Window](https://runtimefix.vercel.app//practice/two-pointers) - Linear-time scanning with two converging or co-moving pointers.
- [Greedy Algorithms](https://runtimefix.vercel.app//practice/greedy) - Make locally optimal choices that lead to a globally optimal solution.
- [Bit Manipulation](https://runtimefix.vercel.app//practice/bit-manipulation) - XOR tricks, bitmask enumeration, bitwise operations, and subset iteration.
- [Combinatorics & Counting](https://runtimefix.vercel.app//practice/combinatorics) - Counting, permutations, combinations, inclusion-exclusion, and constructive algorithms.
- [Recursion & Backtracking](https://runtimefix.vercel.app//practice/recursion-backtracking) - Generate solutions by exploring all possibilities, prune when invalid.
- [String Algorithms](https://runtimefix.vercel.app//practice/string-algorithms) - Hashing, KMP, Z-function, tries, suffix structures, and string matching.
- [Stacks, Queues & Deques](https://runtimefix.vercel.app//practice/stacks-queues) - Monotonic stacks, monotonic deques, bracket matching, and expression parsing.
- [Disjoint Set Union (DSU)](https://runtimefix.vercel.app//practice/dsu) - Union-Find: track connected components with union by rank + path compression.
- [Dynamic Programming — Fundamentals](https://runtimefix.vercel.app//practice/dp-fundamentals) - Core DP patterns: linear, 2D grid, knapsack, LIS, and LCS.
- [Dynamic Programming — Advanced](https://runtimefix.vercel.app//practice/dp-advanced) - Bitmask DP, digit DP, interval DP, tree DP, probability DP, and DP optimizations.
- [Segment Trees & Fenwick Trees](https://runtimefix.vercel.app//practice/segment-fenwick) - Point update + range query, lazy propagation, and BIT variants.
- [Sparse Table, Sqrt Decomposition & More](https://runtimefix.vercel.app//practice/advanced-ds) - Sparse table for static RMQ, sqrt decomposition, and Mo's algorithm.
- [Trees](https://runtimefix.vercel.app//practice/trees) - Rooted trees, tree DFS, subtree queries, LCA, diameter, Euler tour, and heavy-light decomposition.
- [Graph Traversal](https://runtimefix.vercel.app//practice/graph-traversal) - BFS, DFS, connected components, multi-source BFS, 0-1 BFS, and bipartite checking.
- [Graph Algorithms](https://runtimefix.vercel.app//practice/graph-algorithms) - Cycle detection, topological sort, bridges, articulation points, and strongly connected components.
- [Shortest Paths](https://runtimefix.vercel.app//practice/shortest-paths) - Dijkstra, Bellman-Ford, Floyd-Warshall — weighted shortest path algorithms.
- [Minimum Spanning Tree](https://runtimefix.vercel.app//practice/mst) - Kruskal's and Prim's algorithms for minimum spanning trees.
- [Network Flow & Matching](https://runtimefix.vercel.app//practice/flow-matching) - Max flow / min cut, bipartite matching, and min cost max flow.
- [Game Theory](https://runtimefix.vercel.app//practice/game-theory) - Nim, Sprague-Grundy theorem, minimax, and game-state analysis.
- [Computational Geometry](https://runtimefix.vercel.app//practice/geometry) - Convex hull, line sweep, point-in-polygon, and geometric primitives.
- [Matrix Exponentiation & FFT](https://runtimefix.vercel.app//practice/matrix-fft) - Matrix power for linear recurrences and FFT/NTT for polynomial multiplication.

## Topics

- [Competitive Programming](https://runtimefix.vercel.app//topics/competitive-programming) - Master contest strategy, problem-solving patterns, and the techniques that win rated competitions on Codeforces, LeetCode, and ICPC.
- [Dynamic Programming](https://runtimefix.vercel.app//topics/dynamic-programming) - Learn dynamic programming from foundations to advanced techniques: state design, transitions, knapsack, bitmask DP, and optimization.
- [Graphs & Graph Algorithms](https://runtimefix.vercel.app//topics/graphs) - Graph representation, DFS, BFS, Dijkstra's algorithm, MST, topological sort, cycle detection, and tree algorithms explained with C++ code.
- [Data Structures](https://runtimefix.vercel.app//topics/data-structures) - Arrays, vectors, sets, maps, stacks, queues, priority queues, Fenwick trees, segment trees, and DSU — when to use each and why.
- [Algorithms](https://runtimefix.vercel.app//topics/algorithms) - Sorting, searching, binary search, two pointers, sliding window, prefix sums, greedy, and divide-and-conquer algorithms with complexity analysis.
- [C++ for Competitive Programming](https://runtimefix.vercel.app//topics/cpp) - Modern C++ fundamentals: I/O, STL containers, iterators, lambdas, structured bindings, and the features that make C++ the language of competitive programming.
- [Binary Search](https://runtimefix.vercel.app//topics/binary-search) - Binary search on sorted arrays and answer spaces — the technique that turns O(n) into O(log n). Boundary handling, STL functions, and practice problems.
- [Greedy Algorithms](https://runtimefix.vercel.app//topics/greedy-algorithms) - The greedy paradigm: when local optima lead to global optima. Sorting-based greedy, interval scheduling, exchange arguments, and constructive problems.
- [Number Theory & Modular Arithmetic](https://runtimefix.vercel.app//topics/number-theory) - Divisibility, GCD, LCM, primes, sieve of Eratosthenes, modular arithmetic, binary exponentiation, and combinatorics for programming contests.
- [Bit Manipulation](https://runtimefix.vercel.app//topics/bit-manipulation) - Bitwise operators, XOR properties, bitmask enumeration, and subset iteration — the low-level tricks that unlock elegant solutions.
- [Two Pointers & Sliding Window](https://runtimefix.vercel.app//topics/two-pointers) - Two pointers (opposite and same direction) and sliding window (fixed and variable size) — the O(n) patterns that replace brute force.
- [Segment Tree & Fenwick Tree](https://runtimefix.vercel.app//topics/segment-tree) - Range query data structures: Fenwick tree (BIT) for prefix operations, segment tree for arbitrary range queries and updates in O(log n).
- [String Algorithms & Hashing](https://runtimefix.vercel.app//topics/string-algorithms) - Polynomial rolling hashing, trie (prefix tree), string matching, and character operations for competitive programming.
- [Tree Algorithms](https://runtimefix.vercel.app//topics/trees) - Rooted trees, DFS on trees, subtree size, tree diameter, binary lifting, LCA, and Euler tour — the tree techniques that appear in every contest.
- [Complexity Analysis](https://runtimefix.vercel.app//topics/complexity-analysis) - Time and space complexity: Big-O notation, amortized analysis, and the skill of reading constraints to choose the right algorithm.
- [Recursion & Backtracking](https://runtimefix.vercel.app//topics/recursion) - Recursive thinking, the call stack, backtracking templates, pruning, and meet-in-the-middle — from basics to advanced enumeration.
- [Sorting & Frequency Arrays](https://runtimefix.vercel.app//topics/sorting) - std::sort, custom comparators, lower_bound, upper_bound, next_permutation, and frequency counting techniques.
- [Prefix Sums & Difference Arrays](https://runtimefix.vercel.app//topics/prefix-sums) - 1D and 2D prefix sums, suffix aggregates, and difference arrays — the O(1) range query techniques every programmer should know.

## Learn More

For a full breakdown of every chapter, practice subtopic, and concept, see our full LLM context at [https://runtimefix.vercel.app//llms-full.txt](https://runtimefix.vercel.app//llms-full.txt).