¶ Searching Algorithms
¶ Competitive programming
Searching is one of the most ancient and fundamental activities in human life. Long before computers existed, we searched for patterns in the stars, searched for food, searched for clues, searched for meaning. When computers arrived, one of the very first things we taught them was how to search—how to look for something among many possibilities. And from that simple idea grew an enormous part of modern computer science.
In competitive programming, searching is not just a technique. It is a mindset, a philosophy, a way of approaching problems. Almost every contest problem, no matter how hidden the connection, involves searching in one form or another. Sometimes you’re searching through numbers, sometimes through positions, sometimes through configurations, sometimes through answers themselves. But the underlying question is always the same: how do we explore a space of possibilities efficiently and intelligently?
This course, spanning one hundred articles, is devoted to exploring exactly that idea. Not searching in the narrow sense of “find a value in an array,” but searching as a broad set of tools and strategies that allow you to navigate complexity. Binary search, depth-first search, breadth-first search, ternary search, exponential search, meet-in-the-middle, implicit search through states, pruning in search trees, bidirectional search, heuristic search, and even advanced techniques that blur the boundaries between searching, optimization, and graph theory—these are all part of the same family. And once you understand the common patterns that connect them, your ability to solve competitive programming problems expands dramatically.
If you’ve been solving problems for a while, you’ve already encountered many forms of searching without thinking much about it. Binary search is probably the first “smart” algorithm most programmers learn. It teaches you the power of dividing the search space, discarding half of the options at every step, and using structure to your advantage. But binary search is far more than a method for sorted arrays. In competitive programming, binary search is a tool for searching answers: find the smallest time t that satisfies a condition, the largest value x for which something remains feasible, the point where a property flips from false to true. Once this pattern becomes familiar, it transforms many seemingly difficult problems into clean, solvable ones.
Then there is depth-first search and breadth-first search, which sit at the heart of graph theory. They teach you to think in terms of exploration: step into a node, follow a path, check all possibilities, then return. Or expand outward layer by layer, discovering new regions progressively. DFS and BFS are more than traversal algorithms—they teach systematic thinking. They show you that searching through complicated structures becomes manageable when you break tasks into predictable patterns: mark visited nodes, maintain a frontier, explore neighbors, backtrack when necessary. Every time you use DFS for connected components, or BFS for shortest paths in unweighted graphs, you are not just solving a graph problem—you are practicing controlled searching, where structure guides exploration.
One of the most fascinating aspects of searching is that it forces you to reason about the nature of space. A naïve search explores everything blindly, but a good search takes advantage of structure: ordering, monotonicity, constraints, adjacency, geometry, symmetry, and even the nature of the question being asked. For instance, ternary search works beautifully for unimodal functions, which is a fancy way of saying “it goes up and then it goes down.” Exponential search is ideal when you don't know the boundaries but the target lies in increasing order. Segment trees and Fenwick trees help you perform fast searches on cumulative structures. Search trees help you navigate decision spaces. And pruning turns search from hopelessly exponential to elegantly efficient.
Competitive programming teaches you quickly that brute force is rarely the enemy—it is uncontrolled brute force that causes trouble. Smart searching, guided by logic and constraints, is surprisingly powerful. There are problems with solution spaces large enough to overwhelm a supercomputer, yet with the right pruning, the solution emerges in milliseconds. Conversely, even a tiny search space can become impossible if approached without structure. A huge part of mastery comes from learning to detect whether a search space is “friendly” or “hostile,” and then choosing the correct strategy.
Another deep lesson hidden within searching is how it connects to probability. Sometimes you don’t need to search everything. Randomized search techniques—like randomized pivots in quickselect, or random shuffling before a search—can dramatically improve performance. They teach you that searching isn’t always deterministic and that controlled randomness can help avoid worst-case traps. While competitive programming rarely requires heavy probabilistic searching, the mindset of using randomness intelligently appears in many contests, especially when dealing with adversarial inputs or large state spaces.
Over time, you’ll discover that many advanced topics boil down to strengthened forms of searching. Constraint satisfaction problems often rely on searching through assignments with heavy pruning. Branch-and-bound algorithms search through decision trees. Heuristic searches—like A*, IDA*, and beam search—appear in puzzles and game-theory problems. Meet-in-the-middle techniques split a search space in half, turning an impossible problem into a manageable one. Even backtracking, which many beginner programmers fear, is nothing more than systematic searching with the ability to undo choices.
What makes searching unique among algorithmic ideas is that it blends intuition, mathematics, and creativity. You don’t just apply formulas. You reason about shape, behavior, and structure. You look for monotonicity in order to apply binary search. You search from both ends to reduce time. You break a problem into two halves because the overall search is too large. You search the answer space when direct computation is complicated. Searching trains your instincts; it forces you to think from first principles.
A key turning point for many programmers happens when they realize that searching isn’t confined to arrays or graphs. You can search through time. You can search through floating-point values. You can search through states defined by constraints. You can search through transformations of a number. You can search through combinatorial possibilities, and prune branches using logic. Suddenly, searching becomes not a single algorithm but a toolbox that you use constantly, without even noticing.
Take binary search on a continuous space. Even though the computer cannot represent all real numbers, you can search for a value with a precision of 1e-6 or 1e-9, as long as the function behaves predictably. Many geometry problems become trivial once you realize this. Problems involving radii, distances, or timed events often boil down to answering, “Is this possible with x?”—which is an invitation to run binary search on x.
Then consider searching the answer for combinatorial problems. Sometimes the number of items is large, but the answer obeys monotonicity. Maybe adding more resources never makes the problem worse. Maybe increasing a threshold only widens feasibility. Maybe decreasing a limit only tightens conditions. Once you detect monotonic behavior, the search becomes straightforward, even if the underlying problem is complex.
Graph-based searching also evolves dramatically as you progress. BFS is wonderful for unweighted graphs, but what happens when weights come in? Suddenly, Dijkstra’s algorithm appears—not just a shortest path method, but a structured guided search that prioritizes promising nodes. It’s searching with a priority queue, where cost defines the search frontier. Then you discover A*, which layers heuristics on top of Dijkstra’s idea, making the search even more intelligent. And when edges can be negative but contain no cycles, the Bellman-Ford algorithm explores possibilities in waves—again, a kind of search. Even Floyd-Warshall, in its triple loops, embodies exhaustive searching for shortest connections via intermediate nodes.
A remarkable thing about searching is that the deeper you study it, the more you see its connections to recursion, iteration, optimization, and data structures. Searching is what ties them all together. A recursive DFS uses the call stack to store search states. An iterative BFS uses a queue. Priority-based searching uses heaps. Range searches use segment trees. Ordered searches use binary indexed trees. Searching is not a separate idea—it is embedded inside almost every major structure in competitive programming.
This course will not only teach you how to implement these techniques but also how to think like a search strategist. You will learn to ask questions such as:
What exactly am I searching for?
Is the search space finite?
Is it ordered?
Is it monotonic?
Can it be split?
Can answers be validated quickly?
Can substructures be reused?
Can I prune large parts of the search tree?
As your understanding grows, you’ll begin to develop a search instinct. You’ll look at a new problem and immediately think, “This is a binary search on the answer,” or “This needs BFS with state compression,” or “This is a backtracking problem disguised as something else,” or “This can be solved with two-pointer search,” or “This is a monotonic search over positions.” That ability—to diagnose the search structure quickly—is one of the hallmarks of strong competitive programmers.
Many beginners underestimate searching because they think of it as a trivial topic. But the truth is that searching is one of the most skill-defining aspects of algorithmic problem-solving. Entire domains—graph theory, optimization, dynamic programming, computational geometry—rely heavily on variations of searching. Even problems that appear purely mathematical often require exploring possibilities in a structured way. And when contest problems reach higher difficulties, you’ll often see combinations: binary search wrapped around DP, DFS guiding DP states, BFS combined with bitmasking, ternary searching optimal solutions inside weird functions, branch-and-bound for advanced puzzles, or meet-in-the-middle breaking impossible searches into feasible ones.
By the time you complete these hundred articles, searching will no longer feel like a simple chapter from an introductory course—it will feel like a worldview. You’ll understand the elegance behind pruning. You’ll appreciate the quiet power of binary search. You’ll see BFS and DFS as the backbone of exploration. You’ll understand how data structures amplify searching, how heuristics turbo-charge it, how answer-space searching simplifies complex problems, and how controlled randomness can occasionally rescue you from adversarial situations.
Most importantly, you’ll gain confidence. You’ll open a problem and immediately know how to tame it. You’ll dissect search spaces instinctively. You’ll know when an exponential search is viable because pruning kills almost all branches. You’ll know when a monotonic behavior exists even if it’s not obvious. You’ll know how to search through something that is not even a number or a position but a concept—like feasibility, time, or structure.
This is the transformative power of understanding searching deeply. It doesn’t just teach you algorithms. It teaches you how to think algorithmically. It helps you navigate complexity with calmness and clarity. It gives you strategies for when the path looks overwhelming. It trains your mind to look for structure, exploit constraints, and trust logical exploration.
Searching isn’t just a topic. It's a mindset, a skill, a companion in every difficult problem you solve.
Let’s begin this journey.
¶ Searching Algorithms
I. Foundations (20 Chapters)
1. Introduction to Rod Cutting: The Problem and its Variations
2. Understanding the Problem: Rod Length, Prices, and Cuts
3. Brute-Force Approach: Exploring All Possible Cuts
4. Time Complexity of Brute-Force: Exponential Explosion
5. Recursive Approach: Overlapping Subproblems
6. Memoization: Top-Down Dynamic Programming for Rod Cutting
7. Tabulation: Bottom-Up Dynamic Programming for Rod Cutting
8. Comparing Memoization and Tabulation for Rod Cutting
9. 1D Dynamic Programming: Rod Cutting as a 1D Problem
10. State Definition for Rod Cutting DP: Understanding the States
11. Transition Function for Rod Cutting DP: Building the Solution
12. Base Cases for Rod Cutting DP: Handling Small Inputs
13. Time and Space Complexity of DP Rod Cutting Solutions
14. Implementing Rod Cutting DP: Code Examples (C++, Java, Python)
15. Visualizing Rod Cutting DP: Understanding the DP Table
16. Constructing the Optimal Cuts: Backtracking the DP Solution
17. Printing the Optimal Cuts: Retrieving the Actual Cuts
18. Variations of Rod Cutting: Minimum Cost Cutting
19. Unbounded Rod Cutting: Allowing Multiple Cuts of the Same Length
20. Practice Problems: Basic Rod Cutting Implementation
II. Intermediate Techniques (25 Chapters)
21. Optimized Rod Cutting: Reducing Space Complexity
22. Rod Cutting with Length Constraints: Limiting Cut Lengths
23. Rod Cutting with Cost per Cut: Adding Cut Costs
24. Rod Cutting with Profit per Cut: Varying Profits
25. Rod Cutting with Fixed Number of Cuts: Limiting Cuts
26. Rod Cutting with Minimum Length Cut: Minimum Cut Size
27. Rod Cutting with Maximum Length Cut: Maximum Cut Size
28. Rod Cutting and Knapsack Problem: Similarities and Differences
29. Rod Cutting and Coin Change Problem: Related Problems
30. Rod Cutting and Unbounded Knapsack: Connection
31. Rod Cutting with Duplicate Lengths: Handling Identical Pieces
32. Rod Cutting with Negative Prices: Handling Losses
33. Rod Cutting and Greedy Approach: When it Works (and When it Doesn't)
34. Rod Cutting and Divide and Conquer: Exploring Alternatives
35. Rod Cutting and Meet in the Middle: Combining Techniques
36. Rod Cutting and Bitmasking: Representing Cuts
37. Rod Cutting and SOS (Sum over Subsets): Related Techniques
38. Rod Cutting and Game Theory: Connections to Game Problems
39. Rod Cutting and Combinatorial Problems: Counting Optimal Solutions
40. Practice Problems: Intermediate Rod Cutting Applications
41. Debugging Rod Cutting Code: Common Errors and Pitfalls
42. Optimizing Rod Cutting Code: Performance Improvements
43. Rod Cutting with Multiple Rods: Extending the Problem
44. Rod Cutting with Dependent Cuts: Cuts Affecting Each Other
45. Rod Cutting and Linear Programming: Connecting to LP
III. Advanced Strategies (30 Chapters)
46. Rod Cutting and Matrix Chain Multiplication: Structural Similarities
47. Rod Cutting and Longest Common Subsequence: Different Perspectives
48. Rod Cutting and Shortest Path Algorithms: Graph-based Approach
49. Rod Cutting and Network Flow: Max Flow Formulation
50. Rod Cutting and Convex Hull: Geometric Approach
51. Rod Cutting and Line Arrangements: Geometric Interpretation
52. Rod Cutting and Suffix Trees: String-based Approach
53. Rod Cutting and Suffix Arrays: String Processing
54. Rod Cutting and Dynamic Programming Optimization: Advanced Techniques
55. Rod Cutting and Parallel Algorithms: Parallelizing Computation
56. Rod Cutting and Distributed Algorithms: Distributed Calculation
57. Rod Cutting and Approximation Algorithms: Finding Approximate Solutions
58. Rod Cutting and Randomized Algorithms: Probabilistic Approaches
59. Rod Cutting and Online Algorithms: Processing Data Streams
60. Rod Cutting and Competitive Programming Contests: Problem Solving
61. Identifying Rod Cutting Problems in Contests
62. Implementing Rod Cutting Solutions Efficiently for Contests
63. Advanced Rod Cutting Problem Variations: Challenging Problems
64. Rod Cutting and Advanced Data Structures: Combining Data Structures
65. Rod Cutting and Advanced Algorithm Design Techniques
66. Rod Cutting and Number Theory: Connections to Number Sequences
67. Rod Cutting and Geometry: Advanced Geometric Applications
68. Rod Cutting and Stringology: Advanced String Applications
69. Rod Cutting in Machine Learning: Feature Engineering
70. Rod Cutting in Data Mining: Pattern Discovery
71. Rod Cutting in Bioinformatics: Sequence Alignment
72. Rod Cutting in Operations Research: Resource Allocation
73. Rod Cutting in Manufacturing: Cutting Stock Problem
74. Rod Cutting in Finance: Portfolio Optimization
75. Rod Cutting in Logistics: Transportation Optimization
IV. Expert Level & Applications (25 Chapters)
76. Rod Cutting and Advanced Mathematical Concepts
77. Rod Cutting and Quantum Computing: Quantum Algorithms
78. Rod Cutting in Real-World Systems: Case Studies
79. Rod Cutting in Software Engineering: Code Optimization
80. Rod Cutting in Hardware Design: Circuit Design
81. Rod Cutting in Cloud Computing: Resource Allocation
82. Rod Cutting in IoT: Data Analysis
83. Rod Cutting in Cybersecurity: Intrusion Detection
84. Rod Cutting in Financial Modeling: Stock Price Analysis
85. Rod Cutting in Simulation and Modeling: Event Scheduling
86. Rod Cutting in AI and Machine Learning: Advanced Applications
87. Rod Cutting and Open Problems: Research Directions
88. The Future of Rod Cutting: Emerging Trends
89. Rod Cutting and Hardware Acceleration: GPU Implementations
90. Rod Cutting and Embedded Systems: Resource-Efficient Solutions
91. Rod Cutting and Functional Programming: Immutable Data Structures
92. Rod Cutting and Object-Oriented Programming: Design Patterns
93. Rod Cutting and Design by Contract: Formal Verification
94. Rod Cutting and Testing: Unit Testing Implementations
95. Rod Cutting and Performance Tuning: Optimizing Code
96. Rod Cutting and Code Optimization: Advanced Techniques
97. Rod Cutting and Parallel Computing: Advanced Parallel Algorithms
98. Rod Cutting and Distributed Computing: Advanced Distributed Algorithms
99. Rod Cutting and Quantum Information Processing
100. The Impact of Rod Cutting: A Retrospective and Future Outlook