标签：#competativeprogramming

If you've ever lost 20 minutes at 2 AM debugging a submask enumeration loop, or drawn a segment tree on paper for the fifth time this month, this post is for you. I want to share a collection of 31 free, browser-based tools built specifically for competitive programming — no signup, no installs, code stays client-side. They're grouped at Utility Tools Lab's Competitive Programming category , and they cover almost every "I wish there was a tool for this" moment from contest practice. Here's a tour of what's inside. Visualizing structures you normally only imagine Half the pain in CP isn't the algorithm — it's seeing what your data structure is actually doing. Graph Visualizer — paste a CP-style edge list and get a force-directed graph you can drag around. Toggle directed/undirected and 0/1-indexing, then copy the adjacency list back out. Segment Tree Builder — feed in an array, pick sum/min/max/gcd, and watch the tree render, plus grab a full C++ class template. Sparse Table Builder — visualizes every level of the O(1) RMQ precomputation, with live queries. Union-Find (DSU) Visualizer — watch path compression and union-by-rank happen live on a forest view. Path Finder — paint walls on a grid and run BFS to see the shortest path animate, then copy the grid as a C++ 2D vector. Sieve Visualizer — step through the Sieve of Eratosthenes on a color-coded grid. Sorting Visualizer and Binary Search Visualizer — step-by-step animations with live comparison counts, or lo/hi/mid tracking on your own array. These aren't just "nice to look at" — watching the not-found path in binary search, or the moment a submask loop wraps around, is often exactly where off-by-one bugs hide. Code generators that skip the boilerplate Some things in CP are conceptually simple but easy to typo under time pressure. These tools generate ready-to-paste C++: Bitmask Planner — set N ≤ 12, visualize all 2^N states and submask iteration order, get a DP skeleton. PBDS Generator — Order Statistics Tree boi

After covering the foundational building blocks in Session 1, the next step is one of the most important problem-solving techniques in all of programming: recursion . And once recursion feels comfortable, it unlocks a powerful search strategy called backtracking . These two concepts appear everywhere in competitive programming — Fibonacci, binary search, tree traversal, merge sort, dynamic programming, N-Queens, and more. They deserve their own spotlight. 🌟 What Is Recursion? A function is recursive if it calls itself. Instead of solving a problem in one go, a recursive function breaks it into a smaller version of the same problem, solves that, and repeats — until the problem becomes simple enough to answer directly. Three things define every recursive solution: The problem is expressed in terms of a smaller instance of itself Each call reduces the problem size There is a point where the problem becomes trivial and no further calls are needed — this is the base case The Nested Box Analogy Think of recursion like opening nested boxes. A big box contains a smaller box, which contains another, and so on. Eventually you find the item you were looking for. That innermost box is the base case. Without it, you would keep opening boxes forever — which is how you get a stack overflow, not a solution. Base Case and Recursive Case Every recursive function has exactly two parts: Recursive case — the problem is reduced in size and the function calls itself again. Base case — the terminating condition. No further recursive call is made. The function returns a direct answer. Both are non-negotiable. A function without a base case will keep calling itself, consuming stack memory until the program crashes. Example: Factorial 5! = 5 × 4! 4! = 4 × 3! 3! = 3 × 2! 2! = 2 × 1! 1! = 1 ← base case Each step reduces the problem by one. When the function hits 1! = 1 , it stops, and the results unwind back up the call stack. In pseudocode: function factorial(n): if n == 1: return 1 # base cas

Competitive programming often looks like a race to write code as fast as possible. But the real secret is simpler: the best competitive programmers are not just faster typists — they are better at choosing the right data structure, the right algorithm, and the right complexity level for the job. Before we jump into recursion, dynamic programming, graphs, or those problems that make your brain do backflips, we need a solid base. This first session is exactly that. Let's begin. 🚀 1. Data Types: What Kind of Data Are You Storing? A data type tells a programming language what kind of value a variable holds and what operations are valid on it. Primitive Data Types The basic building blocks provided by the language itself: Integer — whole numbers: 5 , 100 , -3 Float / Double — decimal values: 3.14 , 99.5 Character — a single symbol: 'A' , 'z' Boolean — true or false User-Defined Data Types When primitive types are not enough, programmers define their own: Structs — group related fields under one name Classes — structs with behaviour (methods) attached Enums — a fixed set of named constants Typedefs / Aliases — rename existing types for clarity A Real-World Example Imagine building a food delivery app: An integer stores the number of items in the cart A float stores the total bill amount A boolean tracks whether the order has been delivered A class represents an entire Order — customer name, address, items, payment status Data types are essentially the labels on your containers. Without them, chaos begins early. 2. Data Structures: How Do You Organise Data? If data types answer what a value is, data structures answer how to organise many values efficiently. This is where competitive programming starts to get interesting. Linear Data Structures Elements arranged one after another, like people queuing at a ticket counter: Arrays — fixed-size, indexed, fast random access Linked Lists — dynamic size, efficient insertions and deletions Stacks — last in, first out (LIFO) Queues