Foreword — Why This Fight Club Exists

The narrative below is distilled from the original Coding Interview Fight Club notes — the raw training document this book grew out of. The problems changed (they got cleaner, cross-checked, and expanded), but the spirit is untouched.

This document is a survival guide and a training regimen. It is a compendium of high-frequency algorithmic problems, distilled from thousands of successful — and unsuccessful — interview cycles at top-tier tech companies. The modern tech interview is less about finding a competent coder and more about passing a highly standardized, artificial test. The stakes are real: the difference between landing a top-tier role and not is often measured in hundreds of thousands of dollars. Treat the gap with the gravity it deserves — TC or GTFO.

Three beliefs underpin everything in this book:

1. Computer science has no syllabus. Everything we do in a computer is an algorithm operating on data structures, and most of those structures are already implemented by smart engineers and shipped in libraries. LeetCode is just a platform. What the interview tests is whether you can recognize the structure inside a novel problem — and that is a trainable skill, not a birthright.

2. Time is your most valuable asset. Instead of aimlessly grinding problems or reading dense textbooks, focus on the most critical, pattern-based knowledge that delivers the highest ROI. This book is organized by pattern, not by company or by difficulty — because the pattern is what you’ll meet again, in a costume you’ve never seen.

3. Pattern recognition wins within the first two minutes. The drills in these chapters are designed so that when you see a novel problem, the solution shape clicks before your interviewer finishes reading it. That two-minute edge is what separates a candidate who knows the answer from one who can lead the technical discussion.

The long shadows of small bugs

The most elementary-looking algorithms hide the deepest traps. Binary search is the canonical example: Donald Knuth observed its details are “surprisingly tricky,” and Jon Bentley’s studies found that 90% of professional programmers failed to write a bug-free version after hours of trying. The most embarrassing proof was a bug in Java’s own library implementation — (low + high) / 2 overflowing on huge arrays — that persisted in production for over twenty years before being fixed in 2006. When you practice the “off-by-one or off-by-life” chapters of this book, you’re training against a bug that shipped to billions of machines. The discipline is worth it.

The one idea that makes DP click

Dynamic Programming is not rocket science; it is organized recursion. Most people crash because they skip the intuition and jump straight to memorizing bottom-up table-filling. The right order is the brutal one: write the raw, exponential recursion; watch the same subproblems appear again and again — “ah, shit, here we go again” — and then the breakthrough: start taking credit for the work you’ve already done. Cache the results, prove the optimal substructure, and what was exponential becomes polynomial. That is the entire game. Interviewers will barely punish you for intuitive recursive code — unless they’re assholes.

On authority

This guide’s edge cases were tested against a real interviewer’s lens: 46 coding interviews conducted, 13 debriefs attended, hiring managers second-guessed on their system design choices, and more than one recruiter forced to book extra interviews after a hard look at the notes. The problems here are the ones that actually appear. The stories are the ones that actually happened.

What this book adds

The original notes were a treasure map. This book is the expedition: every algorithm rewritten in five languages, every dry run hand-traced until the arithmetic is right, every claim checked against the source repository. The narrative you’ll find in these pages — the “take all the gut punches,” the “Range Query Warlords” energy of the appendix, the insistence that structure beats grind — is the fight club spirit, preserved.

Welcome to the fight club. The first rule is you do talk about it — every line of it, out loud, while you trace the dry run.

Credits: the narrative in this foreword is adapted from the original Coding Interview Fight Club notes; the solutions, traces, and five-language implementations are this book’s own work.

The Multi-Lingual Disciplinary Constitution

(Merged: Standards + Anti-Patterns + Clean Code + SOLID + Cost Gaslighting)

If you’re impatient, skip this page. Life will humble you down.

Philosophy: This is not a suggestion. It is a formal invariant system. Every language has its footguns; this document maps the minefield. LLMs are statistical parrots—this is their cage. Violations are not “style differences”; they are treason against mechanical sympathy and basic human readability.

SECTION 0: THE UNIVERSAL TRINITY (Memory, Types, Control Flow)

0.1 Memory & Performance (All Languages)

• Contiguity over Pointers: Vec<T> (Rust), Array/List (Kotlin/Java), T[] (TS) over linked lists unless perf proves otherwise.
• Lazy Evaluation: Use Sequence (Kotlin), Iterator (Rust/JS), itertools (Python) for lazy pipelines. Do not materialize intermediate collections in memory.
• Branch Prediction: Hot paths must put the 90% case first in if/else. Annotate with likely/unlikely in C/Rust.

0.2 Type Safety & Null Handling

• Null is a War Crime: Kotlin: NEVER use !! (force-unwrap). Use ?., ?:, let, and run. Rust: Option<T> and ? operator. TS: strict null checks + Either/Option via fp-ts. Python: Optional with mypy strict.
• Parsing: Use nom (Rust), Arrow/Kotlinx.serialization, Zod (TS), Pydantic (Python). Regex alone is banned for untrusted input.

0.3 The “No Nested For-Loops” Commandment

If you have a nested loop (O(n²) or worse), you are already wrong unless you have a mathematical proof that n < 100. Replace with:

• Kotlin: list.flatMap { ... }.groupBy { ... }.map { ... }
• Rust: iter().flat_map().fold(HashMap::new(), ...)
• TS: arr.flatMap().reduce()
• Python: itertools.chain.from_iterable()

SECTION 1: THE MECHANICS OF CLEAN NAMING & FUNCTION PURITY (Pre-SOLID)

Before you touch SOLID, master this: Code is read 10x more than written.

1.1 The Naming Haiku

• Booleans: Always start with is, has, can, should. (e.g., isActive, hasPermission). Never flag or status.
• Functions: Must be verbNoun() (e.g., calculateTotal(), fetchUser()). If it returns a boolean, use is/has/can.
• Variables: Nouns. Full words. usr is a sin. user is divine. Abbreviations are only allowed if they are domain-standard (e.g., ID, UUID, HTTP).
• Magic Numbers: If it’s not 0, 1, or -1, it gets a const with a screaming snake case name (e.g., MAX_RETRY_ATTEMPTS = 3).

1.2 The 20-Line Rule (The Function Ceiling)

A function must fit entirely on a single screen without scrolling vertically. If it exceeds 20 lines (excluding braces and whitespace), it is too long. Refactor it. How? Extract inner blocks into well-named private extension functions or local lambdas. If you cannot name the extracted block, your original function was doing too many things.

1.3 Expression-Oriented Programming (Kill the Dangling Return)

Prefer expression bodies over statement blocks. Return implicitly.

• Kotlin (Good): fun double(x: Int): Int = x * 2
• Rust (Good): fn double(x: i32) -> i32 { x * 2 } (no semicolon = implicit return)
• TS (Good): const double = (x: number): number => x * 2
• Python (Good): def double(x): return x * 2 (Python has no expression bodies, but keep it one line).

If you have 4 different return statements scattered inside an if jungle, you are doing it wrong. Use when (Kotlin), match (Rust/TS/Python) as an expression that returns a single value.

SECTION 2: CLEAN, IDIOMATIC READABILITY & SOLID PRINCIPLES (MULTI-LINGUAL)

SOLID is not an abstract OOP buzzword. It is a survival guide against unmaintainable spaghetti. Here is how you enforce it practically across paradigms.

2.1 S - Single Responsibility (One Reason to Change)

A class, module, or function must have exactly one reason to exist.

• Kotlin/Java: Do not create a UserManager that handles DB, sends emails, and caches. Split into UserRepository, EmailNotifier, UserCache.
• Rust: Do not bloat a single impl block. Split logic into different traits (UserFetcher, Notifier) and implement them separately.
• TS/Python: If your class has more than 5 public methods, it’s probably doing too much. Split into smaller composable classes or pure functions in separate modules.
• The LLM Trap: When an AI gives you a giant function, force it: “Refactor this into 3 pure functions, each with a single responsibility.”

2.2 O - Open/Closed (Open for Extension, Closed for Modification)

You should be able to add new behavior without touching existing, working code.

• Kotlin/Java: Use sealed classes / interfaces. Instead of a giant when chain that breaks every time you add a type, define a method on the interface and call it polymorphically.
  • BAD: when (type) { is Dog -> bark(); is Cat -> meow() } (Modifies every time you add an animal).
  • GOOD: animal.speak() (Define speak() on the Animal interface. New animals just implement it).
• Rust: Use trait and enum with trait objects (dyn Trait) or enums with non-exhaustive patterns only at the boundary. Prefer adding new impl blocks over modifying existing match arms.
• TS: Use discriminated unions (type Shape = Circle | Square) but handle the default exhaustively. Or use interfaces and dependency injection.

2.3 L - Liskov Substitution (Subtypes Must Be Substitutable)

If you have a Bird class and a Penguin subclass, Penguin MUST be able to be used anywhere Bird is used without breaking behavior. If Bird has a fly() method, Penguin should NOT override it to throw UnsupportedOperationException. Fix: Instead of inheritance, use composition. Or split the interface into FlyingBird and NonFlyingBird.

• Kotlin/Rust/TS: Favor interface / trait segregation over class inheritance. Composition over inheritance is the golden bullet.

2.4 I - Interface Segregation (Don’t Force Dependencies)

Do not force a class to implement a method it doesn’t need.

• BAD: An Employee interface with calculateSalary(), generateReport(), and login(). Your Intern class now has to fake generateReport().
• GOOD: Split into Payable, Reportable, Authenticatable. Let the class implement only what it needs.
• Rust/TS: Create small, focused traits/interfaces. A type can implement multiple. This makes testing trivial (you just mock the tiny interface).

2.5 D - Dependency Inversion (Depend on Abstractions, Not Concretions)

High-level modules should not depend on low-level modules. Both should depend on abstractions.

• BAD: class OrderService { private val db = MySQLDatabase() } (Hardcoded dependency. You cannot unit test without a real DB).
• GOOD: class OrderService(private val db: Database) where Database is an interface/trait.
• Multi-lingual: In Kotlin/Rust/TS, pass the dependency via constructor (DI) or as a function parameter. In functional programming, pass the “effect” (the database function) as an argument to the pure function.
• The Corollary: Do not use object (Kotlin) or static (Java/TS) for external services. Singletons are global state in disguise and violate DI.

2.6 Clean Code: Tell, Don’t Ask

Do not query an object’s internal state to make a decision for it. Tell the object to do the work itself.

• BAD: if (user.getRole() == "ADMIN") { user.deletePost(post) }
• GOOD: user.deletePost(post) (The User object knows its own role and checks internally).

SECTION 3: ASYNC & STRUCTURED CONCURRENCY (MULTI-LINGUAL)

3.1 The Golden Rule of Async

Never mix blocking and non-blocking code at the same stack frame. If you call a suspend function (Kotlin), async (Rust/JS), or await (Python), the entire call chain up to the boundary must be colored accordingly.

Kotlin (Coroutines)

• Use runBlocking only in main() or test fixtures. NEVER in a server endpoint.
• Use withContext(Dispatchers.IO) for blocking I/O, Dispatchers.Default for CPU.
• Structured Concurrency: Use coroutineScope { ... } to enforce that all child coroutines complete before the parent returns. If you use GlobalScope, you are fired.
• Lazy Flow: Use flow { ... }.map { ... }.filter { ... } – it’s lazy and backpressured. DO NOT use toList() on an infinite flow.

// GOOD: Structured, lazy, functional.
suspend fun fetchAndProcess(ids: List<Int>) = withContext(Dispatchers.IO) {
    ids.asFlow() // Lazy
        .map { id -> fetchUser(id) } // Suspending call
        .filter { it.isActive }
        .map { it.name }
        .toList() // Materializes only at the very end
}

// BAD: GlobalScope leak and blocking on dispatcher.
GlobalScope.launch {
    runBlocking { fetchUser(1) } // Nested runBlocking = deadlock risk.
}

Rust (Tokio)

• Use tokio::spawn with an explicit JoinHandle. Never block_on inside an async function.
• Prefer tokio::select! over manual polling. Timeout every I/O call: tokio::time::timeout(Duration::from_secs(3), fut).await.
• Lazy Iterators: Use .iter().map().collect::<Vec<_>>() for bounded, or .par_iter() (Rayon) for parallel CPU.

TypeScript (Node.js)

• Never use async void functions unless you .catch() immediately. Unhandled rejections crash the process.
• Use Promise.allSettled over Promise.all if partial failures are acceptable.
• Lazy Generators: Use function* or async function* to stream data instead of buffering entire arrays.

Python (Asyncio)

• Use asyncio.gather(*tasks, return_exceptions=True) for fan-out.
• Never use time.sleep() – use asyncio.sleep().
• Lazy: Use generator expressions (x for x in range(10)) over list comprehensions [...] for large datasets.

SECTION 4: THE NEGATIVE H₂S HALL OF SHAME (MULTI-LINGUAL)

Antipattern 1: Kotlin’s !! (The Null-Pointer Resurrector)

// DO NOT DO THIS. EVER.
val user = findUser(id)!! // Throws NPE if null. You just killed the whole point of Kotlin.
user.email!!.length // Double criminal offense.

Fix: findUser(id)?.email?.length ?: 0 or requireNotNull(user) { "User $id missing" } with a meaningful message.

Antipattern 2: The Blocking Coroutine (Async Antipattern)

// DO NOT DO THIS. EVER.
suspend fun getData(): String {
    return runBlocking { // runBlocking inside suspend = thread pinning and deadlock risk.
        httpClient.get("...")
    }
}

Fix: Just suspend all the way down. Use withContext to shift dispatchers, never block.

Antipattern 3: The N+1 Query in Disguise (Functional but Naive)

// BAD: Despite using map, it's still N+1 because you call suspend inside a non-suspend lambda.
val users = userRepo.getAll() // List of 1000
val orders = users.map { user -> orderRepo.findByUserId(user.id) } // 1000 sequential DB calls.

Fix: Use coroutineScope { users.map { async { orderRepo.findByUserId(it.id) } }.awaitAll() } for parallel, or use a single SQL IN query.

Antipattern 4: The God Object ORM (Eager Loading Hell) - All Languages

// BAD: Lazy loading proxies in a web view.
foreach (var post in blogPosts) {
    foreach (var comment in post.Comments) { // Triggers a SELECT per post.
        // ...
    }
}

Fix: Explicit .Include(x => x.Comments) (C#), @EntityGraph (Java), prisma.include({ comments: true }) (TS) – fail at compile-time if the data fetcher is missing.

Antipattern 5: Mutable Shared State in Functional Pipelines

# BAD: Accumulating state in a global inside a map.
counter = 0
def process(x):
    global counter
    counter += x # Mutates global state. Thread-unsafe. Violates functional purity.
    return x * 2
list(map(process, data))

Fix: fold / reduce for accumulation, or itertools.accumulate.

SECTION 5: THE ASIAN DAD GASLIGHTING (COST / PERFORMANCE / WATTAGE)

The Milk Carton Prologue: In the 90s, I optimized 8086 assembly by manually counting clock cycles because we couldn’t afford an ICE (In-Circuit Emulator). We wrote code on paper, under candlelight, in a monsoon. You have a 700W H100 generating 5,000 lines of Kotlin coroutines in 2 seconds. If it fails, you press “Regenerate”. You are privileged.

The Formal Cost Matrix (Stop Guessing):

The Gaslight: Llama is 10x cheaper per token, but requires 9 iterations vs Claude’s 2. Total energy consumed: 300W * 8.9 = 2,670W vs 700W * 2.1 = 1,470W. Claude is 45% more power-efficient for production-ready code. The “cheap” model costs you more in electricity, cloud overages (bad code needs more instances), and engineering review time.

The Dad Speech: You want to save $0.03 on inference? Go ahead. Use the cheap model. It will produce nested for loops and !! null-forcers. Your Kotlin microservice will OOM at 3AM because the functional pipeline materialized a 10-million-element list. Your CTO will get the AWS bill. You will explain to the board that you saved $3 on API calls but cost $4,000 in extra compute.

Calculate this: TCG (Total Cost of Generation) = (Wattage * I2S * Time) + (EngineerSalary * Review_Hours). Always optimize for lowest TCG, not lowest token price. Now buy Claude credits and stop crying. Or go back to the milk cartons.

SECTION 6: THE VERIFICATION CHECKLIST (FOR PRs & LLM OUTPUT)

Before you say “LGTM” or “Commit”, formally verify these 6 properties. If the LLM generated it, force it to answer these in a comment block:

1. Complexity Proof: “What is the worst-case time complexity? Prove it is not O(n²) due to hidden nested iteration.”
2. Null-Safety Proof: “Trace the path of every nullable type. Show that !! or forced unwrap is absent.”
3. Async Liveness: “If this coroutine/task panics, does the parent know? Is there a timeout on every I/O step?”
4. Lazy Termination: “If this uses a Sequence/Iterator/Generator, where is the terminal operator (.toList(), .collect())? Is the stream bounded?”
5. SOLID Compliance: “Point to where the Dependency Inversion is. Where is the abstraction?”
6. Mechanical Sympathy: “How many cache misses does this hot loop cause? How many heap allocations per second?”

The Dunning-Kruger Escape Hatch: If you cannot answer one of these, you do not understand the code. Do not approve it. Ask the LLM to rewrite it until you can draw the memory layout and the SOLID class diagram on a whiteboard. Formal verification and clean architecture do not care about your seniority, your feelings, or your sprint points.

SECTION 7: THE MULTI-LINGUAL CHEATSHEET (QUICK REFERENCE)

Final Commandment: This single file is your pact with the machine. Every time you open a new LLM chat, paste this as the System Prompt. When the AI outputs code, ask it: “Check your output against Sections 1, 2, 3, and 4. Cite the line numbers where you violate them.”

If it cannot self-correct, close the chat and start over. Waste tokens, not your future sanity. Now go, and may your pipelines be lazy, your interfaces segregated, your coroutines structured, and your nulls forever absent.

Coding Interview Fight Club

Everything we do in the computer is an algorithm, and every algorithm leans on data structures. Mostly, these data structures are already implemented by smart open-source developers working at big tech companies — but the reasoning that picks the right one, and the proof that it runs fast enough, is yours alone. This book trains exactly that.

This is a from-scratch, multi-language guide to the 660+ algorithm solutions living in this repository (src/main/kotlin/). It is not a list of answers. It is a training camp: for every problem you will find

• a precise problem statement and worked examples,
• the intuition — why a pattern works, not just that it works,
• multiple approaches — from the brutal brute force to the elegant optimum,
• the same solution in five languages (Kotlin, Java, C++, Python, Rust), every method annotated with @param / @return so you can read the contract at a glance,
• a hand-traced dry run (tables, stack traces, recursion trees) so you can watch the algorithm execute,
• time and space complexity backed by real math — summations, recurrences, and the master theorem — not hand-waved “O(n log n) trust me”.

Why another interview book?

Because most books teach you solutions; interviews punish candidates who can only reproduce them. The difference between a pass and a fail is usually not knowing the trick — it is being able to derive the trick under pressure and argue about its cost without pausing. Every section here is written to be derivable: the intuition comes first, the code is a consequence of the intuition, and the complexity analysis is a proof you could deliver out loud in an interview room.

How the repository maps to this book

Every chapter page names its source files, so you can jump from the book to the code and back.

Conventions used throughout the book

• Math is rendered with MathJax: $O(\log n)$ renders inline, $$...$$ renders centered.
• Code tabs: adjacent code blocks are grouped into Kotlin / Java / C++ / Python / Rust tabs automatically. Click to switch; hover a block for a Copy button.
• Dry runs appear in monospace panels (.dryrun) so multi-column traces line up perfectly.
• Source links: every page carries an edit on GitHub link in the toolbar — typos and improvements are one click away.

Turn the page and start the fight.

How To Read This Book

This book is built for repetition with intent. You will not absorb it by reading once, and you will not absorb it by skipping the dry runs. Here is the recommended loop.

The 20-minute problem loop

For every problem, follow this order — it mirrors exactly what you should do in a real interview:

1. Read the problem statement and the examples. Cover the solution. Try to write down:
   • the input domain (can it be empty? negative? huge?),
   • a brute force you could hand-wave in 2 minutes,
   • the runtime you think is required (usually visible from the constraints: $n \le 10^5$ almost always means $O(n)$ or $O(n \log n)$).
2. Read the Intuition section. This is the heart of the page. If you close the book and cannot re-derive the core idea in your own words, re-read it.
3. Read Approach 1 (brute force). Understand why it is too slow — express the slowness as a formula, e.g. “checking all $n^2$ pairs”.
4. Read the optimal approach, then trace the dry run with your finger. Do not skip this. The dry run is where the algorithm stops being magic and becomes a machine.
5. Read the 5-language code in the language you are least comfortable with. The @param/@return comments are the API contract; the body is the implementation.
6. Read the complexity proof. Every complexity claim in this book is derived, not asserted.
7. Re-implement from memory in your editor. If you cannot, repeat steps 2–6.

The dry-run convention

Dry runs are shown in monospace panels like this:

left=0  right=7  mid=3  arr[3]=4  arr[7]=9
  arr[3] < arr[7]  ->  right = 2        (keep searching left half)
...
return 4   (arr[left] is the minimum)

Each line shows the state before an action and the decision taken. Arrows (->) show how the state mutates. Treat every line as an assertion you can check by hand.

The 5 languages

Every solution ships in Kotlin (the source of truth, verbatim from src/main/kotlin/), plus Java, C++, typed Python, and Rust translations written fresh for this book. The translations preserve:

• the exact same algorithm and complexity,
• the same @param/@return contract,
• idiomatic types — List<Int>/int[]/vector<int>/list[int]/Vec<i32> depending on the language.

If a translation ever deviates in behavior, the page says so explicitly.

Difficulty of a page

• Core — a pattern you must own cold (e.g. Koko Eating Bananas, Median of Two Sorted Arrays).
• Variant — a twist on a core pattern (e.g. Search in Rotated Sorted Array II).
• Gym — a problem that combines several patterns (e.g. Closest Subsequence Sum).

Suggested reading order

Read Chapter 1 (Binary Search) first even if you know it — it is the shortest complete tour of the book’s format. Then follow the tree in order, or jump to whatever your interview is testing this week. The book is a reference, a syllabus, and a drill — in that order of priority.

The 5-Language Codebase

The engine of this book is the Kotlin repository at src/main/kotlin/. Understanding how it is organized makes every page of this book more useful.

Repository layout

src/main/kotlin/
├── array/            # arrays, two pointers, combinatorics, grid-adjacent array tricks
├── backtracking/     # permutations, combinations, subsets, constraint search
├── binarysearch/     # classic + exotic binary search (this book's Chapter 1)
├── bitset/           # bit manipulation
├── cache/            # LRU, LFU, thread-safe caches
├── disjointset/      # union-find / DSU
├── dynamic_programming/
├── graph/            # BFS, DFS, topological sort, SCC, flow, TSP, MST...
├── greedy/
├── grid/             # matrices, islands, A*
├── heap/
├── linkedlist/
├── math/
├── probability/      # reservoir sampling, randomized structures
├── quicksort/        # quickselect, top-k
├── sliding_window/
├── stack/
├── string/           # pattern matching, palindrome, trie-adjacent string tricks
├── tree/             # BST, segment tree, Fenwick tree, interval tree, N-ary
├── trie/
└── ...

Chapter mapping

Every book chapter cites its source files at the top. For example, Chapter 1 cites src/main/kotlin/binarysearch/KokoEatingBanana.kt for the Koko section. This lets you:

• open the exact file the book is explaining,
• run it with your own test harness,
• diff your own solution against the repo’s.

How the multi-language code was produced

1. Kotlin — copied from the repository, verbatim (minor cosmetic cleanup only, e.g. removing the package line so each listing is self-contained).
2. Java / C++ / Python / Rust — fresh translations written for this book with the same algorithm, same complexity, same @param/@return contract, idiomatic to each language.

Where the repository file contains a second, alternative solution (e.g. FindKClosestElements ships both a binary-search and a heap solution), the book presents both, since interviews love follow-ups of exactly this shape.

Typed Python

“Typed Python” means annotations are always present:

def minEatingSpeed(piles: list[int], h: int) -> int:

This is what the book shows everywhere. It costs nothing at runtime and it documents the contract the same way the Kotlin/Java/C++/Rust signatures do.

A note on the Kotlin sources

The repository is a living training log, not a release artifact — some files contain scratch notes, TODOs, or experiments. The book’s Kotlin listings present the essence of each file (the solution + its comments), and the Dry Run sections always describe the exact code shown, not a hypothetical version.

Big-O, Complexity & The Math Behind It

Every runtime claim in this book reduces to a handful of mathematical facts. Learn these once and complexity analysis stops being guesswork.

1. What Big-O actually is

We say $f(n) = O(g(n))$ if there exist constants $c > 0$ and $n_0 \ge 0$ such that for all $n \ge n_0$:

$$ f(n) \le c \cdot g(n) $$

Intuitively: beyond some input size, $f$ never grows faster than $g$ (up to a constant). Constants and lower-order terms are invisible to Big-O — that is a feature, not a bug: it isolates the growth rate, which is what survives a scale-up from your laptop to Google’s fleet.

The sibling notations you will meet:

• $\Omega(g)$ — lower bound ($f$ grows at least as fast as $g$),
• $\Theta(g)$ — tight bound (both hold),
• $o(g)$ — strictly slower growth.

The dominant term rule. When a function is a sum of terms, only the fastest-growing term matters:

$$ 5n^3 + 42n^2 + 7n + 100 = \Theta(n^3) $$

The base of a logarithm doesn’t matter (in Big-O). $\log_2 n = \frac{\log_{10} n}{\log_{10} 2}$, and the factor $1/\log_{10}2$ is a constant, so $\log_2 n = \Theta(\log_{10} n)$. That is why we write plain $\log n$.

2. The exponential-logarithmic duality you must internalize

Binary search works because the exponential function and the logarithm are inverses:

• An exponential doubling process (each step halves the search space) takes $\log_2 n$ steps to shrink $n$ to 1.
• A linear scan takes $n$ steps to do the same.

Concretely: $\log_2(10^6) \approx 20$, $\log_2(10^9) \approx 30$. If $n = 10^9$ and your algorithm is $O(\log n)$, you perform ~30 operations. If it is $O(n)$, you perform a billion. This is the entire difference binary search makes — 30 versus 1,000,000,000.

The key identity, used constantly in this book’s proofs:

$$ \log_2 n = k \iff 2^k = n $$

So halving an array of size $n$ exactly $k$ times reaches size $n / 2^k$, which equals 1 when $k = \log_2 n$.

3. Summations: the three you’ll actually use

Arithmetic series (why nested loops over $i < j$ cost $O(n^2)$):

$$ 1 + 2 + 3 + \cdots + n = \frac{n(n+1)}{2} = \Theta(n^2) $$

Proof sketch: pair $1$ with $n$, $2$ with $n-1$, … each pair sums to $n+1$, and there are $n/2$ pairs.

Geometric series (why doubling/halving sums to a constant factor):

$$ 1 + 2 + 4 + \cdots + 2^k = 2^{k+1} - 1 $$

For $|r| < 1$: $\displaystyle \sum_{i=0}^{\infty} r^i = \frac{1}{1 - r}$. This is why a single “while” loop that halves something still only costs $O(\log n)$ even though you revisit it: $n + n/2 + n/4 + \cdots = 2n = O(n)$.

Harmonic series (why “for each divisor” loops cost $O(n \log n)$):

$$ 1 + \frac12 + \frac13 + \cdots + \frac1n \le 1 + \ln n = O(\log n) $$

4. Recurrences and the Master Theorem

Recursive algorithms are analyzed via recurrences. The workhorse is the Master Theorem. For

$$ T(n) = a,T!\left(\frac{n}{b}\right) + f(n) $$

with $a \ge 1$, $b > 1$, compare $f(n)$ against $n^{\log_b a}$:

Worked examples from this book:

• Binary search: $T(n) = T(n/2) + O(1)$. Here $a=1, b=2$, so $n^{\log_2 1} = n^0 = 1$, and $f(n) = 1 = \Theta(n^0)$ → Case 2: $T(n) = \Theta(\log n)$.
• Merge sort / “binary search + linear feasibility” (Koko-style problems): $T(n) = T(n/2) + O(n)$ → $a=1$, $n^{\log_2 1}=1$, $f(n) = n$ is polynomially larger → Case 3: $T(n) = \Theta(n)$. Wait — the feasibility check is $O(n)$ and binary search runs it $\log R$ times, so total is $O(n \log R)$; the Master Theorem here describes the recursive structure, which for Koko is iterative, not recursive — see §6.
• Closest Subsequence Sum (Chapter 1.22): splitting in half gives $T(n) = 2T(n/2) + O(n)$ → $a=2$, $n^{\log_2 2} = n$, $f(n) = n$ → Case 2: $T(n) = \Theta(n \log n)$. But the DFS subset enumeration dominates: $2^{n/2}$ per half. Real bound: $O(2^{n/2})$.

5. Common growth rates, ranked

Rule of thumb from constraints: $n \le 10^5$ → $O(n \log n)$ acceptable; $n \le 10^3$ → $O(n^2)$ acceptable; $n \le 20$ → exponential acceptable.

6. The “binary search over an answer” complexity formula

Many problems in Chapter 1 (Koko, Capacity-to-Ship, House Robber IV) don’t binary search over an array — they binary search over a range of possible answers $[L, R]$, checking each candidate with a linear predicate $P$ that costs $O(f(n))$. The total is:

$$ T(n) = O!\left(f(n) \cdot \log_2(R - L)\right) $$

The $\log$ comes from the halving argument of §2 (the search space shrinks from $R - L$ to 1 in $\log_2(R-L)$ steps), and the $f(n)$ factor is paid per step. This single formula covers Koko ($O(n \log R)$), Capacity-to-Ship ($O(n \log S)$), and House Robber IV ($O(n \log V)$).

7. Space complexity is just “how much memory do we allocate”

• Iterative binary search: $O(1)$ auxiliary (a few pointers).
• Recursion: each live stack frame holds its locals, so depth $d$ costs $O(d)$. A balanced binary search recursion of depth $\log n$ costs $O(\log n)$; a linear recursion of depth $n$ costs $O(n)$.
• DP tables: a $m \times n$ table is $\Theta(mn)$; rolling arrays collapse it to $O(\min(m,n))$.

8. Amortized analysis (one idea, huge payoff)

Some operations are occasionally expensive but cheap on average. The classic example: a dynamically growing array that doubles when full. Resizing happens at sizes $1, 2, 4, \dots, 2^k$ costing $1, 2, 4, \dots, 2^k$ respectively. By the geometric-series identity:

$$ 1 + 2 + 4 + \cdots + 2^k = 2^{k+1} - 1 = O(n) $$

over $n$ insertions, i.e. $O(1)$ amortized per insertion. This is why ArrayList/vector/StringBuilder appends are “O(1)” in interviews, and it appears again in the amortized analyses of caches and splay-like structures in Chapter 12.

Chapter 1 — Binary Search

Source: src/main/kotlin/binarysearch/ (22 problems)

Master idea: every problem in this chapter is a different face of the same theorem — if a predicate on a range is monotone, the boundary where it flips can be found in $O(\log n)$.

Prerequisites: the halving math in Reference: Big-O & Complexity Math.

Problems at a glance

Reading order

Work through the sections in order the first time: 1.0 → 1.1 → 1.2 → 1.8 → 1.5 → 1.17 → 1.6 → 1.12. That path covers every sub-pattern (answer-space search, lower bound, rotated arrays, slope descent, partition search) with the minimum number of pages. The rest are variants and gyms that cement the same five moves.

Afterwards, close the book and try to derive 1.12’s partition condition from scratch — if you can, you own this chapter.

1.0 Pattern Primer — The Binary Search Theorem

Every problem in this chapter is a search problem, and search problems are solved by one of two weapons:

1. Brute force: look at every candidate. Cost is proportional to the size of the candidate space.
2. Binary search: exploit structure in the candidate space to discard half of it at each step. Cost is proportional to the logarithm of the size of the candidate space.

The structure we need is monotonicity. This page gives you the exact theorem, the two implementation templates used everywhere in this chapter, and the two traps that kill 90% of implementations.

The theorem

Binary Search Theorem. Let $P(x)$ be a predicate defined on an ordered domain $D$ (an array index range, an integer range $[L, R]$, whatever). If $P$ is monotone — i.e. $P(x) \Rightarrow P(x’)$ for all $x’ \ge x$ (once true, always true) — then there is a unique boundary $b^* = \min{x \in D : P(x)}$ and it can be found by halving in $O(\log |D|)$ predicate evaluations.

Equivalently, the domain splits into a “false prefix” followed by a “true suffix”:

P(x):   F F F F F T T T T T T
              ^
              b* = first true

The mirror form (once true, always false, i.e. $P$ is anti-monotone) works identically — you just binary search for the last true instead of the first true. Both appear in this chapter.

Why halving finds it: binary search maintains an invariant “left is false, right is true” (or “left is outside, right is inside”). Each step tests the midpoint. If the midpoint is false, the boundary must lie strictly to its right, so we move left past it; if true, the boundary is at or to its left, so we move right onto it. Either way the interval $[left, right]$ halves, and by the identity $2^k \ge n \iff k \ge \log_2 n$, after $\lceil \log_2 n \rceil$ steps the interval collapses to the single point $b^*$. See Reference §2 for the halving math.

Template A — the “first true” search (lower bound)

The workhorse of this chapter. All of Koko, Capacity, First Bad Version, House Robber IV, Search Insert Position, and the rotated-array problems are this template wearing different costumes:

// Find the smallest x in [lo, hi) such that predicate(x) is true.
// Invariant: predicate(lo) == false (or lo is "too small"), predicate(hi) == true (or hi is "big enough").
fun lowerBound(lo: Int, hi: Int, predicate: (Int) -> Boolean): Int {
    var left = lo
    var right = hi            // right is EXCLUSIVE: candidate space is [left, right)
    while (left < right) {    // stop when the interval has exactly one element
        val mid = left + (right - left) / 2   // overflow-safe midpoint
        if (predicate(mid)) right = mid       // mid is true  -> boundary is at or left of mid
        else                left = mid + 1    // mid is false -> boundary is strictly right of mid
    }
    return left               // left == right == b*
}

Notes on the details — each one is load-bearing:

• right = hi (exclusive). This guarantees right always points at a candidate for the answer, and the loop condition left < right never drops the answer. If you used right = hi - 1 you’d need left <= right and a completely different set of edge cases.
• left = mid + 1 vs right = mid. This asymmetry is what makes the search progress: mid is never re-tested as false, so the interval strictly shrinks. If you wrote left = mid and mid stays false forever (e.g. left = mid = left when right - left == 1), you’d infinite-loop.
• Overflow-safe midpoint. (left + right) / 2 can overflow for huge ranges (this exact bug lived in Java’s standard library for 20 years — see Chapter 1 intro). Always write left + (right - left) / 2.

Template B — the exact-match search

When you’re looking for an exact value (not a boundary), you use the classic three-way comparison:

fun exactMatch(arr: IntArray, target: Int): Int {
    var left = 0
    var right = arr.lastIndex          // INCLUSIVE here
    while (left <= right) {
        val mid = left + (right - left) / 2
        when {
            arr[mid] == target -> return mid
            arr[mid] < target  -> left = mid + 1
            else               -> right = mid - 1
        }
    }
    return -1                          // not found
}

Template B terminates because every branch either returns or shrinks the interval. The price of “inclusive” bounds is that left == right still needs a test — hence <=.

When do you “binary search on the answer”?

Classic binary search searches an array. But 1.1, 1.2, 1.10 search a range of integer answers $[L, R]$ instead — the “array” is conceptual. The trigger is:

1. The answer is a number with a natural range (speed $[1, \max piles]$, capacity $[\max weight, \sum weights]$, capability $[\min, \max]$).
2. Feasibility is monotone in the answer: if speed $k$ works, speed $k+1$ works.
3. A cheap feasibility check $P(x)$ exists.

Then the answer is $\min{x : P(x)}$ — exactly Template A. The cost is $O(f \cdot \log(R - L))$ where $f$ is the cost of one feasibility check (see Reference §6).

The five moves of this chapter

Every remaining page in this chapter is one of these five moves, stated in a costume. Learn the moves, not the costumes.

1.1 Koko Eating Bananas

Source: src/main/kotlin/binarysearch/KokoEatingBanana.kt Pattern: binary search on the answer · Core page

The Problem

Koko loves bananas. There are n piles, and the i-th pile has piles[i] bananas. The guards are going to be away for h hours, and Koko wants to eat all the bananas before they return.

Koko decides her eating speed: k bananas per hour. Each hour she picks one pile and eats k bananas from it. If a pile has fewer than k bananas, she eats the whole pile and then cannot eat anything else that hour (the hour is “wasted”). She can choose k freely, and can change it between hours — but the speed must be an integer.

Find the minimum integer k such that Koko can finish all piles within h hours.

• Constraints: $1 \le n \le 10^4$, $n \le h \le 10^9$, $1 \le piles[i] \le 10^9$.

Examples

Example 1
Input:  piles = [3, 6, 7, 11], h = 8
Output: 4
Explanation: at k = 4:  pile 3 → 1h, pile 6 → 2h, pile 7 → 2h, pile 11 → 3h. Total = 8h. ✓
             at k = 3:  3→1h, 6→2h, 7→3h, 11→4h. Total = 10h > 8. ✗
             So 4 is the minimum speed that works.

Example 2
Input:  piles = [30, 11, 23, 4, 20], h = 5
Output: 30
Explanation: with only 5 hours, Koko must finish each pile in exactly 1 hour → k = 30 (max pile).

Intuition — why binary search applies at all

Two facts make this a binary search problem instead of a brute-force problem:

1. The answer lives in a small, ordered range. The speed is between $1$ and $\max(piles)$ — eating faster than the largest pile never helps (each pile already takes ≥ 1 hour). So the candidate space is $[1, \max(piles)]$, size $R \le 10^9$.

2. Feasibility is monotone in the speed. Define $P(k)$ = “Koko can finish all piles in $\le h$ hours at speed $k$.” If $k$ works, then any faster speed $k’ > k$ also works — eating more bananas per hour can never make her slower. So $P$ looks like:

P(k):   F F F F F T T T T T
              ^
          answer = first true

This is exactly the Binary Search Theorem from 1.0: the boundary between “too slow” and “fast enough” is the minimum valid speed, and halving finds it in $O(\log R)$ feasibility checks.

The cost of one check: at speed $k$, pile $i$ takes $\lceil piles[i] / k \rceil = \lfloor (piles[i] + k - 1) / k \rfloor$ hours (integer ceiling division — the “+k−1 then integer divide” trick). Sum over all piles, compare to $h$: $O(n)$ per check.

Total: $O(n \log R)$ — about $10^4 \times 30 = 3 \times 10^5$ operations for the worst case. A linear scan over all $R$ candidate speeds would be $10^4 \times 10^9$ — hopeless. This is the entire point.

Approach 1 — Brute force (linear scan over speeds)

Try $k = 1, 2, 3, \dots$ until one works. The first working $k$ is the answer.

def min_eating_speed(piles: list[int], h: int) -> int:
    """O(R) candidate speeds × O(n) check each = O(R·n). Too slow for R up to 1e9."""
    for k in range(1, max(piles) + 1):
        if sum((p + k - 1) // k for p in piles) <= h:
            return k
    return max(piles)

• Time: $O(R \cdot n)$ where $R = \max(piles)$ — up to $10^{13}$ operations. Dead on arrival for real constraints.
• Space: $O(1)$.

The structure ($P$ monotone) is exactly what binary search is for. The brute force throws away that structure; the optimal solution exploits it.

Approach 2 — Binary search on the answer (optimal)

/**
 * @param piles the number of bananas in each pile (1..1e9 each)
 * @param h     the number of hours the guards are away (h >= piles.size)
 * @return      the minimum integer eating speed k (bananas/hour) such that
 *              Koko can finish all piles within h hours
 */
fun minEatingSpeed(piles: IntArray, h: Int): Int {
    var left = 1                      // too slow to be feasible, but a valid lower bound
    var right = piles.maxOrNull()!!   // always feasible: one hour per pile at most

    while (left < right) {            // Template A: find first true
        val mid = left + (right - left) / 2
        if (canEatAllBananas(piles, h, mid)) {
            right = mid               // feasible -> try slower
        } else {
            left = mid + 1            // infeasible -> must go faster
        }
    }
    return left
}

/**
 * @param piles the pile sizes
 * @param h     the hour budget
 * @param k     the candidate speed to test
 * @return      true iff sum of ceil(pile / k) over all piles is <= h
 */
private fun canEatAllBananas(piles: IntArray, h: Int, k: Int): Boolean {
    var totalHours = 0
    for (pile in piles) {
        totalHours += (pile + k - 1) / k   // ceiling division without floating point
    }
    return totalHours <= h
}

public class KokoEatingBanana {
    /**
     * @param piles the number of bananas in each pile
     * @param h     the number of hours the guards are away (h >= piles.length)
     * @return      the minimum integer speed k such that all piles finish within h hours
     */
    public int minEatingSpeed(int[] piles, int h) {
        int left = 1;
        int right = 0;
        for (int pile : piles) right = Math.max(right, pile);   // max pile = always-feasible speed

        while (left < right) {
            int mid = left + (right - left) / 2;                // overflow-safe midpoint
            if (canEatAllBananas(piles, h, mid)) {
                right = mid;                                    // feasible -> slow down
            } else {
                left = mid + 1;                                 // infeasible -> speed up
            }
        }
        return left;
    }

    /**
     * @param piles the pile sizes
     * @param h     the hour budget
     * @param k     candidate speed to test
     * @return      true iff sum of ceil(pile / k) over all piles is <= h
     */
    private boolean canEatAllBananas(int[] piles, int h, int k) {
        long totalHours = 0;
        for (int pile : piles) {
            totalHours += (pile + k - 1L) / k;                  // 1L avoids overflow on the +k-1
        }
        return totalHours <= h;
    }
}

#include <vector>
#include <algorithm>

class KokoEatingBanana {
public:
    /**
     * @param piles the number of bananas in each pile
     * @param h     the number of hours the guards are away (h >= piles.size())
     * @return      the minimum integer speed k such that all piles finish within h hours
     */
    int minEatingSpeed(const std::vector<int>& piles, int h) {
        int left = 1;
        int right = *std::max_element(piles.begin(), piles.end());  // always-feasible speed

        while (left < right) {
            int mid = left + (right - left) / 2;
            if (canEatAllBananas(piles, h, mid)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }

private:
    /**
     * @param piles the pile sizes
     * @param h     the hour budget
     * @param k     candidate speed to test
     * @return      true iff sum of ceil(pile / k) over all piles is <= h
     */
    bool canEatAllBananas(const std::vector<int>& piles, int h, int k) {
        long long totalHours = 0;
        for (int pile : piles) {
            totalHours += (pile + k - 1LL) / k;   // integer ceiling division
        }
        return totalHours <= h;
    }
};

def min_eating_speed(piles: list[int], h: int) -> int:
    """
    @param piles: the number of bananas in each pile
    @param h:     the number of hours the guards are away (h >= len(piles))
    @return:      the minimum integer speed k such that all piles finish within h hours
    """
    left, right = 1, max(piles)          # right = always-feasible speed
    while left < right:
        mid = left + (right - left) // 2
        if can_eat_all(piles, h, mid):
            right = mid                  # feasible -> try slower
        else:
            left = mid + 1               # infeasible -> must go faster
    return left


def can_eat_all(piles: list[int], h: int, k: int) -> bool:
    """
    @param piles: the pile sizes
    @param h:     the hour budget
    @param k:     candidate speed to test
    @return:      True iff sum of ceil(pile / k) over all piles is <= h
    """
    total_hours = sum((pile + k - 1) // k for pile in piles)   # ceiling division
    return total_hours <= h

#![allow(unused)]
fn main() {
impl Solution {
    /// @param piles the number of bananas in each pile
    /// @param h     the number of hours the guards are away (h >= piles.len())
    /// @return      the minimum integer speed k such that all piles finish within h hours
    pub fn min_eating_speed(piles: Vec<i32>, h: i32) -> i32 {
        let (mut left, mut right) = (1, *piles.iter().max().unwrap());   // right = always-feasible
        while left < right {
            let mid = left + (right - left) / 2;
            if Self::can_eat_all(&piles, h, mid) {
                right = mid;                 // feasible -> try slower
            } else {
                left = mid + 1;              // infeasible -> must go faster
            }
        }
        left
    }

    /// @param piles the pile sizes
    /// @param h     the hour budget
    /// @param k     candidate speed to test
    /// @return      true iff sum of ceil(pile / k) over all piles is <= h
    fn can_eat_all(piles: &[i32], h: i32, k: i32) -> bool {
        let total: i64 = piles.iter().map(|&p| (p as i64 + k as i64 - 1) / k as i64).sum();
        total <= h as i64
    }
}
}

Dry run

Input: piles = [3, 6, 7, 11], h = 8. Candidate space $[1, 11]$:

left=1  right=11  mid=6  -> hours(6) = 1+1+2+2 = 6 <= 8  FEASIBLE -> right=6
left=1  right=6   mid=3  -> hours(3) = 1+2+3+4 = 10 > 8  NOT      -> left=4
left=4  right=6   mid=5  -> hours(5) = 1+2+2+3 = 8  <= 8  FEASIBLE -> right=5
left=4  right=5   mid=4  -> hours(4) = 1+2+2+3 = 8  <= 8  FEASIBLE -> right=4
left=4  right=4   -> loop ends, return 4

Let’s verify the feasibility check by hand for the two interesting midpoints:

Notice the search never even looked at speeds 1, 2, 7–11 — it discarded them in 5 halving steps. Brute force would have examined 11.

Why right lands on a feasible answer: right starts at $\max(piles)$ (feasible: each pile takes exactly 1 hour) and only ever moves down onto feasible midpoints. left starts at 1 (infeasible whenever $h < n$; but even when 1 is feasible, the invariant still finds the minimum feasible because we always probe lower). The invariant “left infeasible, right feasible” survives every iteration, so at termination left == right is the boundary = answer.

Complexity

Time. Each iteration runs canEatAllBananas in $O(n)$ (one pass, integer divisions). The search space $[1, \max(piles)]$ has size $R$, halved $\log_2 R$ times:

$$ T(n) = n \cdot \log_2 R = O(n \log R) $$

With $n \le 10^4$ and $R \le 10^9$: $\approx 10^4 \times 30 = 3 \times 10^5$ operations.

Space. Four scalar variables plus the input: $O(1)$ auxiliary.

Variants & follow-ups

• Capacity To Ship Packages Within D Days (1.2) — identical shape; the feasibility check becomes a greedy packer.
• Minimum Number of Taps to Water a Garden (src/main/kotlin/array/greedy/) — “monotone in the answer” again, but the check is greedy interval covering.
• House Robber IV (1.10) — binary search on the capability (a value), with a greedy “rob non-adjacent” check.
• Interview follow-up: “What if h can be smaller than n?” Then the answer is still well-defined, but the range shrinks — the loop handles it, because $k \ge \max(piles)$ is always feasible and the search space is never empty.
• Interview follow-up: “Prove ceiling division.” $\lceil a/b \rceil = \lfloor (a + b - 1) / b \rfloor$ because $a = qb + r$ with $0 \le r < b$; adding $b - 1$ pushes the numerator past the next multiple of $b$ exactly when $r > 0$.

1.2 Capacity To Ship Packages Within D Days

Source: src/main/kotlin/binarysearch/CapacityToShipPackageWithinDDays.kt Pattern: binary search on the answer · Core page

The Problem

A conveyor belt ships packages in order. You are given weights — the weight of each package — and days — the number of days you have. Packages are loaded onto the ship in the given order, one day at a time, without reordering.

The ship has a capacity C (total weight it can carry per day). Each day you must ship the next packages until adding one more would exceed C.

Find the minimum capacity C that ships all packages within days days.

• Constraints: $1 \le n \le 5 \times 10^4$, $1 \le days \le n$, $1 \le weights[i] \le 500$.

Examples

Example 1
Input:  weights = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], days = 5
Output: 15
Explanation: with C = 15:
  day 1: 1+2+3+4+5 = 15
  day 2: 6+7      = 13
  day 3: 8        = 8
  day 4: 9        = 9
  day 5: 10       = 10   -> exactly 5 days. C = 14 fails (1+2+3+4+5=15 > 14 splits into more days).

Example 2
Input:  weights = [3, 2, 2, 4, 1, 4], days = 3
Output: 6
Explanation: day 1: 3+2 = 5, day 2: 2+4 = 6, day 3: 1+4 = 5 → 3 days with capacity 6.

Intuition — the Koko twin

This is Koko (1.1) with different clothes:

• The answer range is $[\max(weights), \sum(weights)]$. Capacity below the heaviest single package can never ship that package; capacity at the total sum ships everything in one day.
• Feasibility is monotone: $P(C)$ = “all packages ship within days days at capacity $C$”. Bigger capacity can only mean fewer days — you can always ship the same packages you could before, and possibly more per day. So $P$ is a false-prefix/true-suffix predicate:

P(C):   F F F F F T T T T T
              ^
        answer = first true

• The feasibility check is a greedy day-packer. To test capacity $C$: walk the packages, accumulate into a running load, and whenever adding the next package would exceed $C$, close the current day and start a new one with that package. Count days. This is optimal for the “ship in order” constraint — no smarter packing exists because reordering is forbidden and each package is atomic.

Total: $O(n \log S)$ where $S = \sum weights \le 2.5 \times 10^7$. The log factor is only ~25; the $n$ factor is 1 pass per check.

Approach 1 — Brute force (try every capacity)

Scan $C$ from $\max(weights)$ upward, run the greedy day-counter, return the first $C$ that fits. Cost: up to $S - \max$ candidates × $O(n)$ per check $\approx 2.5 \times 10^7 \times 5 \times 10^4$ — catastrophically slow. The monotone structure begs for halving instead.

Approach 2 — Binary search on the answer (optimal)

/**
 * @param weights the weight of each package, in shipping order
 * @param days    the number of days available to ship everything
 * @return        the minimum capacity C such that all packages ship within `days` days
 */
fun shipWithinDays(weights: IntArray, days: Int): Int {
    var sum = 0
    var max = 0
    for (weight in weights) {
        sum += weight
        max = maxOf(max, weight)
    }

    var left = max          // infeasible below this
    var right = sum         // always feasible
    while (left < right) {
        val mid = left + (right - left) / 2
        if (feasible(weights, mid, days)) {
            right = mid     // feasible -> try smaller capacity
        } else {
            left = mid + 1  // infeasible -> need more capacity
        }
    }
    return left
}

/**
 * @param weights the packages in order
 * @param capacity the candidate ship capacity to test
 * @param days    the day budget
 * @return        true iff a greedy day-packer fits all packages into <= `days` days
 */
fun feasible(weights: IntArray, capacity: Int, days: Int): Boolean {
    var daysNeeded = 1
    var currentLoad = 0
    for (weight in weights) {
        currentLoad += weight
        if (currentLoad > capacity) {
            daysNeeded++            // close the current day, start a fresh one with this package
            currentLoad = weight
        }
    }
    return daysNeeded <= days
}

public class CapacityToShipPackageWithinDDays {
    /**
     * @param weights the weight of each package, in shipping order
     * @param days    the number of days available to ship everything
     * @return        the minimum capacity C such that all packages ship within `days` days
     */
    public int shipWithinDays(int[] weights, int days) {
        int sum = 0, max = 0;
        for (int w : weights) {
            sum += w;
            max = Math.max(max, w);
        }

        int left = max, right = sum;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (feasible(weights, mid, days)) right = mid;   // feasible -> smaller capacity
            else left = mid + 1;                              // infeasible -> more capacity
        }
        return left;
    }

    /**
     * @param weights  the packages in order
     * @param capacity the candidate ship capacity to test
     * @param days     the day budget
     * @return         true iff a greedy day-packer fits all packages into <= `days` days
     */
    private boolean feasible(int[] weights, int capacity, int days) {
        int daysNeeded = 1, currentLoad = 0;
        for (int w : weights) {
            currentLoad += w;
            if (currentLoad > capacity) {
                daysNeeded++;
                currentLoad = w;
            }
        }
        return daysNeeded <= days;
    }
}

#include <vector>

class CapacityToShipPackageWithinDDays {
public:
    /**
     * @param weights the weight of each package, in shipping order
     * @param days    the number of days available to ship everything
     * @return        the minimum capacity C such that all packages ship within `days` days
     */
    int shipWithinDays(const std::vector<int>& weights, int days) {
        int sum = 0, max = 0;
        for (int w : weights) {
            sum += w;
            max = std::max(max, w);
        }

        int left = max, right = sum;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (feasible(weights, mid, days)) right = mid;
            else left = mid + 1;
        }
        return left;
    }

private:
    /**
     * @param weights  the packages in order
     * @param capacity the candidate ship capacity to test
     * @param days     the day budget
     * @return         true iff a greedy day-packer fits all packages into <= `days` days
     */
    bool feasible(const std::vector<int>& weights, int capacity, int days) {
        int daysNeeded = 1, currentLoad = 0;
        for (int w : weights) {
            currentLoad += w;
            if (currentLoad > capacity) {
                daysNeeded++;
                currentLoad = w;
            }
        }
        return daysNeeded <= days;
    }
};

def ship_within_days(weights: list[int], days: int) -> int:
    """
    @param weights: the weight of each package, in shipping order
    @param days:    the number of days available to ship everything
    @return:        the minimum capacity C such that all packages ship within `days` days
    """
    left, right = max(weights), sum(weights)
    while left < right:
        mid = left + (right - left) // 2
        if feasible(weights, mid, days):
            right = mid        # feasible -> try smaller capacity
        else:
            left = mid + 1     # infeasible -> need more capacity
    return left


def feasible(weights: list[int], capacity: int, days: int) -> bool:
    """
    @param weights:  the packages in order
    @param capacity: the candidate ship capacity to test
    @param days:     the day budget
    @return:         True iff a greedy day-packer fits all packages into <= `days` days
    """
    days_needed, current_load = 1, 0
    for w in weights:
        current_load += w
        if current_load > capacity:
            days_needed += 1
            current_load = w
    return days_needed <= days

#![allow(unused)]
fn main() {
impl Solution {
    /// @param weights the weight of each package, in shipping order
    /// @param days    the number of days available to ship everything
    /// @return        the minimum capacity C such that all packages ship within `days` days
    pub fn ship_within_days(weights: Vec<i32>, days: i32) -> i32 {
        let (mut left, mut right) = (*weights.iter().max().unwrap(), weights.iter().sum::<i32>());
        while left < right {
            let mid = left + (right - left) / 2;
            if Self::feasible(&weights, mid, days) {
                right = mid;          // feasible -> try smaller capacity
            } else {
                left = mid + 1;       // infeasible -> need more capacity
            }
        }
        left
    }

    /// @param weights  the packages in order
    /// @param capacity the candidate ship capacity to test
    /// @param days     the day budget
    /// @return         true iff a greedy day-packer fits all packages into <= `days` days
    fn feasible(weights: &[i32], capacity: i32, days: i32) -> bool {
        let mut days_needed = 1;
        let mut current_load = 0;
        for &w in weights {
            current_load += w;
            if current_load > capacity {
                days_needed += 1;
                current_load = w;
            }
        }
        days_needed <= days
    }
}
}

Dry run

Input: weights = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], days = 5. Search space $[10, 55]$:

left=10  right=55  mid=32  -> greedy days(32) = 3  ≤ 5  FEASIBLE -> right=32
left=10  right=32  mid=21  -> greedy days(21) = 3  ≤ 5  FEASIBLE -> right=21
left=10  right=21  mid=15  -> greedy days(15) = 5  ≤ 5  FEASIBLE -> right=15
left=10  right=15  mid=12  -> greedy days(12) = 6  > 5  NOT      -> left=13
left=13  right=15  mid=14  -> greedy days(14) = 6  > 5  NOT      -> left=15
left=15  right=15  -> loop ends, return 15

Let me double-check the critical feasibility traces by hand (the “why 15 works, 14 doesn’t” table):

For C=14: day1: 1,2,3,4 → 10; +5 = 15 > 14, so day2 starts with 5: 5,6 → 11; +7 = 18 > 14, day3 starts with 7: 7,8 → 15 > 14, day4 starts with 8: 8,9 → 17 > 14, day5 starts with 9: 9,10 → 19 > 14, day6: 10. That’s 6 days > 5 ✗. So 14 is infeasible and 15 is the boundary. The binary search found it in 5 feasibility checks.

Complexity

Time. $O(\log(S - \max))$ halving steps, each costing an $O(n)$ greedy pass:

$$ T(n) = n \cdot \log_2(S - \max) = O(n \log S) $$

With $S \le 2.5 \times 10^7$: $\approx 5 \times 10^4 \times 25 = 1.25 \times 10^6$ operations.

Space. $O(1)$ auxiliary (a handful of scalars; the input array is not copied).

Why the greedy check is correct

The “ship in order, close a day when the next package overflows” rule is not a heuristic — it is forced. Because packages cannot be reordered and a day cannot be split mid-package, the only decision is where day boundaries fall, and the earliest possible boundary (greedy) leaves the maximum remaining capacity for future days. Formally: if a feasible packing exists with day boundaries $b_1 < b_2 < \dots$, then the greedy boundaries $g_1 \le b_1, g_2 \le b_2, \dots$ never finish later, so greedy uses $\le$ the optimal number of days. Hence “greedy days ≤ budget” is both necessary and sufficient for feasibility.

Variants & follow-ups

• Koko Eating Bananas (1.1) — identical skeleton; the greedy check is “accumulate hours”, not “accumulate load”.
• House Robber IV (1.10) — same skeleton, greedy non-adjacent picker.
• Split Array Largest Sum (classic sibling) — the answer is the same “minimum feasible capacity”; the check counts subarrays with sum ≤ mid.
• Interview follow-up: “What if packages could be reordered?” Then feasibility is still monotone, but the check becomes a bin-packing argument (NP-hard in general) — the in-order constraint is what keeps this polynomial. Say that out loud and you sound senior.

1.3 Find First And Last Position Of Target

Source: src/main/kotlin/binarysearch/FindFirstAndLastPosition.kt Pattern: lower bound + upper bound · Core page

The Problem

Given a sorted array nums (may contain duplicates) and a target value, return the index of the first occurrence and the index of the last occurrence. If the target does not appear, return [-1, -1].

• Constraints: $0 \le n \le 10^5$, values and target fit in Int.

Examples

Input:  nums = [5, 7, 7, 8, 8, 10], target = 8
Output: [3, 4]

Input:  nums = [5, 7, 7, 8, 8, 10], target = 6
Output: [-1, -1]

Input:  nums = [], target = 0
Output: [-1, -1]

Intuition

A naive linear scan finds the first occurrence in $O(n)$ — fine once, but this is the primitive out of which heavier machinery is built (count of a value = last − first + 1; range queries in sorted data; binary-search-based data structures). The sorted structure gives us a much sharper tool.

The key insight: the boundary trick works on both sides of the target.

• First occurrence = “first true” for the predicate $P_1(x) = nums[x] \ge target$. Before the first 8, all elements are < 8 (false); from the first 8 onward, all elements are >= 8 (true). The boundary is exactly the first 8.
• Last occurrence = “last true” for the predicate $P_2(x) = nums[x] \le target$, i.e. the first index where the opposite predicate $nums[x] > target$ becomes true, minus 1.

Both boundaries are found by the same machinery from 1.0 — Template B with a twist: when we hit target, we don’t stop; we keep shrinking the window toward the side we care about. That’s the whole trick:

• to find the first occurrence: on a hit, right = mid - 1 (keep looking left),
• to find the last occurrence: on a hit, left = mid + 1 (keep looking right),
• and we remember the last hit in result — when the window empties, result holds the boundary.

Approach 1 — Linear scan

Scan left to right for the first match, then right to left for the last. $O(n)$ time, $O(1)$ space. Correct but ignores the sorted structure entirely; if the interviewer then asks “what if nums has a billion entries”, you want Approach 2.

Approach 2 — Two binary searches (optimal)

/**
 * @param nums   the sorted array (may contain duplicates)
 * @param target the value whose range of occurrences to find
 * @return       an IntArray [firstIndex, lastIndex], or [-1, -1] if target is absent
 */
fun searchRange(nums: IntArray, target: Int): IntArray {
    val result = intArrayOf(-1, -1)

    // Find the first occurrence: keep shrinking right on hits.
    result[0] = binarySearch(nums, target, findFirst = true)
    // If the first occurrence is missing, the whole range is missing.
    if (result[0] == -1) return result

    // Find the last occurrence: keep growing left on hits.
    result[1] = binarySearch(nums, target, findFirst = false)
    return result
}

/**
 * @param nums      the sorted array
 * @param target    the value to locate
 * @param findFirst when true, return the leftmost occurrence; when false, the rightmost
 * @return          the requested boundary index, or -1 if target is absent
 */
private fun binarySearch(nums: IntArray, target: Int, findFirst: Boolean): Int {
    var left = 0
    var right = nums.lastIndex
    var result = -1

    while (left <= right) {
        val mid = left + (right - left) / 2
        when {
            nums[mid] == target -> {
                result = mid
                // Narrow the window past the hit, toward the side we want.
                if (findFirst) right = mid - 1  // hunt for an earlier equal element
                else            left = mid + 1  // hunt for a later equal element
            }
            nums[mid] < target -> left = mid + 1
            else                -> right = mid - 1
        }
    }
    return result
}

public class FindFirstAndLastPosition {
    /**
     * @param nums   the sorted array (may contain duplicates)
     * @param target the value whose range of occurrences to find
     * @return       int[] {firstIndex, lastIndex}, or {-1, -1} if target is absent
     */
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        result[0] = binarySearch(nums, target, true);
        if (result[0] == -1) return result;
        result[1] = binarySearch(nums, target, false);
        return result;
    }

    /**
     * @param nums      the sorted array
     * @param target    the value to locate
     * @param findFirst true for leftmost occurrence, false for rightmost
     * @return          the requested boundary index, or -1 if absent
     */
    private int binarySearch(int[] nums, int target, boolean findFirst) {
        int left = 0, right = nums.length - 1, result = -1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                result = mid;
                if (findFirst) right = mid - 1;
                else           left = mid + 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return result;
    }
}

#include <vector>

class FindFirstAndLastPosition {
public:
    /**
     * @param nums   the sorted array (may contain duplicates)
     * @param target the value whose range of occurrences to find
     * @return       {firstIndex, lastIndex}, or {-1, -1} if target is absent
     */
    std::vector<int> searchRange(const std::vector<int>& nums, int target) {
        std::vector<int> result = {-1, -1};
        result[0] = binarySearch(nums, target, true);
        if (result[0] == -1) return result;
        result[1] = binarySearch(nums, target, false);
        return result;
    }

private:
    /**
     * @param nums      the sorted array
     * @param target    the value to locate
     * @param findFirst true for leftmost occurrence, false for rightmost
     * @return          the requested boundary index, or -1 if absent
     */
    int binarySearch(const std::vector<int>& nums, int target, bool findFirst) {
        int left = 0, right = (int)nums.size() - 1, result = -1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                result = mid;
                if (findFirst) right = mid - 1;
                else           left = mid + 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return result;
    }
};

def search_range(nums: list[int], target: int) -> list[int]:
    """
    @param nums:   the sorted array (may contain duplicates)
    @param target: the value whose range of occurrences to find
    @return:       [firstIndex, lastIndex], or [-1, -1] if target is absent
    """
    first = binary_search(nums, target, find_first=True)
    if first == -1:
        return [-1, -1]
    last = binary_search(nums, target, find_first=False)
    return [first, last]


def binary_search(nums: list[int], target: int, find_first: bool) -> int:
    """
    @param nums:       the sorted array
    @param target:     the value to locate
    @param find_first: True for leftmost occurrence, False for rightmost
    @return:           the requested boundary index, or -1 if absent
    """
    left, right, result = 0, len(nums) - 1, -1
    while left <= right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            result = mid
            if find_first:
                right = mid - 1
            else:
                left = mid + 1
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return result

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums   the sorted array (may contain duplicates)
    /// @param target the value whose range of occurrences to find
    /// @return       [firstIndex, lastIndex], or [-1, -1] if target is absent
    pub fn search_range(nums: Vec<i32>, target: i32) -> Vec<i32> {
        let first = Self::binary_search(&nums, target, true);
        if first == -1 {
            return vec![-1, -1];
        }
        let last = Self::binary_search(&nums, target, false);
        vec![first, last]
    }

    /// @param nums       the sorted array
    /// @param target     the value to locate
    /// @param find_first true for leftmost occurrence, false for rightmost
    /// @return           the requested boundary index, or -1 if absent
    fn binary_search(nums: &[i32], target: i32, find_first: bool) -> i32 {
        if nums.is_empty() {
            return -1;
        }
        let (mut left, mut right, mut result) = (0usize, nums.len() - 1, -1i32);
        while left <= right {
            let mid = left + (right - left) / 2;
            if nums[mid] == target {
                result = mid as i32;
                if find_first {
                    if mid == 0 { break; }
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else if nums[mid] < target {
                left = mid + 1;
            } else {
                if mid == 0 { break; }
                right = mid - 1;
            }
        }
        result
    }
}
}

Note on the Rust version: usize can’t go negative, so when mid == 0 and we need to move right below it, we break out — the search window is exhausted and result already holds the best boundary found. This is the one place where Rust’s type system forces a slightly different (but equivalent) control flow than the other four languages.

Dry run

Input: nums = [5, 7, 7, 8, 8, 10], target = 8. First, the “find first” pass:

left=0  right=5  mid=2  nums[2]=7 < 8  -> left=3
left=3  right=5  mid=4  nums[4]=8 == 8 -> result=4, findFirst -> right=3
left=3  right=3  mid=3  nums[3]=8 == 8 -> result=3, findFirst -> right=2
left=3  right=2  -> loop ends. return 3    (first occurrence) ✓

Then the “find last” pass:

left=0  right=5  mid=2  nums[2]=7 < 8  -> left=3
left=3  right=5  mid=4  nums[4]=8 == 8 -> result=4, findLast -> left=5
left=5  right=5  mid=5  nums[5]=10 > 8 -> right=4
left=5  right=4  -> loop ends. return 4    (last occurrence) ✓

Both passes examine $\lceil \log_2 6 \rceil = 3$ elements each — six probes total versus six for a linear scan on this tiny input, and the gap widens exponentially as n grows.

Edge cases: nums = [] → right = -1, loop never runs, result = -1 → [-1, -1]. Target smaller than everything → both passes return -1. Target larger than everything → same.

Complexity

Time. Each of the two passes halves the window, so each costs $O(\log n)$; total:

$$ T(n) = 2 \cdot \lceil \log_2(n+1) \rceil = O(\log n) $$

Space. A handful of scalars: $O(1)$ auxiliary.

Variants & follow-ups

• First Bad Version (1.8) is the same “find the boundary” search with an oracle predicate instead of an array.
• Count of occurrences of target in a sorted array = last - first + 1 — one extra subtraction on top of this page.
• Kth Missing Positive Number (1.11) reuses the “first true” boundary idea on a counting predicate.
• Interview follow-up: “How would you find the index where the array stops being ≤ target?” — that’s literally the findLast pass; the boundary style of thinking transfers to any monotone predicate, which is the theme of 1.0.

1.4 Find K Closest Elements

Source: src/main/kotlin/binarysearch/FindKClosestElements.kt Pattern: binary search on the start index · Core page (the heap version is a famous follow-up)

The Problem

Given a sorted array arr, an integer k, and an integer x, return the k elements of arr that are closest to x (by absolute difference), in sorted order.

Ties are broken toward the smaller value: if two candidates are equally close, prefer arr[i] over arr[i + k] (the left one).

• Constraints: $1 \le k \le n \le 10^4$, sorted ascending.

Examples

Input:  arr = [1, 2, 3, 4, 5], k = 4, x = 3
Output: [1, 2, 3, 4]
Explanation: distances from 3: 1→2, 2→1, 3→0, 4→1, 5→2. The 4 smallest are 1,2,3,4.

Input:  arr = [1, 2, 3, 4, 5], k = 4, x = -1
Output: [1, 2, 3, 4]
Explanation: everything is to the right; the 4 smallest values are closest.

Input:  arr = [1, 1, 1, 10, 10, 10], k = 1, x = 9
Output: [10]
Explanation: |1−9| = 8 vs |10−9| = 1 → the single 10 is closest.

Intuition — why binary search can find a window start

Most people reach for a heap or a sort. Both are correct and worth knowing (Approach 2 below), but there is a sharper structure hiding here: the answer is always a contiguous window of k elements in the sorted array.

Why? Suppose the answer contained arr[i] but not arr[j] with i < j while j lies strictly between i and the window’s other members. Swapping would only move the window toward the cluster — formally, for any three sorted values $a \le b \le c$ we have $|b - x| \le \max(|a - x|, |c - x|)$, so an interior element can never be farther than an exterior one. Hence the optimal set is a contiguous block.

So the problem reduces to: find the leftmost index s of the optimal window arr[s .. s+k). That’s a search over n - k + 1 possible starts — and the score of a window is monotone enough to binary search:

Let $W_s = \text{arr}[s..s+k)$. Moving the window right by one drops arr[s] and adds arr[s+k]. If arr[s+k] is closer to x than arr[s], the window improves by shifting right; otherwise it doesn’t. So the predicate “window starting at s is not worse than any window starting to its right” is monotone in s, and the standard halving finds the best start in $O(\log(n-k))$ window comparisons — each comparison $O(1)$. Total: $O(\log(n-k))$, beating the heap’s $O(n \log k)$ and the sort’s $O(n \log n)$.

Approach 1 — Binary search on the window start (optimal)

/**
 * @param arr the sorted array to search in
 * @param k   the number of closest elements to return
 * @param x   the target value to be close to
 * @return    the k closest elements, in sorted order
 */
fun findClosestElements(arr: IntArray, k: Int, x: Int): List<Int> {
    // The optimal window starts somewhere in [0, arr.size - k].
    var (left, right) = 0 to arr.size - k

    while (left < right) {
        val mid = left + (right - left) / 2
        // Compare the left edge of window(mid) with the element just past its right edge.
        // If x - arr[mid] > arr[mid + k] - x, then arr[mid + k] is closer to x than
        // arr[mid] is, so shifting the window right improves it -> move left past mid.
        when {
            x - arr[mid] > arr[mid + k] - x -> left = mid + 1
            else                             -> right = mid
        }
    }
    return arr.toList().subList(left, left + k)
}

import java.util.*;

public class FindKClosestElements {
    /**
     * @param arr the sorted array to search in
     * @param k   the number of closest elements to return
     * @param x   the target value to be close to
     * @return    the k closest elements, in sorted order
     */
    public List<Integer> findClosestElements(int[] arr, int k, int x) {
        int left = 0, right = arr.length - k;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (x - arr[mid] > arr[mid + k] - x) {
                left = mid + 1;          // right edge is closer -> shift window right
            } else {
                right = mid;             // keep window at or left of mid
            }
        }
        List<Integer> result = new ArrayList<>();
        for (int i = left; i < left + k; i++) result.add(arr[i]);
        return result;
    }
}

#include <vector>

class FindKClosestElements {
public:
    /**
     * @param arr the sorted array to search in
     * @param k   the number of closest elements to return
     * @param x   the target value to be close to
     * @return    the k closest elements, in sorted order
     */
    std::vector<int> findClosestElements(const std::vector<int>& arr, int k, int x) {
        int left = 0, right = (int)arr.size() - k;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (x - arr[mid] > arr[mid + k] - x) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return std::vector<int>(arr.begin() + left, arr.begin() + left + k);
    }
};

def find_closest_elements(arr: list[int], k: int, x: int) -> list[int]:
    """
    @param arr: the sorted array to search in
    @param k:   the number of closest elements to return
    @param x:   the target value to be close to
    @return:    the k closest elements, in sorted order
    """
    left, right = 0, len(arr) - k
    while left < right:
        mid = left + (right - left) // 2
        # arr[mid + k] closer to x than arr[mid]? Then shift the window right.
        if x - arr[mid] > arr[mid + k] - x:
            left = mid + 1
        else:
            right = mid
    return arr[left:left + k]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param arr the sorted array to search in
    /// @param k   the number of closest elements to return
    /// @param x   the target value to be close to
    /// @return    the k closest elements, in sorted order
    pub fn find_closest_elements(arr: Vec<i32>, k: i32, x: i32) -> Vec<i32> {
        let k = k as usize;
        let (mut left, mut right) = (0usize, arr.len() - k);
        while left < right {
            let mid = left + (right - left) / 2;
            if x - arr[mid] > arr[mid + k] - x {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        arr[left..left + k].to_vec()
    }
}
}

Approach 2 — Max-heap of size k (the classic follow-up)

Works on unsorted arrays too. Keep a heap of the k best so far; when it exceeds k, evict the worst. “Worst” = largest distance, ties broken toward the larger value (so that the smaller value survives ties — exactly the tie rule).

/**
 * @param arr the array (sorted or not) to search in
 * @param k   the number of closest elements to return
 * @param x   the target value to be close to
 * @return    the k closest elements, in sorted order
 */
fun findClosestElementsHeap(arr: IntArray, k: Int, x: Int): List<Int> {
    // Max-heap on (distance from x, value): comparator returns positive when b is "bigger" = worse.
    val priorityQueue = PriorityQueue<Int> { a, b ->
        val diffA = abs(a - x)
        val diffB = abs(b - x)
        if (diffA == diffB) b - a else diffB - diffA
    }
    for (element in arr) {
        priorityQueue.offer(element)
        if (priorityQueue.size > k) priorityQueue.poll()   // evict the worst
    }
    return priorityQueue.sorted()
}

import java.util.*;

public class FindKClosestElementsHeap {
    /**
     * @param arr the array (sorted or not) to search in
     * @param k   the number of closest elements to return
     * @param x   the target value to be close to
     * @return    the k closest elements, in sorted order
     */
    public List<Integer> findClosestElements(int[] arr, int k, int x) {
        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> {
            int da = Math.abs(a - x), db = Math.abs(b - x);
            return da == db ? b - a : db - da;   // max-heap on (distance, value)
        });
        for (int element : arr) {
            pq.offer(element);
            if (pq.size() > k) pq.poll();
        }
        List<Integer> result = new ArrayList<>(pq);
        Collections.sort(result);
        return result;
    }
}

#include <vector>
#include <queue>
#include <algorithm>

class FindKClosestElementsHeap {
public:
    /**
     * @param arr the array (sorted or not) to search in
     * @param k   the number of closest elements to return
     * @param x   the target value to be close to
     * @return    the k closest elements, in sorted order
     */
    std::vector<int> findClosestElements(const std::vector<int>& arr, int k, int x) {
        auto worse = [x](int a, int b) {
            int da = std::abs(a - x), db = std::abs(b - x);
            return da == db ? a < b : da < db;   // max-heap: "less" means "worse" on top
        };
        std::priority_queue<int, std::vector<int>, decltype(worse)> pq(worse);
        for (int element : arr) {
            pq.push(element);
            if ((int)pq.size() > k) pq.pop();
        }
        std::vector<int> result;
        while (!pq.empty()) { result.push_back(pq.top()); pq.pop(); }
        std::sort(result.begin(), result.end());
        return result;
    }
};

def find_closest_elements_heap(arr: list[int], k: int, x: int) -> list[int]:
    """
    @param arr: the array (sorted or not) to search in
    @param k:   the number of closest elements to return
    @param x:   the target value to be close to
    @return:    the k closest elements, in sorted order
    """
    import heapq
    heap: list[tuple[int, int]] = []            # max-heap keyed by (-distance, -value)
    for element in arr:
        heapq.heappush(heap, (-abs(element - x), -element))
        if len(heap) > k:
            heapq.heappop(heap)                 # evict the worst
    return sorted(-neg_value for _, neg_value in heap)

#![allow(unused)]
fn main() {
use std::collections::BinaryHeap;
use std::cmp::Ordering;

impl Solution {
    /// @param arr the array (sorted or not) to search in
    /// @param k   the number of closest elements to return
    /// @param x   the target value to be close to
    /// @return    the k closest elements, in sorted order
    pub fn find_closest_elements_heap(arr: Vec<i32>, k: i32, x: i32) -> Vec<i32> {
        // Reverse wrapper: BinaryHeap pops the LARGEST (distance, value), which is the worst.
        #[derive(Eq, PartialEq)]
        struct Elem(i32, i32);
        impl Ord for Elem {
            fn cmp(&self, other: &Self) -> Ordering {
                (self.0, self.1).cmp(&(other.0, other.1))
            }
        }
        impl PartialOrd for Elem { fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) } }

        let mut heap = BinaryHeap::new();
        for &element in &arr {
            heap.push(Elem((element - x).abs(), element));
            if heap.len() > k as usize {
                heap.pop();
            }
        }
        let mut result: Vec<i32> = heap.into_iter().map(|e| e.1).collect();
        result.sort_unstable();
        result
    }
}
}

Heap complexity: $O(n \log k)$ time ($n$ pushes, at most $n$ pops), $O(k)$ space. Binary search complexity: $O(\log(n-k))$ time, $O(1)$ extra space (plus the $O(k)$ output). When arr is sorted — as the problem guarantees — the binary search is strictly better; when arr isn’t sorted, the heap is the weapon.

Dry run (binary search approach)

Input: arr = [1, 2, 3, 4, 5], k = 4, x = 3. Start window index space: $[0, 1]$ (only 2 possible starts):

left=0  right=1  mid=0
  x - arr[0] = 3 - 1 = 2
  arr[0+4] - x = arr[4] - 3 = 5 - 3 = 2
  2 > 2 is FALSE  -> right = 0
left=0  right=0  -> return arr[0..4] = [1, 2, 3, 4] ✓

Tie rule in action: window [1,2,3,4] (distances 2,1,0,1) ties window [2,3,4,5] (distances 1,0,1,2) on total distance; the tie-break prefers the smaller left edge, which is exactly what the > (strict) comparison in the code does.

Input: arr = [1, 2, 3, 4, 5], k = 4, x = -1. Window start space $[0, 1]$:

left=0  right=1  mid=0
  x - arr[0] = -1 - 1 = -2
  arr[4] - x = 5 - (-1) = 6
  -2 > 6 is FALSE -> right = 0
return [1, 2, 3, 4] ✓   (leftmost window wins)

Input: arr = [1,1,1,10,10,10], k = 1, x = 9. Window start space $[0, 5]$:

left=0  right=5  mid=2
  x - arr[2] = 9 - 1 = 8
  arr[3] - x = 10 - 9 = 1
  8 > 1 TRUE -> left = 3
left=3  right=5  mid=4
  x - arr[4] = 9 - 10 = -1
  arr[5] - x = 10 - 9 = 1
  -1 > 1 FALSE -> right = 4
left=3  right=4  mid=3
  x - arr[3] = 9 - 10 = -1
  arr[4] - x = 10 - 9 = 1
  -1 > 1 FALSE -> right = 3
return arr[3..4] = [10] ✓

Complexity

Binary search approach. The window-start space has $n - k + 1$ candidates; halving needs $\lceil \log_2(n-k+1) \rceil$ comparisons, each $O(1)$:

$$ T(n) = O(\log(n - k)), \qquad S(n) = O(k) \text{ (the output)} $$

Heap approach. Each of the $n$ elements is pushed once ($O(\log k)$) and popped at most once ($O(\log k)$):

$$ T(n) = O(n \log k), \qquad S(n) = O(k) $$

Variants & follow-ups

• K Closest Points to Origin (src/main/kotlin/heap/) — same heap pattern, Euclidean distance instead of absolute difference; “sorted” doesn’t apply, so the heap (or quickselect) is the answer.
• Interview follow-up: “Prove the answer is a contiguous window.” Use the ordering lemma: for sorted $a \le b \le c$ and any $x$, $|b - x| \le \max(|a - x|, |c - x|)$ — an interior element can’t be the farthest. Therefore the optimal $k$-set has no “holes”.
• Interview follow-up: “Why > and not >=?” The strict comparison sends equal-distance cases to right = mid, biasing the search left — exactly the required smaller-value tie-break.

1.5 Find Minimum In Rotated Sorted Array

Source: src/main/kotlin/binarysearch/FindMinimumInRotatedSortedArray.kt Pattern: rotated-array pivot · Core page

The Problem

A sorted array was rotated at some unknown pivot (e.g. [0,1,2,4,5,6,7] became [4,5,6,7,0,1,2]). All elements are distinct. Find the minimum element in $O(\log n)$.

• Constraints: $1 \le n \le 5000$, all values distinct.

Examples

Input:  nums = [3, 4, 5, 1, 2]
Output: 1

Input:  nums = [4, 5, 6, 7, 0, 1, 2]
Output: 0

Input:  nums = [11, 13, 15, 17]
Output: 11        (rotation by 0 — array is still sorted)

Input:  nums = [2, 1]
Output: 1

Intuition — the “two sorted runs” picture

A rotated sorted array is two sorted runs glued together:

[4, 5, 6, 7, | 0, 1, 2]
 \__run 1__/  \_run 2_/
               ^
            minimum = start of run 2

Everything in run 1 is larger than everything in run 2 (because the array was sorted before rotation). Now watch what happens at nums[mid]:

• If nums[mid] > nums[right], then mid sits in run 1, and the minimum is strictly to its right → left = mid + 1.
• Otherwise (nums[mid] < nums[right], the only other case since all values are distinct), mid sits in run 2, and the minimum is at mid or to its left → right = mid.

This is Template A from 1.0 wearing a rotated costume: the predicate is “$nums[mid]$ is in run 2”, which is monotone (run 1 first, then run 2 — never interleaved). We’re finding the first element of run 2.

The edge nums[mid] == nums[right] cannot happen here (distinct values), which is exactly why the duplicate-tolerant variant (1.16) needs extra work.

Approach 1 — Linear scan

Scan for the first element smaller than its predecessor. $O(n)$ time. Works, but the problem’s $O(\log n)$ requirement (and the sorted structure) demands the binary version.

Approach 2 — Binary search on the pivot (optimal)

/**
 * @param nums the rotated sorted array (distinct values)
 * @return     the minimum element
 */
fun findMin(nums: IntArray): Int {
    var (left, right) = 0 to nums.size - 1

    while (left < right) {
        val mid = left + (right - left) / 2
        when {
            // mid is in the "big" left run -> the minimum is strictly to the right
            nums[mid] > nums[right] -> left = mid + 1
            // mid is in the "small" right run -> minimum is at or left of mid
            else                    -> right = mid
        }
    }
    return nums[left]
}

public class FindMinimumInRotatedSortedArray {
    /**
     * @param nums the rotated sorted array (distinct values)
     * @return     the minimum element
     */
    public int findMin(int[] nums) {
        int left = 0, right = nums.length - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > nums[right]) {
                left = mid + 1;          // mid is in the big left run
            } else {
                right = mid;             // mid is in the small right run
            }
        }
        return nums[left];
    }
}

#include <vector>

class FindMinimumInRotatedSortedArray {
public:
    /**
     * @param nums the rotated sorted array (distinct values)
     * @return     the minimum element
     */
    int findMin(const std::vector<int>& nums) {
        int left = 0, right = (int)nums.size() - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > nums[right]) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return nums[left];
    }
};

def find_min(nums: list[int]) -> int:
    """
    @param nums: the rotated sorted array (distinct values)
    @return:     the minimum element
    """
    left, right = 0, len(nums) - 1
    while left < right:
        mid = left + (right - left) // 2
        if nums[mid] > nums[right]:
            left = mid + 1          # mid is in the big left run
        else:
            right = mid             # mid is in the small right run
    return nums[left]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the rotated sorted array (distinct values)
    /// @return     the minimum element
    pub fn find_min(nums: Vec<i32>) -> i32 {
        let (mut left, mut right) = (0usize, nums.len() - 1);
        while left < right {
            let mid = left + (right - left) / 2;
            if nums[mid] > nums[right] {
                left = mid + 1;          // mid is in the big left run
            } else {
                right = mid;             // mid is in the small right run
            }
        }
        nums[left]
    }
}
}

Dry run

Input: nums = [3, 4, 5, 1, 2]

left=0  right=4  mid=2  nums[2]=5  nums[4]=2  5 > 2 -> left=3   (5 is in the big run; min is right of it)
left=3  right=4  mid=3  nums[3]=1  nums[4]=2  1 > 2? NO -> right=3
left=3  right=3  -> return nums[3] = 1 ✓

Input: nums = [11, 13, 15, 17] (no rotation)

left=0  right=3  mid=1  nums[1]=13  nums[3]=17  13 > 17? NO -> right=1
left=0  right=1  mid=0  nums[0]=11  nums[1]=13  11 > 13? NO -> right=0
return nums[0] = 11 ✓   (the "rotation by zero" case lands on the first element)

Input: nums = [2, 1] (rotation of a 2-element array)

left=0  right=1  mid=0  nums[0]=2  nums[1]=1  2 > 1 -> left=1
left=1  right=1  -> return nums[1] = 1 ✓

Why the > comparison against nums[right] (not nums[left])? Compare with the “find the rotation point” version that tests nums[mid] > nums[first]. The right-anchored version is safe even when the array is not rotated at all: in a fully sorted array nums[mid] > nums[right] is always false, so right collapses leftward onto index 0 — the minimum. The first-anchored version would instead collapse toward the rotation point, which is index 0 too, but it needs an extra “did we rotate?” check. Anchoring on right is the cleaner invariant.

Follow-up: find the MAXIMUM (the rotation peak)

The notes’ version asks the mirror question: find the largest element in a rotated sorted array. The same “two sorted runs” picture (the intuition above) gives a two-liner: if not rotated, the answer is the last element; else locate the rotation point (the minimum) with the loop above, and the maximum is the element just before it (wrapping around):

fun findLargestInRotated(arr: IntArray): Int {
    require(arr.isNotEmpty()) { "Array can't be empty" }

    // Not rotated: the largest element is the right-most one
    if (arr[0] < arr[arr.lastIndex]) return arr[arr.lastIndex]

    // Find the rotation point (the minimum) with the same right-anchored loop
    var (left, right) = 0 to arr.lastIndex
    while (left < right) {
        val mid = left + (right - left) / 2
        if (arr[mid] > arr[right]) left = mid + 1   // min is in the right half
        else right = mid
    }
    // The max is the element just before the minimum (wrapping)
    return arr[(left - 1 + arr.size) % arr.size]
}

The arr[0] < arr[last] early return is the notes’ “prune early” trick: in a non-rotated array, the last element is always greater than the first. Otherwise the min-index left from Approach 2 locates the peak by adjacency.

Complexity

Time. Each iteration halves the window:

$$ T(n) = O(\log n) $$

Space. $O(1)$ auxiliary.

Variants & follow-ups

• Search In Rotated Sorted Array (1.17) — same two-run structure, but you must also decide which run the target is in.
• Search In Rotated Sorted Array II (1.16) — duplicates break the >/< trichotomy; the fix is a dedup step that can degrade the worst case to $O(n)$.
• Interview follow-up: “Find the rotation index (not the value).” The same loop returns left, and the rotation index is left (0 if not rotated).
• Interview follow-up: “What changes with duplicates?” The == case (e.g. [2,2,2,0,2]) makes it impossible to know which run mid is in — see 1.16 for the standard handling.

1.6 Find Peak Element

Source: src/main/kotlin/binarysearch/FindPeakElement.kt Pattern: monotone slope descent · Core page

The Problem

A peak in an array is an element that is strictly greater than its neighbors. An array may have multiple peaks; return the index of any peak. You may assume nums[-1] = nums[n] = -∞ (the boundaries count as “not greater than anything”).

• Constraints: $1 \le n \le 10^4$, values distinct-ish (the algorithm works with duplicates too).

Examples

Input:  nums = [1, 2, 3, 1]
Output: 2                  (nums[2] = 3 > 2 and 3 > 1)

Input:  nums = [1, 2, 1, 3, 5, 6, 4]
Output: 5                  (nums[5] = 6 is a peak; index 1 is also a peak — either is accepted)

Input:  nums = [1, 2, 3]   (monotone increasing)
Output: 2                  (3 > 2 and nums[3] = -∞)

Input:  nums = [3, 2, 1]   (monotone decreasing)
Output: 0                  (3 > -∞ and 3 > 2)

Intuition — “climb the mountain”

The naive approach scans for any element greater than both neighbors: $O(n)$. But there’s a directional structure: at any position mid, compare nums[mid] with nums[mid+1]:

• nums[mid] < nums[mid+1] — the array is rising at mid. Somewhere to the right there must be a peak. Why? The sequence starting at mid+1 either keeps rising forever — in which case the last element is a peak (its right neighbor is $-\infty$) — or it eventually falls, and the first fall is a peak. Either way: a peak exists strictly to the right.
• nums[mid] > nums[mid+1] — the array is falling at mid. Symmetrically, a peak exists at mid or to its left (walk left and the sequence either keeps falling — first element is a peak since its left neighbor is $-\infty$ — or turns up, and the turn is a peak).

So the comparison nums[mid] vs nums[mid+1] tells us which half provably contains a peak. That’s a monotone-ish predicate (once the array starts descending, it’s “peaky on the left”) — Template A again, but with a geometric argument instead of a value ordering. This is sometimes called “binary search on the slope.”

The boundary assumption $nums[-1] = nums[n] = -\infty$ is what makes the “must exist” arguments airtight. Without it, a monotone array would have no peak.

Approach 1 — Linear scan

Check every element against its two neighbors. $O(n)$. The classic $O(\log n)$ requirement is the whole point.

Approach 2 — Slope-descent binary search (optimal)

/**
 * @param nums the input array (boundaries count as -infinity)
 * @return     the index of any peak element
 */
fun findPeakElement(nums: IntArray): Int {
    var left = 0
    var right = nums.lastIndex

    while (left < right) {
        val mid = left + (right - left) / 2
        if (nums[mid] > nums[mid + 1]) {
            right = mid        // falling here -> peak at or left of mid
        } else {
            left = mid + 1     // rising here -> peak strictly right of mid
        }
    }
    return left
}

public class FindPeakElement {
    /**
     * @param nums the input array (boundaries count as -infinity)
     * @return     the index of any peak element
     */
    public int findPeakElement(int[] nums) {
        int left = 0, right = nums.length - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > nums[mid + 1]) {
                right = mid;      // falling here -> peak at or left of mid
            } else {
                left = mid + 1;   // rising here -> peak strictly right of mid
            }
        }
        return left;
    }
}

#include <vector>

class FindPeakElement {
public:
    /**
     * @param nums the input array (boundaries count as -infinity)
     * @return     the index of any peak element
     */
    int findPeakElement(const std::vector<int>& nums) {
        int left = 0, right = (int)nums.size() - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > nums[mid + 1]) right = mid;
            else left = mid + 1;
        }
        return left;
    }
};

def find_peak_element(nums: list[int]) -> int:
    """
    @param nums: the input array (boundaries count as -infinity)
    @return:     the index of any peak element
    """
    left, right = 0, len(nums) - 1
    while left < right:
        mid = left + (right - left) // 2
        if nums[mid] > nums[mid + 1]:
            right = mid          # falling here -> peak at or left of mid
        else:
            left = mid + 1       # rising here -> peak strictly right of mid
    return left

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the input array (boundaries count as -infinity)
    /// @return     the index of any peak element
    pub fn find_peak_element(nums: Vec<i32>) -> i32 {
        let (mut left, mut right) = (0usize, nums.len() - 1);
        while left < right {
            let mid = left + (right - left) / 2;
            if nums[mid] > nums[mid + 1] {
                right = mid;          // falling here -> peak at or left of mid
            } else {
                left = mid + 1;       // rising here -> peak strictly right of mid
            }
        }
        left as i32
    }
}
}

4. FindPeakElementBetterSolution.kt — boundary-safe peak

1.6 documents the standard binary-search peak; this file’s “better” claim is explicit boundary handling — neighbors default to Int.MIN_VALUE at the edges:

class FindPeakElementBetterSolution {
    fun findPeakElement(nums: IntArray): Int? {
        if (nums.isEmpty()) return null

        var (left, right) = 0 to nums.size - 1

        while (left < right) {
            val mid = left + (right - left) / 2

            // Safely handle boundaries
            val leftNeighbor = if (mid > 0) nums[mid - 1] else Int.MIN_VALUE
            val rightNeighbor = if (mid < nums.size - 1) nums[mid + 1] else Int.MIN_VALUE

            when {
                nums[mid] > leftNeighbor && nums[mid] > rightNeighbor -> return mid   // peak
                nums[mid] < rightNeighbor -> left = mid + 1                            // go right
                else -> right = mid                                                    // go left
            }
        }
        return left
    }
}

What’s cool: the Int.MIN_VALUE neighbors make the boundary cells valid peaks (a single-element array’s only element is a peak); the when reads as the three-way decision; and Int? return explicitly signals “empty input”. The three-branch structure also avoids 1.7’s separate “safe boundaries” page — this file is that page’s idea in one method.

Dry run

Input: nums = [1, 2, 3, 1]

left=0  right=3  mid=1  nums[1]=2  nums[2]=3  2 > 3? NO -> left=2   (rising; peak to the right)
left=2  right=3  mid=2  nums[2]=3  nums[3]=1  3 > 1? YES -> right=2
left=2  right=2  -> return 2 ✓   (nums[2] = 3 is the peak)

Input: nums = [1, 2, 3] (monotone rising — peak is the last element)

left=0  right=2  mid=1  nums[1]=2  nums[2]=3  2 > 3? NO -> left=2
left=2  right=2  -> return 2 ✓   (last element; its right neighbor is -infinity)

Input: nums = [3, 2, 1] (monotone falling — peak is the first element)

left=0  right=2  mid=1  nums[1]=2  nums[2]=1  2 > 1? YES -> right=1
left=0  right=1  mid=0  nums[0]=3  nums[1]=2  3 > 2? YES -> right=0
left=0  right=0  -> return 0 ✓   (first element; its left neighbor is -infinity)

The two monotone cases are worth tracing twice — they’re the proof that a peak always exists on the chosen side, and they’re exactly what an interviewer will probe.

Complexity

Time.

$$ T(n) = O(\log n) $$

Space. $O(1)$.

Variants & follow-ups

• 1.13 — the same slope descent, but the array is unimodal (strictly rises then strictly falls) so there’s exactly one peak.
• 1.20 — mirror image: follow the descending direction to find a local minimum.
• 1.7 — a boundary-safe variant that reads both neighbors (works when you can’t rely on the $±\infty$ convention).
• Find Peak Element II (2D) — the same “climb the slope” idea generalized to a matrix: find the max of the middle column, then recurse on the half that slopes up. $O(n \log m)$ instead of $O(nm)$.
• Interview follow-up: “Prove a peak exists in a non-empty array.” The element with the maximum value is always a peak (it’s ≥ both neighbors; with strict inequalities and distinct values it’s strictly greater). Existence is free — the search just needs to find one without scanning.

1.7 Find Peak Element (Safe Boundaries)

Source: src/main/kotlin/binarysearch/FindPeakElementBetterSolution.kt Pattern: monotone slope descent, boundary-safe · Variant page

The Problem

Identical to 1.6 — return the index of any peak — but the implementation here makes no assumption about reading nums[mid + 1] at the boundary: it checks both neighbors with explicit bounds guards, and early-returns the moment it finds a peak (no need to converge the window).

Intuition

The two styles differ in when they certify a peak:

• 1.6-style (window convergence): never early-returns; it relies on the invariant “the window provably contains a peak” and reads only nums[mid] vs nums[mid+1]. Requires trusting the $-\infty$ boundary convention.
• This page (explicit check): at each mid, read both neighbors (with Int.MIN_VALUE at the edges) and check the definition of a peak directly: nums[mid] > left && nums[mid] > right. If yes — return. If not, use the slope to decide which half still provably contains a peak.

The explicit version is more robust to rephrasings of the problem (e.g. “the array might be monotone; boundaries are the answer”) and it self-documents the peak definition. The cost is reading two neighbors instead of one — still $O(1)$ per step, so complexity is unchanged.

Approach — boundary-safe slope descent

/**
 * @param nums the input array (boundaries treated as -infinity)
 * @return     the index of any peak element, or null if nums is empty
 */
fun findPeakElement(nums: IntArray): Int? {
    if (nums.isEmpty()) return null

    var (left, right) = 0 to nums.size - 1

    while (left < right) {
        val mid = left + (right - left) / 2

        // Read both neighbors with explicit sentinel values at the edges.
        val leftNeighbor  = if (mid > 0) nums[mid - 1] else Int.MIN_VALUE
        val rightNeighbor = if (mid < nums.size - 1) nums[mid + 1] else Int.MIN_VALUE

        when {
            // Direct hit: strictly greater than both neighbors.
            nums[mid] > leftNeighbor && nums[mid] > rightNeighbor -> return mid
            // Rising to the right -> a peak exists strictly to the right.
            nums[mid] < rightNeighbor -> left = mid + 1
            // Falling to the left -> a peak exists at or to the left.
            else -> right = mid
        }
    }
    return left
}

public class FindPeakElementSafe {
    /**
     * @param nums the input array (boundaries treated as -infinity)
     * @return     the index of any peak element, or -1 if nums is empty
     */
    public int findPeakElement(int[] nums) {
        if (nums.length == 0) return -1;
        int left = 0, right = nums.length - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            int leftNeighbor  = mid > 0 ? nums[mid - 1] : Integer.MIN_VALUE;
            int rightNeighbor = mid < nums.length - 1 ? nums[mid + 1] : Integer.MIN_VALUE;
            if (nums[mid] > leftNeighbor && nums[mid] > rightNeighbor) return mid;
            if (nums[mid] < rightNeighbor) left = mid + 1;
            else right = mid;
        }
        return left;
    }
}

#include <vector>
#include <climits>

class FindPeakElementSafe {
public:
    /**
     * @param nums the input array (boundaries treated as -infinity)
     * @return     the index of any peak element, or -1 if nums is empty
     */
    int findPeakElement(const std::vector<int>& nums) {
        if (nums.empty()) return -1;
        int left = 0, right = (int)nums.size() - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            int leftNeighbor  = mid > 0 ? nums[mid - 1] : INT_MIN;
            int rightNeighbor = mid < (int)nums.size() - 1 ? nums[mid + 1] : INT_MIN;
            if (nums[mid] > leftNeighbor && nums[mid] > rightNeighbor) return mid;
            if (nums[mid] < rightNeighbor) left = mid + 1;
            else right = mid;
        }
        return left;
    }
};

def find_peak_element(nums: list[int]) -> int:
    """
    @param nums: the input array (boundaries treated as -infinity)
    @return:     the index of any peak element, or -1 if nums is empty
    """
    if not nums:
        return -1
    left, right = 0, len(nums) - 1
    while left < right:
        mid = left + (right - left) // 2
        left_neighbor  = nums[mid - 1] if mid > 0 else float("-inf")
        right_neighbor = nums[mid + 1] if mid < len(nums) - 1 else float("-inf")
        if nums[mid] > left_neighbor and nums[mid] > right_neighbor:
            return mid                     # direct hit
        if nums[mid] < right_neighbor:
            left = mid + 1                 # rising -> peak to the right
        else:
            right = mid                    # falling -> peak at or left
    return left

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the input array (boundaries treated as -infinity)
    /// @return     the index of any peak element, or -1 if nums is empty
    pub fn find_peak_element(nums: Vec<i32>) -> i32 {
        if nums.is_empty() {
            return -1;
        }
        let (mut left, mut right) = (0usize, nums.len() - 1);
        while left < right {
            let mid = left + (right - left) / 2;
            let left_neighbor  = if mid > 0 { nums[mid - 1] } else { i32::MIN };
            let right_neighbor = if mid + 1 < nums.len() { nums[mid + 1] } else { i32::MIN };
            if nums[mid] > left_neighbor && nums[mid] > right_neighbor {
                return mid as i32;
            }
            if nums[mid] < right_neighbor {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        left as i32
    }
}
}

Dry run

Input: nums = [1, 2, 1, 3, 5, 6, 4]

left=0  right=6  mid=3  nums[3]=3, L=1, R=5
  3 > 1 && 3 > 5? NO  |  3 < 5 (rising) -> left=4
left=4  right=6  mid=5  nums[5]=6, L=5, R=4
  6 > 5 && 6 > 4? YES -> return 5 ✓

Input: nums = [1, 2, 3] (monotone rising — peak at the end)

left=0  right=2  mid=1  nums[1]=2, L=1, R=3
  2 > 1 && 2 > 3? NO  |  2 < 3 -> left=2
left=2  right=2  -> return 2 ✓   (the loop never probes the boundary read; it converges)

Input: nums = [3, 2, 1] (monotone falling — peak at the start)

left=0  right=2  mid=1  nums[1]=2, L=3, R=1
  2 > 3 && 2 > 1? NO  |  2 < 1? NO -> right=1
left=0  right=1  mid=0  nums[0]=3, L=-inf, R=2
  3 > -inf && 3 > 2? YES -> return 0 ✓   (the left sentinel kicks in exactly here)

The last trace is the reason this variant exists: the sentinel makes the boundary element a valid, provable peak without needing the abstract “$-\infty$” convention from the problem statement.

Complexity

Time. $O(\log n)$ — at most two array reads per halving step.

Space. $O(1)$.

Variants & follow-ups

• 1.6 — the minimal one-neighbor version; fewer reads, more reliance on the boundary convention.
• 1.20 — the same boundary-safe style, mirrored for valleys (uses Int.MAX_VALUE sentinels).
• Interview follow-up: “Return all peaks.” Binary search doesn’t help; you need an $O(n)$ scan (every element can be a peak, e.g. a sawtooth). Knowing when the trick doesn’t apply is part of the answer.

1.8 First Bad Version

Source: src/main/kotlin/binarysearch/FirstBadVersion.kt Pattern: lower bound via an API predicate · Core page

The Problem

You are a product manager leading a team developing a product. The latest version n has a bug; a previous version may have introduced it. Once a version is bad, all subsequent versions are bad:

versions:  1  2  3  4  5  6  7
quality:   G  G  B  B  B  B  B
                  ^
             first bad = 3

You have an API isBadVersion(version) that returns true iff that version is bad. Find the first bad version, minimizing the number of API calls.

• Constraints: $1 \le n \le 2^{31} - 1$ — a linear scan of a billion versions is disqualifying; the API-call budget must be logarithmic.

Intuition

The “badness” predicate $P(v)$ = isBadVersion(v) is monotone by definition: good, good, …, good, bad, bad, …, bad — exactly one flip. This is the textbook instance of the Binary Search Theorem: find the first true in $[1, n]$. Template A from 1.0, verbatim, with the array access replaced by the API call.

This problem is the canonical “binary search on a predicate” — no array exists at all. If you can solve this, you can solve any “first true” problem (Koko, Capacity, House Robber IV all reduce to it with a fancier predicate).

Approach 1 — Linear scan

Call isBadVersion(i) for i = 1..n, return the first true. $O(n)$ API calls — 2 billion in the worst case. The problem exists to teach you not to do this.

Approach 2 — Binary search on the predicate (optimal)

/**
 * @param n the total number of versions, numbered 1..n
 * @return  the first version that is bad (isBadVersion returns true)
 */
override fun firstBadVersion(n: Int): Int {
    var start = 1
    var end = n

    while (start < end) {
        val mid = start + (end - start) / 2
        when {
            isBadVersion(mid) -> end = mid        // mid is bad -> first bad is at or before mid
            else              -> start = mid + 1  // mid is good -> first bad is strictly after mid
        }
    }
    return start
}

public class FirstBadVersion {
    /* Stub of the LeetCode API. In the real problem this is provided. */
    private boolean isBadVersion(int version) { return version >= 3; }

    /**
     * @param n the total number of versions, numbered 1..n
     * @return  the first version that is bad (isBadVersion returns true)
     */
    public int firstBadVersion(int n) {
        int start = 1, end = n;
        while (start < end) {
            int mid = start + (end - start) / 2;   // overflow-safe midpoint
            if (isBadVersion(mid)) {
                end = mid;                        // mid is bad -> first bad is at or before mid
            } else {
                start = mid + 1;                  // mid is good -> first bad is strictly after mid
            }
        }
        return start;
    }
}

#include <cstdint>

class FirstBadVersion {
    /* Stub of the LeetCode API. In the real problem this is provided. */
    bool isBadVersion(int version) { return version >= 3; }

public:
    /**
     * @param n the total number of versions, numbered 1..n
     * @return  the first version that is bad (isBadVersion returns true)
     */
    int firstBadVersion(int n) {
        int start = 1, end = n;
        while (start < end) {
            int mid = start + (end - start) / 2;
            if (isBadVersion(mid)) {
                end = mid;
            } else {
                start = mid + 1;
            }
        }
        return start;
    }
};

def first_bad_version(n: int, is_bad: callable) -> int:
    """
    @param n:      the total number of versions, numbered 1..n
    @param is_bad: the oracle API; is_bad(v) is True iff v is bad
    @return:       the first version that is bad
    """
    start, end = 1, n
    while start < end:
        mid = start + (end - start) // 2
        if is_bad(mid):
            end = mid            # mid is bad -> first bad is at or before mid
        else:
            start = mid + 1      # mid is good -> first bad is strictly after mid
    return start

#![allow(unused)]
fn main() {
impl Solution {
    /* Stub of the LeetCode API. In the real problem this is provided. */
    fn is_bad_version(version: i32) -> bool { version >= 3 }

    /// @param n the total number of versions, numbered 1..n
    /// @return  the first version that is bad (isBadVersion returns true)
    pub fn first_bad_version(n: i32) -> i32 {
        let (mut start, mut end) = (1i64, n as i64);
        while start < end {
            let mid = start + (end - start) / 2;
            if Self::is_bad_version(mid as i32) {
                end = mid;
            } else {
                start = mid + 1;
            }
        }
        start as i32
    }
}
}

Rust note: start + (end - start) / 2 overflows i32 for $n = 2^{31}-1$ (mid can exceed i32::MAX/2 only via the sum — actually start + (end-start)/2 stays within $[start, end] \subseteq [1, 2^{31}-1]$, which fits — but the explicit (start + end) form would not). The i64 widening shown here is belt-and-suspenders and keeps the code obviously correct. The other languages must use the same overflow-safe form: left + (right - left) / 2, never (left + right) / 2.

Dry run

Input: n = 7, bad versions start at 3 (isBadVersion(v) = v >= 3)

start=1  end=7  mid=4  isBadVersion(4)=true  -> end=4
start=1  end=4  mid=2  isBadVersion(2)=false -> start=3
start=3  end=4  mid=3  isBadVersion(3)=true  -> end=3
start=3  end=3  -> return 3 ✓

Input: n = 5, everything good (isBadVersion(v) = false always)

start=1  end=5  mid=3  false -> start=4
start=4  end=5  mid=4  false -> start=5
start=5  end=5  -> return 5

The algorithm returns n when no version is bad — a sensible “no bug” answer, and exactly what the invariant guarantees (the first true is at the right edge).

Complexity

Time. Each API call halves the range:

$$ T(n) = O(\log n) \text{ API calls} $$

Space. $O(1)$.

Variants & follow-ups

• Guess Number Higher Or Lower (1.9) — same halving, but the oracle returns three answers (-1/0/1) instead of a boolean, so the loop is the exact-match Template B.
• Kth Missing Positive Number (1.11) — “first true” on a derived predicate (missing-count ≥ k).
• Interview follow-up: “The API is flaky and occasionally lies.” Now binary search can converge to the wrong boundary; you’d sample each version multiple times (majority vote) and pay a constant-factor blowup — a nice robustness discussion that shows systems thinking.
• Interview follow-up: “What’s the minimum number of calls for n = 2^31 − 1?” Exactly $\lceil \log_2(2^{31}-1) \rceil = 31$ calls. Say it with the halving identity: $2^{30} < 2^{31}-1 \le 2^{31}$.

1.9 Guess Number Higher Or Lower

Source: src/main/kotlin/binarysearch/GuessNumberHigherOrLower.kt Pattern: exact-match ternary-response search · Core page

The Problem

I pick a secret number in [1, n]. You call an API:

guess(num):
  -1  ->  num is HIGHER than the secret (you guessed too big)
   1  ->  num is LOWER  than the secret (you guessed too small)
   0  ->  num == secret

Find the secret with the fewest calls.

• Constraints: $1 \le n \le 2^{31} - 1$.

Intuition

This is binary search before it was binary search — literally the original “guess a number” game, which is exactly how the technique was described to Knuth’s generation. The oracle’s three answers partition the candidate space into “too high” / “too low” / “hit”, and each non-hit answer halves the space:

• guess(mid) < 0 → secret < mid → end = mid - 1
• guess(mid) > 0 → secret > mid → start = mid + 1
• guess(mid) == 0 → done.

This is Template B (1.0) — exact match, inclusive bounds, three-way comparison — with the array comparison replaced by the oracle. The difference from 1.8 is that the oracle answers direction, not a boolean, so on a hit we return immediately instead of continuing to a boundary.

Approach 1 — Linear guessing

Guess 1, 2, 3, … until the oracle says 0. Up to $2^{31}-1$ calls. The problem’s whole point is that the oracle’s direction feedback lets you discard half the space per call.

Approach 2 — Binary search with the oracle (optimal)

/**
 * @param n the upper bound of the secret range [1, n]
 * @return  the secret number
 */
override fun guessNumber(n: Int): Int {
    var start = 1
    var end = n

    while (start <= end) {
        val mid = start + (end - start) / 2   // overflow-safe midpoint
        val distance = guess(mid)             // -1 too big, 1 too small, 0 hit

        when {
            distance == 0 -> return mid
            distance < 0  -> end = mid - 1    // secret is smaller
            else          -> start = mid + 1  // secret is larger
        }
    }
    return -1   // unreachable for a valid game
}

public class GuessNumberHigherOrLower {
    /* Stub of the LeetCode API: returns -1/0/1 as documented. */
    private int guess(int num) { return Integer.compare(6, num); } // secret = 6

    /**
     * @param n the upper bound of the secret range [1, n]
     * @return  the secret number
     */
    public int guessNumber(int n) {
        int start = 1, end = n;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            int distance = guess(mid);
            if (distance == 0) return mid;
            if (distance < 0) end = mid - 1;     // guessed too big
            else start = mid + 1;                // guessed too small
        }
        return -1;
    }
}

class GuessNumberHigherOrLower {
    /* Stub of the LeetCode API. */
    int guess(int num) { return (6 < num) - (6 > num); }  // secret = 6

public:
    /**
     * @param n the upper bound of the secret range [1, n]
     * @return  the secret number
     */
    int guessNumber(int n) {
        int start = 1, end = n;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            int distance = guess(mid);
            if (distance == 0) return mid;
            if (distance < 0) end = mid - 1;
            else start = mid + 1;
        }
        return -1;
    }
};

def guess_number(n: int, guess: callable) -> int:
    """
    @param n:     the upper bound of the secret range [1, n]
    @param guess: the oracle; guess(num) -> -1 (too big), 1 (too small), 0 (hit)
    @return:      the secret number
    """
    start, end = 1, n
    while start <= end:
        mid = start + (end - start) // 2
        distance = guess(mid)
        if distance == 0:
            return mid
        if distance < 0:
            end = mid - 1        # guessed too big
        else:
            start = mid + 1      # guessed too small
    return -1

#![allow(unused)]
fn main() {
impl Solution {
    /* Stub of the LeetCode API: secret = 6. */
    fn guess(num: i32) -> i32 { (6 < num) as i32 - (6 > num) as i32 }

    /// @param n the upper bound of the secret range [1, n]
    /// @return  the secret number
    pub fn guess_number(n: i32) -> i32 {
        let (mut start, mut end) = (1i64, n as i64);
        while start <= end {
            let mid = start + (end - start) / 2;
            let distance = Self::guess(mid as i32);
            if distance == 0 {
                return mid as i32;
            }
            if distance < 0 {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
        -1
    }
}
}

Dry run

Input: n = 10, secret = 6.

start=1  end=10  mid=5  guess(5)=1  (too small) -> start=6
start=6  end=10  mid=8  guess(8)=-1 (too big)   -> end=7
start=6  end=7   mid=6  guess(6)=0  (hit)       -> return 6 ✓

Three calls to find a secret among 10 candidates. With $n = 10^9$, the bound is $\lceil \log_2 10^9 \rceil = 30$ calls — the difference between “guess a billion numbers” and “guess thirty”.

Complexity

Time. Each non-hit call halves the range:

$$ T(n) = O(\log n) \text{ oracle calls} $$

Space. $O(1)$.

Variants & follow-ups

• First Bad Version (1.8) — boolean oracle; you search a boundary rather than an exact value.
• Find Peak Element (1.6) — the “oracle” is the local slope comparison, and the answer is a position, not a value.
• Interview follow-up: “The secret is a floating-point number; find it to within $\varepsilon$.” Same loop with mid = (start + end) / 2.0 and a while (end - start > eps) condition — complexity becomes $O(\log((R-L)/\varepsilon))$ iterations. The halving math is identical, just with a different “range size.”
• Interview follow-up: “What’s the worst-case number of calls for $n = 2^{31}-1$?” Exactly $\lceil \log_2 2^{31} \rceil = 31$. State it with the identity $2^{31} = 2^{30} \cdot 2$ — the halving argument from Reference §2.

1.10 House Robber IV

Source: src/main/kotlin/binarysearch/HouseRobber_IV.kt Pattern: binary search on the answer + greedy check · Gym page

The Problem

There are n houses in a row; house i holds nums[i] money. You must rob exactly k houses, no two adjacent, and you want to minimize the maximum amount robbed from any single house (the “capability” of the heist).

Formally: choose indices $i_1 < i_2 < \cdots < i_k$ with $i_{j+1} - i_j \ge 2$ minimizing $\max_j nums[i_j]$. Return that minimum capability.

• Constraints: $1 \le k \le \lceil n/2 \rceil$, $1 \le n \le 10^5$.

Examples

Input:  nums = [2, 3, 5, 9], k = 2
Output: 5
Explanation: robbing houses 1 and 3 (values 3, 5) or 2 and 4 (5, 9): min max = max(3,5) = 5.
             Robbing 0 and 2 (2, 5) is also valid: max = 5. Can't do better: any 2-house
             choice with max < 5 must use two houses both < 5 = {2, 3}, but they're adjacent.

Input:  nums = [2, 7, 9, 3, 1], k = 2
Output: 2
Explanation: rob house 0 (2) and house 4 (1): max = 2. The two cheapest non-adjacent.

Intuition — a minimax problem, inverted

“Minimize the maximum” is the smell of binary search on the answer. The direct optimization (“which k houses?”) is combinatorial — $\binom{n}{k}$ choices. But the decision version is trivial:

Decision: can we pick $k$ non-adjacent houses, all with value $\le cap$?

Greedy answer: scan left to right; whenever nums[i] <= cap, rob it and skip the next house (greedy non-adjacent selection). The greedy count is maximal — skipping a rob-able house can never let you rob more — so greedyCount(cap) >= k is exactly “feasible”. And feasibility is monotone in cap: bigger cap → more rob-able houses → never fewer rob-able choices.

So the answer is $\min{cap : \text{greedyCount}(cap) \ge k}$ over $cap \in [\min(nums), \max(nums)]$ — Template A from 1.0 with the feasibility check being the greedy robber. This is the same skeleton as Koko (1.1) and Capacity (1.2): binary search on the answer + O(n) check.

Approach 1 — Brute force

Try every subset of exactly k non-adjacent houses: $\binom{n}{k}$ subsets, each costing $O(k)$ to evaluate → exponential. For $n = 10^5$, hopeless.

Approach 2 — Binary search on capability (optimal)

/**
 * @param nums the money in each house (values are the capability candidates)
 * @param k    the exact number of non-adjacent houses to rob
 * @return     the minimum possible maximum amount robbed from any single house
 */
fun minCapability(nums: IntArray, k: Int): Int {
    var left = nums.minOrNull() ?: 0
    var right = nums.maxOrNull() ?: 0

    /**
     * @param cap the capability ceiling being tested
     * @return    true iff greedy can pick >= k non-adjacent houses each with value <= cap
     */
    fun canRob(cap: Int): Boolean {
        var robbed = 0
        var i = 0
        while (i < nums.size) {
            if (nums[i] <= cap) {
                robbed++
                i += 2          // skip the adjacent house
            } else {
                i++
            }
        }
        return robbed >= k
    }

    while (left < right) {
        val mid = (left + right) / 2   // values fit in Int; (left+right) is safe for n <= 1e5 but
                                       // prefer left + (right-left)/2 for the overflow-proof habit
        if (canRob(mid)) {
            right = mid                 // feasible -> try a smaller capability
        } else {
            left = mid + 1              // infeasible -> need a bigger capability
        }
    }
    return left
}

public class HouseRobberIV {
    /**
     * @param nums the money in each house
     * @param k    the exact number of non-adjacent houses to rob
     * @return     the minimum possible maximum amount robbed from any single house
     */
    public int minCapability(int[] nums, int k) {
        int left = Integer.MAX_VALUE, right = Integer.MIN_VALUE;
        for (int v : nums) { left = Math.min(left, v); right = Math.max(right, v); }

        while (left < right) {
            int mid = left + (right - left) / 2;
            if (canRob(nums, mid, k)) right = mid;
            else left = mid + 1;
        }
        return left;
    }

    /**
     * @param nums the house values
     * @param cap  the capability ceiling being tested
     * @param k    the number of houses required
     * @return     true iff greedy can pick >= k non-adjacent houses with value <= cap
     */
    private boolean canRob(int[] nums, int cap, int k) {
        int robbed = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] <= cap) { robbed++; i++; }   // skip the adjacent house
        }
        return robbed >= k;
    }
}

#include <vector>
#include <algorithm>

class HouseRobberIV {
public:
    /**
     * @param nums the money in each house
     * @param k    the exact number of non-adjacent houses to rob
     * @return     the minimum possible maximum amount robbed from any single house
     */
    int minCapability(const std::vector<int>& nums, int k) {
        auto [lo, hi] = std::minmax_element(nums.begin(), nums.end());
        int left = *lo, right = *hi;

        while (left < right) {
            int mid = left + (right - left) / 2;
            if (canRob(nums, mid, k)) right = mid;
            else left = mid + 1;
        }
        return left;
    }

private:
    /**
     * @param nums the house values
     * @param cap  the capability ceiling being tested
     * @param k    the number of houses required
     * @return     true iff greedy can pick >= k non-adjacent houses with value <= cap
     */
    bool canRob(const std::vector<int>& nums, int cap, int k) {
        int robbed = 0;
        for (int i = 0; i < (int)nums.size(); i++) {
            if (nums[i] <= cap) { robbed++; i++; }
        }
        return robbed >= k;
    }
};

def min_capability(nums: list[int], k: int) -> int:
    """
    @param nums: the money in each house
    @param k:    the exact number of non-adjacent houses to rob
    @return:     the minimum possible maximum amount robbed from any single house
    """
    left, right = min(nums), max(nums)

    def can_rob(cap: int) -> bool:
        """
        @param cap: the capability ceiling being tested
        @return:    True iff greedy can pick >= k non-adjacent houses with value <= cap
        """
        robbed, i = 0, 0
        while i < len(nums):
            if nums[i] <= cap:
                robbed += 1
                i += 2             # skip the adjacent house
            else:
                i += 1
        return robbed >= k

    while left < right:
        mid = left + (right - left) // 2
        if can_rob(mid):
            right = mid            # feasible -> try a smaller capability
        else:
            left = mid + 1         # infeasible -> need a bigger capability
    return left

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the money in each house
    /// @param k    the exact number of non-adjacent houses to rob
    /// @return     the minimum possible maximum amount robbed from any single house
    pub fn min_capability(nums: Vec<i32>, k: i32) -> i32 {
        let (mut left, mut right) = (*nums.iter().min().unwrap(), *nums.iter().max().unwrap());

        while left < right {
            let mid = left + (right - left) / 2;
            if Self::can_rob(&nums, mid, k) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        left
    }

    /// @param nums the house values
    /// @param cap  the capability ceiling being tested
    /// @param k    the number of houses required
    /// @return     true iff greedy can pick >= k non-adjacent houses with value <= cap
    fn can_rob(nums: &[i32], cap: i32, k: i32) -> bool {
        let mut robbed = 0;
        let mut i = 0;
        while i < nums.len() {
            if nums[i] <= cap {
                robbed += 1;
                i += 2;             // skip the adjacent house
            } else {
                i += 1;
            }
        }
        robbed >= k
    }
}
}

Dry run

Input: nums = [2, 3, 5, 9], k = 2. Search space $[2, 9]$:

left=2  right=9  mid=5  canRob(5): rob 2 (i->2), 5 (i->4) -> 2 robbed >= 2 FEASIBLE -> right=5
left=2  right=5  mid=3  canRob(3): rob 2 (i->2), 5? >3 no (i->3), 9? no -> 1 robbed < 2 NOT -> left=4
left=4  right=5  mid=4  canRob(4): rob 2 (i->2), 5>4 no, 9>4 no -> 1 robbed NOT -> left=5
left=5  right=5  -> return 5 ✓

Verify the greedy counts by hand:

Why the greedy is optimal: when nums[i] <= cap, robbing house i and skipping i+1 is never worse than skipping i (which would leave you at i+1, adjacent to nothing robbed yet — strictly fewer options). The greedy count is therefore the maximum number of rob-able houses, so it decides feasibility exactly.

Complexity

Time. $\log_2(\max - \min)$ halving steps × an $O(n)$ greedy pass each:

$$ T(n) = O(n \log V), \qquad V = \max(nums) - \min(nums) \le 10^9 $$

With $n = 10^5$: $\approx 10^5 \times 30 = 3 \times 10^6$ operations. (The values fit in Int, so (left + right) / 2 is safe here, but the overflow-proof left + (right - left) / 2 is the habit to keep.)

Space. $O(1)$.

Variants & follow-ups

• Koko Eating Bananas (1.1) and Capacity to Ship (1.2) — the same “binary search on the answer + greedy feasibility” skeleton; the only difference is what the greedy counts.
• House Robber (classic DP, src/main/kotlin/array/dp/) — same “no two adjacent” constraint but maximizing total value; that’s a DP, not a binary search. Knowing why (no monotone ceiling to search) is the interview gold.
• Interview follow-up: “Why is ‘exactly k’ the same as ‘at least k’ here?” If you can rob $m > k$ non-adjacent houses with max value ≤ cap, you can drop any $m - k$ of them and still have $k$ non-adjacent with max ≤ cap — so feasibility is preserved. That’s why robbed >= k is the right check.

1.11 Kth Missing Positive Number

Source: src/main/kotlin/binarysearch/KThMissingPositiveNumber.kt Pattern: index-space counting + lower bound · Core page

The Problem

Given a strictly increasing array arr of positive integers, find the k-th missing positive integer. The missing integers are counted from 1 upward, excluding the values present in arr.

• Constraints: $1 \le n \le 10^4$, $1 \le k \le 10^4$, strictly increasing arr.

Examples

Input:  arr = [2, 3, 4, 7, 11], k = 5
Output: 9
Explanation: the missing positives are 1, 5, 6, 8, 9, 10, ...; the 5th is 9.

Input:  arr = [1, 2, 3, 4], k = 2
Output: 6
Explanation: missing are 5, 6, 7, ...; the 2nd is 6.

Intuition — count the missing numbers before each position

The naive plan: walk from 1 upward, skipping values in arr, until you’ve seen k missing numbers. $O(n + k)$ — fine for small inputs, but there’s a much sharper structure.

Define the missing count before index i:

$$ \text{missing}(i) = arr[i] - (i + 1) $$

Why? Up to and including arr[i], there are arr[i] positive integers total; of those, i + 1 appear in the array (indices $0..i$). The rest — arr[i] - (i + 1) — are missing.

Since arr is strictly increasing, $\text{missing}(i)$ is non-decreasing in i: each step $i \to i+1$ adds $arr[i+1] - arr[i] - 1 \ge 0$ missing numbers. So the predicate

$$ P(i) = (\text{missing}(i) \ge k) $$

is monotone (false, false, …, true, true, …) — Template A material. Let $i^*$ = the first index with missing(i) ≥ k. Then:

• All missing numbers up to position $i^$ number ≥ k, and just before $i^$ there are < k missing.
• The k-th missing number must be greater than arr[i^*] (it’s past the last present value before the count reaches k)… wait, careful — actually the k-th missing is found within the gap ending at arr[i^*].

Let me redo the accounting precisely. Let $m = \text{missing}(i^)$. Just before index $i^$, missing = missing(i^* - 1) < k. Between arr[i^* - 1] and arr[i^*] there are arr[i^*] - arr[i^* - 1] - 1 missing numbers. The k-th missing overall is the $(k - \text{missing}(i^*-1))$-th missing number in that gap, which equals:

$$ \text{answer} = arr[i^] - (\text{missing}(i^) - k + 1) $$

The neat formula that the code uses instead: answer = i^* + k. Let’s prove it: since missing(i*) = arr[i*] − (i*+1) ≥ k and missing(i*−1) < k, we get

$$ arr[i^] = \text{missing}(i^) + i^* + 1 $$

The k-th missing is missing(i*) − k + 1 positions before arr[i*]:

$$ arr[i^] - (\text{missing}(i^) - k + 1) = (i^* + 1 + \text{missing}(i^)) - \text{missing}(i^) + k - 1 = i^* + k $$

Beautiful: the answer is literally left + k where left is the lower-bound index. And if k > missing(n-1) (the k-th missing is past the end of the array), the loop exits with left == n, and n + k is still correct. The formula handles the “append” case for free.

Approach 1 — Linear scan

Walk i = 1, 2, ..., skip values in arr, count misses until k. $O(n + k)$ time. Works, but when arr = [1, 2, 3, ..., 10000] and k = 10000 you scan ~20,000 numbers while the binary search needs 14 probes.

Approach 2 — Binary search on the missing-count (optimal)

/**
 * @param arr the strictly increasing array of positive integers
 * @param k   the ordinal (1-based) of the missing positive integer to return
 * @return    the k-th missing positive integer
 */
fun findKthPositive(arr: IntArray, k: Int): Int {
    var (left, right) = 0 to arr.size

    while (left < right) {
        val mid = left + (right - left) / 2
        val missingCount = arr[mid] - (mid + 1)   // missing positives before index mid

        when {
            missingCount < k -> left = mid + 1    // not enough missing yet -> look right
            else             -> right = mid       // k-th missing is at or before mid
        }
    }
    return left + k   // the closed-form answer (see intuition for the proof)
}

public class KthMissingPositiveNumber {
    /**
     * @param arr the strictly increasing array of positive integers
     * @param k   the ordinal (1-based) of the missing positive integer to return
     * @return    the k-th missing positive integer
     */
    public int findKthPositive(int[] arr, int k) {
        int left = 0, right = arr.length;
        while (left < right) {
            int mid = left + (right - left) / 2;
            int missingCount = arr[mid] - (mid + 1);
            if (missingCount < k) left = mid + 1;
            else right = mid;
        }
        return left + k;
    }
}

#include <vector>

class KthMissingPositiveNumber {
public:
    /**
     * @param arr the strictly increasing array of positive integers
     * @param k   the ordinal (1-based) of the missing positive integer to return
     * @return    the k-th missing positive integer
     */
    int findKthPositive(const std::vector<int>& arr, int k) {
        int left = 0, right = (int)arr.size();
        while (left < right) {
            int mid = left + (right - left) / 2;
            int missingCount = arr[mid] - (mid + 1);
            if (missingCount < k) left = mid + 1;
            else right = mid;
        }
        return left + k;
    }
};

def find_kth_positive(arr: list[int], k: int) -> int:
    """
    @param arr: the strictly increasing array of positive integers
    @param k:   the ordinal (1-based) of the missing positive integer to return
    @return:    the k-th missing positive integer
    """
    left, right = 0, len(arr)
    while left < right:
        mid = left + (right - left) // 2
        missing = arr[mid] - (mid + 1)     # missing positives before index mid
        if missing < k:
            left = mid + 1
        else:
            right = mid
    return left + k

#![allow(unused)]
fn main() {
impl Solution {
    /// @param arr the strictly increasing array of positive integers
    /// @param k   the ordinal (1-based) of the missing positive integer to return
    /// @return    the k-th missing positive integer
    pub fn find_kth_positive(arr: Vec<i32>, k: i32) -> i32 {
        let (mut left, mut right) = (0usize, arr.len());
        while left < right {
            let mid = left + (right - left) / 2;
            let missing = arr[mid] - (mid as i32 + 1);
            if missing < k {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        left as i32 + k
    }
}
}

Dry run

Input: arr = [2, 3, 4, 7, 11], k = 5

left=0  right=5  mid=2  missing(2) = 4 - 3 = 1  < 5 -> left=3
left=3  right=5  mid=4  missing(4) = 11 - 5 = 6 ≥ 5 -> right=4
left=3  right=4  mid=3  missing(3) = 7 - 4 = 3  < 5 -> left=4
left=4  right=4  -> return 4 + 5 = 9 ✓

Sanity table (the “missing(i)” column is the whole trick):

The 5th missing is 9 — exactly i* + k = 4 + 5. The boundary index 4 is where missing crosses k=5 (6 ≥ 5), and the formula converts the index into the actual value.

Append case: arr = [1, 2, 3, 4], k = 2 — missing counts are all 0, so the loop slides left to 4:

left=0  right=4  mid=2  missing=0 < 2 -> left=3
left=3  right=4  mid=3  missing=0 < 2 -> left=4
return 4 + 2 = 6 ✓

Complexity

Time. The lower-bound search halves an index space of size $n$:

$$ T(n) = O(\log n) $$

Space. $O(1)$.

Variants & follow-ups

• Find First And Last Position (1.3) and Search Insert Position (1.18) — the same lower-bound engine on a different predicate.
• Interview follow-up: “Prove missing(i) is monotone.” $arr[i+1] > arr[i]$ implies $arr[i+1] - (i+2) \ge arr[i] - (i+1)$, since the index increases by exactly 1 while the value increases by ≥ 1.
• Interview follow-up: “What if k can exceed arr.size?” The exclusive upper bound right = arr.size makes the loop terminate with left == n, and n + k is exactly the k-th missing (all n values are present, so the first missing after them is n + 1, the k-th is n + k). The formula covers it with zero extra code.

1.12 Median Of Two Sorted Arrays

Source: src/main/kotlin/binarysearch/MedianOfTwoSortedARrays.kt Pattern: partition-based search · The boss fight of this chapter

The Problem

Given two sorted arrays nums1 (size $m$) and nums2 (size $n$), return the median of the two sorted arrays as a Double, in $O(\log \min(m, n))$ time.

• Constraints: $0 \le m, n \le 10^3$, $m + n \ge 1$.

Examples

Input:  nums1 = [1, 3], nums2 = [2]
Output: 2.0
Explanation: merged = [1, 2, 3]; median = 2.

Input:  nums1 = [1, 2], nums2 = [3, 4]
Output: 2.5
Explanation: merged = [1, 2, 3, 4]; median = (2 + 3) / 2 = 2.5.

Input:  nums1 = [], nums2 = [1]
Output: 1.0

Intuition — binary search on a partition, not on an element

The median splits the merged array into a left half and a right half of equal size (or off-by-one when odd). Key move: we don’t merge — we decide where the split falls inside each array.

Let partitionX = number of elements taken from nums1 into the left half, and partitionY = number taken from nums2. For the halves to be balanced we need:

$$ \text{partitionX} + \text{partitionY} = \frac{m + n + 1}{2} \quad \text{(integer division)} $$

The left half is then max(leftX, leftY) where leftX = nums1[partitionX-1] etc., and the right half is min(rightX, rightY). The arrangement is a valid split exactly when:

$$ \text{leftX} \le \text{rightY} \quad \text{and} \quad \text{leftY} \le \text{rightX} $$

i.e. everything on the left is ≤ everything on the right. If leftX > rightY, we took too many elements from nums1 (its left side pokes past nums2’s right side) → move partitionX left. If leftY > rightX, take more from nums1 → move partitionX right. Either way the fix is a halving step on partitionX — binary search on the partition position.

We binary search over partitionX ∈ [0, m] (searching the smaller array — that’s where the $\log \min(m,n)$ comes from). At the valid split, the median is:

$$ \text{median} = \begin{cases} \max(\text{leftX}, \text{leftY}), & m + n \text{ odd} \[2mm] \dfrac{\max(\text{leftX},\text{leftY}) + \min(\text{rightX},\text{rightY})}{2}, & m + n \text{ even} \end{cases} $$

Boundary cells are handled with sentinels: -∞ for a nonexistent left element, +∞ for a nonexistent right element. This is why the code uses getOrNull(...) ?: Int.MIN_VALUE/MAX_VALUE — the sentinel makes the comparisons work at the edges without special-casing.

Why search the smaller array? partitionY = (m+n+1)/2 - partitionX must stay in [0, n]. If we binary-searched the larger array, partitionY could fall out of range. By always searching the smaller one, the constraint is automatically satisfiable. The swap at the top (if nums1.size > nums2.size → recurse with swapped args) enforces this.

Approach 1 — Merge and pick

Merge both arrays into one sorted list ($O(m + n)$), then read the middle element(s). Correct, and what most people write in an interview first. Then the interviewer says “make it $O(\log(m+n))$” — and this page is the answer.

Approach 2 — Partition binary search (optimal)

/**
 * @param nums1 the first sorted array (may be empty)
 * @param nums2 the second sorted array (may be empty)
 * @return      the median of the combined sorted sequence as a Double
 */
fun findMedianSortedArrays(nums1: IntArray, nums2: IntArray): Double {
    // Always binary search the SMALLER array: keeps partitionY in bounds.
    if (nums1.size > nums2.size) {
        return findMedianSortedArrays(nums2, nums1)
    }

    val m = nums1.size
    val n = nums2.size
    var start = 0
    var end = m

    while (start <= end) {
        val partitionX = (start + end) / 2
        val partitionY = (m + n + 1) / 2 - partitionX   // balance the halves

        // Sentinels: nonexistent left cells are -inf, right cells are +inf.
        val leftX  = nums1.getOrNull(partitionX - 1) ?: Int.MIN_VALUE
        val rightX = nums1.getOrNull(partitionX) ?: Int.MAX_VALUE
        val leftY  = nums2.getOrNull(partitionY - 1) ?: Int.MIN_VALUE
        val rightY = nums2.getOrNull(partitionY) ?: Int.MAX_VALUE

        when {
            // Valid split: everything left <= everything right.
            leftX <= rightY && leftY <= rightX -> {
                return if ((m + n) % 2 == 0) {
                    (maxOf(leftX, leftY) + minOf(rightX, rightY)) / 2.0
                } else {
                    maxOf(leftX, leftY).toDouble()
                }
            }
            // Too many elements taken from nums1: push partitionX left.
            leftX > rightY -> end = partitionX - 1
            // Too few from nums1: push partitionX right.
            else           -> start = partitionX + 1
        }
    }
    return -1.0 // Unreachable for valid inputs
}

public class MedianOfTwoSortedArrays {
    /**
     * @param nums1 the first sorted array (may be empty)
     * @param nums2 the second sorted array (may be empty)
     * @return      the median of the combined sorted sequence
     */
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1.length > nums2.length) return findMedianSortedArrays(nums2, nums1);
        int m = nums1.length, n = nums2.length;
        int start = 0, end = m;

        while (start <= end) {
            int partitionX = (start + end) / 2;
            int partitionY = (m + n + 1) / 2 - partitionX;

            int leftX  = partitionX - 1 >= 0 ? nums1[partitionX - 1] : Integer.MIN_VALUE;
            int rightX = partitionX < m ? nums1[partitionX] : Integer.MAX_VALUE;
            int leftY  = partitionY - 1 >= 0 ? nums2[partitionY - 1] : Integer.MIN_VALUE;
            int rightY = partitionY < n ? nums2[partitionY] : Integer.MAX_VALUE;

            if (leftX <= rightY && leftY <= rightX) {
                if ((m + n) % 2 == 0) {
                    return (Math.max(leftX, leftY) + Math.min(rightX, rightY)) / 2.0;
                }
                return Math.max(leftX, leftY);
            }
            if (leftX > rightY) end = partitionX - 1;
            else start = partitionX + 1;
        }
        return -1.0;
    }
}

#include <vector>
#include <algorithm>
#include <climits>

class MedianOfTwoSortedArrays {
public:
    /**
     * @param nums1 the first sorted array (may be empty)
     * @param nums2 the second sorted array (may be empty)
     * @return      the median of the combined sorted sequence
     */
    double findMedianSortedArrays(std::vector<int> nums1, std::vector<int> nums2) {
        if (nums1.size() > nums2.size()) return findMedianSortedArrays(nums2, nums1);
        int m = (int)nums1.size(), n = (int)nums2.size();
        int start = 0, end = m;

        while (start <= end) {
            int partitionX = (start + end) / 2;
            int partitionY = (m + n + 1) / 2 - partitionX;

            int leftX  = partitionX - 1 >= 0 ? nums1[partitionX - 1] : INT_MIN;
            int rightX = partitionX < m ? nums1[partitionX] : INT_MAX;
            int leftY  = partitionY - 1 >= 0 ? nums2[partitionY - 1] : INT_MIN;
            int rightY = partitionY < n ? nums2[partitionY] : INT_MAX;

            if (leftX <= rightY && leftY <= rightX) {
                if ((m + n) % 2 == 0) {
                    return (std::max(leftX, leftY) + std::min(rightX, rightY)) / 2.0;
                }
                return std::max(leftX, leftY);
            }
            if (leftX > rightY) end = partitionX - 1;
            else start = partitionX + 1;
        }
        return -1.0;
    }
};

def find_median_sorted_arrays(nums1: list[int], nums2: list[int]) -> float:
    """
    @param nums1: the first sorted array (may be empty)
    @param nums2: the second sorted array (may be empty)
    @return:      the median of the combined sorted sequence
    """
    if len(nums1) > len(nums2):
        return find_median_sorted_arrays(nums2, nums1)   # search the smaller array

    m, n = len(nums1), len(nums2)
    start, end = 0, m
    import sys
    NEG, POS = -sys.maxsize - 1, sys.maxsize

    while start <= end:
        partition_x = (start + end) // 2
        partition_y = (m + n + 1) // 2 - partition_x

        left_x  = nums1[partition_x - 1] if partition_x - 1 >= 0 else NEG
        right_x = nums1[partition_x] if partition_x < m else POS
        left_y  = nums2[partition_y - 1] if partition_y - 1 >= 0 else NEG
        right_y = nums2[partition_y] if partition_y < n else POS

        if left_x <= right_y and left_y <= right_x:
            if (m + n) % 2 == 0:
                return (max(left_x, left_y) + min(right_x, right_y)) / 2.0
            return float(max(left_x, left_y))
        if left_x > right_y:
            end = partition_x - 1
        else:
            start = partition_x + 1
    return -1.0

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums1 the first sorted array (may be empty)
    /// @param nums2 the second sorted array (may be empty)
    /// @return      the median of the combined sorted sequence
    pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
        if nums1.len() > nums2.len() {
            return Self::find_median_sorted_arrays(nums2, nums1);
        }
        let (m, n) = (nums1.len(), nums2.len());
        let (mut start, mut end) = (0usize, m);

        while start <= end {
            let partition_x = start + (end - start) / 2;
            let partition_y = (m + n + 1) / 2 - partition_x;

            let left_x  = if partition_x > 0 { nums1[partition_x - 1] } else { i32::MIN };
            let right_x = if partition_x < m { nums1[partition_x] } else { i32::MAX };
            let left_y  = if partition_y > 0 { nums2[partition_y - 1] } else { i32::MIN };
            let right_y = if partition_y < n { nums2[partition_y] } else { i32::MAX };

            if left_x <= right_y && left_y <= right_x {
                if (m + n) % 2 == 0 {
                    return (left_x.max(left_y) as f64 + right_x.min(right_y) as f64) / 2.0;
                }
                return left_x.max(left_y) as f64;
            }
            if left_x > right_y {
                if partition_x == 0 { break; }
                end = partition_x - 1;
            } else {
                start = partition_x + 1;
            }
        }
        -1.0
    }
}
}

Dry run

Input: nums1 = [1, 3], nums2 = [2]. $m = 2, n = 1, m + n = 3$ (odd → median is the max of the left halves).

start=0  end=2  partitionX=1  partitionY=(3+1)/2 - 1 = 1
  leftX = nums1[0] = 1        rightX = nums1[1] = 3
  leftY = nums2[0] = 2        rightY = +inf (partitionY = 1 == n)
  leftX(1) <= rightY(inf) ✓   leftY(2) <= rightX(3) ✓  -> VALID
  odd -> return max(1, 2) = 2.0 ✓

Visualize the split:

nums1: [1 | 3]        partitionX = 1 (take 1 into the left half)
nums2: [2 | ]         partitionY = 1 (take 2 into the left half)
left half  = {1, 2}   right half = {3}
median = max(1, 2) = 2 ✓

Input: nums1 = [1, 2], nums2 = [3, 4]. $m + n = 4$ (even → average of the two middle values).

start=0  end=2  partitionX=1  partitionY=(4+1)/2 - 1 = 1
  leftX=1  rightX=2  leftY=3  rightY=4
  leftX(1) <= rightY(4) ✓   leftY(3) <= rightX(2)? NO  -> leftY > rightX: take MORE from nums1 -> start=2
start=2  end=2  partitionX=2  partitionY=2 - 2 = 0
  leftX = nums1[1] = 2    rightX = +inf
  leftY = -inf            rightY = nums2[0] = 3
  leftX(2) <= rightY(3) ✓  leftY(-inf) <= rightX(inf) ✓ -> VALID
  even -> (max(2, -inf) + min(inf, 3)) / 2 = (2 + 3) / 2 = 2.5 ✓

Visualize the second (final) split:

nums1: [1, 2 | ]      partitionX = 2 (take both into the left half)
nums2: [   | 3, 4]    partitionY = 0 (take none)
left half  = {1, 2}   right half = {3, 4}
median = (max(2, -inf) + min(inf, 3)) / 2 = 2.5 ✓

Notice how the sentinels (-inf/+inf) make the “empty side” cases flow through the same formula — no special-casing anywhere.

Complexity

Time. The search space is partitionX ∈ [0, m] with $m = \min(m, n)$ after the swap; each step is $O(1)$:

$$ T(m, n) = O(\log \min(m, n)) $$

This beats the $O(\log(m+n))$ “binary search the k-th element” alternative and is the best possible for comparison-based approaches.

Space. $O(1)$.

Variants & follow-ups

• Kth element of two sorted arrays — the general form; this page’s partition idea generalizes by adjusting the “balance” formula to k.
• Median of a data stream (src/main/kotlin/heap/) — the streaming version: two heaps (max-heap for the lower half, min-heap for the upper half), $O(\log n)$ per insertion, $O(1)$ median. Static vs streaming is a classic pairing.
• Interview follow-up: “Why must partitionY stay in [0, n]?” If it fell outside, nums2 would be entirely on one side — an invalid split. The smaller-array swap guarantees 0 ≤ (m+n+1)/2 − x ≤ n for every x ∈ [0, m]; verify with the extremes: at x = 0, partitionY = (m+n+1)/2 ≤ n since m ≤ n; at x = m, partitionY = (n−m+1)/2 ≥ 0.
• Interview follow-up: “Why (m + n + 1) / 2 and not (m + n) / 2?” The +1 biases the left half to be at least as large as the right half, so the odd case (extra element in the left half) is handled by max(leftX, leftY) without branching on which array holds the extra element.

1.13 Peak Index In A Mountain Array

Source: src/main/kotlin/binarysearch/PeakIndexInMountainArray.kt Pattern: monotone slope descent (unimodal) · Variant page

The Problem

A mountain array is an array that strictly increases up to a peak index i, then strictly decreases:

$$ arr[0] < arr[1] < \cdots < arr[i] > arr[i+1] > \cdots > arr[n-1] $$

arr is guaranteed to be a mountain. Return the peak index i.

• Constraints: $3 \le n \le 10^4$, arr is a mountain by construction.

Examples

Input:  arr = [0, 1, 0]          -> Output: 1
Input:  arr = [0, 2, 1, 0]       -> Output: 1
Input:  arr = [0, 1, 2, 3, 6, 5, 4, 3]  -> Output: 4

Intuition

This is 1.6 with a guarantee: the array is unimodal, so there is exactly one peak, and the slope comparison is globally consistent (rises everywhere left of the peak, falls everywhere right of it). That makes the predicate truly monotone, not just “a peak exists on this side”:

slope:  /  /  /  /  |  \  \  \
                    ^
                peak = the turning point

So the standard slope-descent binary search is not just correct — it’s sharp: it finds the unique turning point in $O(\log n)$. (With the unimodal guarantee, even the variant that compares nums[mid] with both neighbors and early-returns on a hit works.)

Approach 1 — Linear scan

Scan until arr[i] > arr[i+1]; that i is the peak. $O(n)$. The $O(\log n)$ requirement (and $n$ up to $10^4$+) makes binary search the expected answer.

Approach 2 — Slope-descent binary search (optimal)

/**
 * @param arr a mountain array (strictly increases then strictly decreases)
 * @return    the index of the single peak
 */
fun peakIndexInMountainArray(arr: IntArray): Int {
    var (left, right) = 0 to arr.lastIndex

    while (left <= right) {
        val mid = left + (right - left) / 2
        when {
            arr[mid + 1] > arr[mid] -> left = mid + 1   // still rising -> peak is to the right
            else                    -> right = mid - 1  // falling -> peak is at or left of mid
        }
    }
    return left
}

public class PeakIndexInMountainArray {
    /**
     * @param arr a mountain array (strictly increases then strictly decreases)
     * @return    the index of the single peak
     */
    public int peakIndexInMountainArray(int[] arr) {
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid + 1] > arr[mid]) {
                left = mid + 1;       // still rising -> peak is to the right
            } else {
                right = mid - 1;      // falling -> peak is at or left of mid
            }
        }
        return left;
    }
}

#include <vector>

class PeakIndexInMountainArray {
public:
    /**
     * @param arr a mountain array (strictly increases then strictly decreases)
     * @return    the index of the single peak
     */
    int peakIndexInMountainArray(const std::vector<int>& arr) {
        int left = 0, right = (int)arr.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid + 1] > arr[mid]) left = mid + 1;
            else right = mid - 1;
        }
        return left;
    }
};

def peak_index_in_mountain_array(arr: list[int]) -> int:
    """
    @param arr: a mountain array (strictly increases then strictly decreases)
    @return:    the index of the single peak
    """
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = left + (right - left) // 2
        if arr[mid + 1] > arr[mid]:
            left = mid + 1        # still rising -> peak is to the right
        else:
            right = mid - 1       # falling -> peak is at or left of mid
    return left

#![allow(unused)]
fn main() {
impl Solution {
    /// @param arr a mountain array (strictly increases then strictly decreases)
    /// @return    the index of the single peak
    pub fn peak_index_in_mountain_array(arr: Vec<i32>) -> i32 {
        let (mut left, mut right) = (0usize, arr.len() - 1);
        while left <= right {
            let mid = left + (right - left) / 2;
            if arr[mid + 1] > arr[mid] {
                left = mid + 1;
            } else if mid == 0 {
                break;
            } else {
                right = mid - 1;
            }
        }
        left as i32
    }
}
}

Note on mid + 1: the code reads arr[mid + 1]. Because arr is a mountain with $n \ge 3$, the peak is never at index 0, so a valid mid never equals arr.lastIndex while left <= right still holds — the access is safe. If you dislike relying on that, use the two-neighbor form from 1.7.

Dry run

Input: arr = [0, 1, 2, 3, 6, 5, 4, 3]

left=0  right=7  mid=3  arr[4]=6 > arr[3]=3  -> left=4   (rising; peak right)
left=4  right=7  mid=5  arr[6]=4 > arr[5]=5? NO -> right=4  (falling; peak at/left)
left=4  right=4  mid=4  arr[5]=5 > arr[4]=6? NO -> right=3
left=4  right=3  -> loop ends, return 4 ✓

Input: arr = [0, 2, 1, 0]

left=0  right=3  mid=1  arr[2]=1 > arr[1]=2? NO -> right=0
left=0  right=0  mid=0  arr[1]=2 > arr[0]=0  YES -> left=1
left=1  right=0  -> return 1 ✓

Complexity

Time. Each iteration halves the window; the mid + 1 reads keep it at a constant number of array accesses per step:

$$ T(n) = O(\log n) $$

Space. $O(1)$.

Variants & follow-ups

• 1.6 — the general (multi-peak) version, where “any peak” is acceptable.
• Find in Mountain Array (LeetCode 1095) — combine this search (to find the peak) with two standard binary searches (one on the rising half, one on the falling half).
• Interview follow-up: “What if the array could be flat (plateaus)?” The mountain guarantee breaks; the arr[mid+1] > arr[mid] test becomes ambiguous on a flat run, and you’d fall back to the boundary-safe neighbor comparison of 1.7.

1.14 Random Pick With Weight

Source: src/main/kotlin/binarysearch/RandomPickWithWeight.kt Pattern: prefix sums + binary search · Gym page

The Problem

Design a structure initialized with an array of positive weights w. pickIndex() must return a random index i with probability proportional to w[i]:

$$ P(i) = \frac{w[i]}{\sum_j w[j]} $$

• Constraints: $1 \le w.length \le 10^4$, $1 \le w[i] \le 10^5$, many calls to pickIndex.

Examples

w = [1, 3]
P(0) = 1/4, P(1) = 3/4.  pickIndex() should return 1 about 75% of the time.

Intuition — the “roulette wheel” made of line segments

Draw each weight as a segment on a number line: weight 1 occupies [0, 1), weight 3 occupies [1, 4). Pick a uniform random point in [0, total). The segment that contains the point is your answer:

w = [1, 3]     total = 4
| 0 |   1    |   2    |   3    |
|seg0|      seg1 (length 3)      |
    ^ random point -> index 1

The prefix sums [1, 4] record the right ends of the segments. Finding which segment contains r = “find the first prefix sum > r” — and because prefix sums are sorted, that’s a binary search.

Careful with the boundary convention: Random.nextInt(total) returns $r \in [0, total)$ (exclusive of total). With prefix P = [1, 4], the condition P[mid] > r (strictly greater) maps:

• $r \in [0, 1)$ → first prefix > r is 1 → index 0 (segment 0, length 1) ✓
• $r \in [1, 4)$ → first prefix > r is 4 → index 1 (segment 1, length 3) ✓

This is Template A (1.0) — “first true” for the predicate prefix[mid] > r.

Approach — prefix sums + binary search

/**
 * @param w the positive weights; index i must be picked with probability w[i] / sum(w)
 */
class RandomPickWithWeight(w: IntArray) {
    private val prefixSum = IntArray(w.size) { 0 }
    private val totalSum: Int

    init {
        for (i in w.indices) {
            prefixSum[i] = if (i > 0) prefixSum[i - 1] + w[i] else w[i]
        }
        totalSum = prefixSum.last()
    }

    /**
     * @return a random index i with probability proportional to w[i]
     */
    fun pickIndex(): Int {
        // Uniform point in [0, totalSum). nextInt(exclusive) is exactly this.
        val randomPick = Random.nextInt(totalSum)
        var (start, end) = 0 to w.size

        while (start < end) {
            val mid = start + (end - start) / 2
            when {
                prefixSum[mid] > randomPick -> end = mid    // segment containing r is at or left
                else                        -> start = mid + 1
            }
        }
        return start
    }
}

import java.util.concurrent.ThreadLocalRandom;

public class RandomPickWithWeight {
    private final int[] prefixSum;
    private final int totalSum;

    /**
     * @param w the positive weights; index i must be picked with probability w[i] / sum(w)
     */
    public RandomPickWithWeight(int[] w) {
        prefixSum = new int[w.length];
        for (int i = 0; i < w.length; i++) {
            prefixSum[i] = (i > 0 ? prefixSum[i - 1] : 0) + w[i];
        }
        totalSum = prefixSum[prefixSum.length - 1];
    }

    /**
     * @return a random index i with probability proportional to w[i]
     */
    public int pickIndex() {
        int r = ThreadLocalRandom.current().nextInt(totalSum);   // [0, totalSum)
        int start = 0, end = prefixSum.length;
        while (start < end) {
            int mid = start + (end - start) / 2;
            if (prefixSum[mid] > r) end = mid;
            else start = mid + 1;
        }
        return start;
    }
}

#include <vector>
#include <random>

class RandomPickWithWeight {
    std::vector<int> prefixSum;
    int totalSum;
    std::mt19937 gen{std::random_device{}()};

public:
    /**
     * @param w the positive weights; index i must be picked with probability w[i] / sum(w)
     */
    RandomPickWithWeight(const std::vector<int>& w) {
        prefixSum.resize(w.size());
        int acc = 0;
        for (int i = 0; i < (int)w.size(); i++) {
            acc += w[i];
            prefixSum[i] = acc;
        }
        totalSum = acc;
    }

    /**
     * @return a random index i with probability proportional to w[i]
     */
    int pickIndex() {
        std::uniform_int_distribution<int> dist(0, totalSum - 1);
        int r = dist(gen);                       // [0, totalSum)
        int start = 0, end = (int)prefixSum.size();
        while (start < end) {
            int mid = start + (end - start) / 2;
            if (prefixSum[mid] > r) end = mid;
            else start = mid + 1;
        }
        return start;
    }
};

import random

class RandomPickWithWeight:
    """
    @param w: the positive weights; index i must be picked with probability w[i] / sum(w)
    """
    def __init__(self, w: list[int]) -> None:
        self.prefix_sum: list[int] = []
        acc = 0
        for weight in w:
            acc += weight
            self.prefix_sum.append(acc)
        self.total = acc

    """
    @return: a random index i with probability proportional to w[i]
    """
    def pick_index(self) -> int:
        r = random.randrange(self.total)          # [0, total)
        start, end = 0, len(self.prefix_sum)
        while start < end:
            mid = start + (end - start) // 2
            if self.prefix_sum[mid] > r:
                end = mid
            else:
                start = mid + 1
        return start

#![allow(unused)]
fn main() {
use rand::Rng;

struct Solution {
    prefix_sum: Vec<i32>,
    total: i32,
}

impl Solution {
    /// @param w the positive weights; index i must be picked with probability w[i] / sum(w)
    fn new(w: Vec<i32>) -> Self {
        let mut prefix_sum = Vec::with_capacity(w.len());
        let mut acc = 0;
        for weight in w {
            acc += weight;
            prefix_sum.push(acc);
        }
        let total = acc;
        Self { prefix_sum, total }
    }

    /// @return a random index i with probability proportional to w[i]
    fn pick_index(&self) -> i32 {
        let r = rand::thread_rng().gen_range(0..self.total);   // [0, total)
        let (mut start, mut end) = (0usize, self.prefix_sum.len());
        while start < end {
            let mid = start + (end - start) / 2;
            if self.prefix_sum[mid] > r {
                end = mid;
            } else {
                start = mid + 1;
            }
        }
        start as i32
    }
}
}

Rust note: requires the rand crate. The code above uses gen_range(0..self.total) which matches nextInt(total)’s exclusive-upper-bound semantics exactly.

Dry run

Input: w = [1, 3] → prefixSum = [1, 4], total = 4.

Say the RNG draws r = 2:

start=0  end=2  mid=1  prefix[1]=4 > 2 -> end=1
start=0  end=1  mid=0  prefix[0]=1 > 2? NO -> start=1
start=1  end=1  -> return 1 ✓   (segment 1, which spans [1, 4))

Now enumerate all four possible draws to see the distribution:

Index 0 is returned for exactly 1 of 4 draws; index 1 for 3 of 4 — exactly the weights. The roulette wheel is exact.

Complexity

Construction: one pass to build prefix sums — $O(n)$ time, $O(n)$ space.

pickIndex: one halving search over $n$ prefix entries:

$$ T_{\text{pick}} = O(\log n), \qquad S = O(n) $$

Variants & follow-ups

• Random Pick Index (streaming version) — reservoir sampling, when the array is too big to prefix-sum; see src/main/kotlin/probability/.
• Interview follow-up: “Why nextInt(total) and not nextInt(total + 1)?” The exclusive bound keeps r inside [0, total), matching the segment layout [prefix[i-1], prefix[i]); an inclusive bound would need an extra case for r == total.
• Interview follow-up: “What if weights are huge (sum overflows Int)?” Use Long prefix sums — the binary search is unchanged; the overflow is the only thing that breaks, and it breaks at construction, not at pick time.

1.15 Search A 2D Matrix

Source: src/main/kotlin/binarysearch/SearchA2dMatrix.kt Pattern: index unrolling · Core page

The Problem

Given an $m \times n$ matrix where each row is sorted left-to-right and the first element of each row is greater than the last element of the previous row, determine whether a target is present.

The two properties together mean the whole matrix, read row by row, is one globally sorted sequence of length $mn$.

• Constraints: $1 \le m, n \le 100$.

Examples

matrix = [
  [1,  3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 60]
]
target = 3   -> true
target = 13  -> false
target = 60  -> true

Intuition — flatten the matrix without flattening it

The killer observation: the matrix is one sorted array with a $n$-wide stride. If you number the cells $0..mn-1$ in row-major order, then

$$ \text{row} = \lfloor idx / n \rfloor, \qquad \text{col} = idx \bmod n $$

and the sequence matrix[row][col] is non-decreasing. So the whole thing is a plain binary search (Template B, exact match) over the virtual 1D range $[0, mn-1]$, with the array access replaced by the two conversions above.

The unrolling identity is the entire trick: $\lfloor idx/n \rfloor$ and $idx \bmod n$ are just the quotient and remainder of dividing the flat index by the row width — the standard “row-major” memory layout that every 2D array uses under the hood.

Approach 1 — Search each row

Binary search each row: $O(m \log n)$. Works, but ignores the cross-row ordering — the matrix is one sorted sequence, so a single binary search over all $mn$ cells is strictly better.

Approach 2 — Single binary search on the flattened index (optimal)

/**
 * @param matrix the m x n matrix, rows sorted and first-of-row > last-of-previous-row
 * @param target the value to find
 * @return       true iff target is present in the matrix
 */
fun searchMatrix(matrix: Array<IntArray>, target: Int): Boolean {
    if (matrix.isEmpty() || matrix[0].isEmpty()) return false

    val (m, n) = matrix.size to matrix[0].size
    var (left, right) = 0 to m * n - 1

    while (left <= right) {
        val mid = left + (right - left) / 2
        val midValue = matrix[mid / n][mid % n]   // flatten: row = idx / n, col = idx % n

        when {
            midValue == target -> return true
            midValue < target  -> left = mid + 1
            else               -> right = mid - 1
        }
    }
    return false
}

public class SearchA2dMatrix {
    /**
     * @param matrix the m x n matrix, rows sorted and first-of-row > last-of-previous-row
     * @param target the value to find
     * @return       true iff target is present in the matrix
     */
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix.length == 0 || matrix[0].length == 0) return false;
        int m = matrix.length, n = matrix[0].length;
        int left = 0, right = m * n - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;
            int value = matrix[mid / n][mid % n];   // row-major unrolling
            if (value == target) return true;
            if (value < target) left = mid + 1;
            else right = mid - 1;
        }
        return false;
    }
}

#include <vector>

class SearchA2dMatrix {
public:
    /**
     * @param matrix the m x n matrix, rows sorted and first-of-row > last-of-previous-row
     * @param target the value to find
     * @return       true iff target is present in the matrix
     */
    bool searchMatrix(const std::vector<std::vector<int>>& matrix, int target) {
        if (matrix.empty() || matrix[0].empty()) return false;
        int m = (int)matrix.size(), n = (int)matrix[0].size();
        int left = 0, right = m * n - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;
            int value = matrix[mid / n][mid % n];
            if (value == target) return true;
            if (value < target) left = mid + 1;
            else right = mid - 1;
        }
        return false;
    }
};

def search_matrix(matrix: list[list[int]], target: int) -> bool:
    """
    @param matrix: the m x n matrix, rows sorted and first-of-row > last-of-previous-row
    @param target: the value to find
    @return:       True iff target is present in the matrix
    """
    if not matrix or not matrix[0]:
        return False
    m, n = len(matrix), len(matrix[0])
    left, right = 0, m * n - 1

    while left <= right:
        mid = left + (right - left) // 2
        value = matrix[mid // n][mid % n]      # row-major unrolling
        if value == target:
            return True
        if value < target:
            left = mid + 1
        else:
            right = mid - 1
    return False

#![allow(unused)]
fn main() {
impl Solution {
    /// @param matrix the m x n matrix, rows sorted and first-of-row > last-of-previous-row
    /// @param target the value to find
    /// @return       true iff target is present in the matrix
    pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
        if matrix.is_empty() || matrix[0].is_empty() {
            return false;
        }
        let (m, n) = (matrix.len(), matrix[0].len());
        let (mut left, mut right) = (0usize, m * n - 1);

        while left <= right {
            let mid = left + (right - left) / 2;
            let value = matrix[mid / n][mid % n];
            if value == target {
                return true;
            }
            if value < target {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        false
    }
}
}

Dry run

Input: matrix as above, target = 3. Flattened search space $[0, 11]$:

left=0  right=11  mid=5   idx 5 -> row 1, col 1 -> 11    11 > 3 -> right=4
left=0  right=4   mid=2   idx 2 -> row 0, col 2 -> 5     5  > 3 -> right=1
left=0  right=1   mid=0   idx 0 -> row 0, col 0 -> 1     1  < 3 -> left=1
left=1  right=1   mid=1   idx 1 -> row 0, col 1 -> 3     3 == 3 -> return true ✓

The unrolling is easy to verify by hand:

The value row is strictly increasing — it’s a 1D sorted array wearing a 2D costume, and the binary search never notices.

Complexity

Time. The virtual array has $mn$ cells:

$$ T(m, n) = O(\log(mn)) $$

Space. $O(1)$.

Variants & follow-ups

• Search a 2D Matrix II (classic sibling) — rows and columns are sorted independently, but the cross-row property is gone. Binary search over the whole thing fails; the $O(m + n)$ “staircase search” from the top-right corner is the canonical answer.
• Kth Smallest Element in a Sorted Matrix — uses this unrolling idea and a binary-search-on-answer over the value range.
• Interview follow-up: “What if rows are sorted but the first-of-row property doesn’t hold?” The global sortedness collapses; you’d fall back to row-by-row binary search ($O(m \log n)$) or the staircase walk ($O(m + n)$).

1.16 Search In Rotated Sorted Array II

Source: src/main/kotlin/binarysearch/SearchInRotatedArray_II.kt Pattern: rotated binary search with duplicates · Core page

The Problem

Search in a rotated array that may contain duplicates (return existence).

• Constraints: n ≤ 5000.

Examples

Input:  nums = [2,5,6,0,0,1,2], target = 0   -> Output: true
Input:  nums = [2,5,6,0,0,1,2], target = 3   -> Output: false

Intuition — the rotated search; when nums[mid] == nums[left], shrink

Duplicates break the rotation detection: nums[left] == nums[mid] can’t tell which side is sorted. The fix: narrow the range (left++) and retry:

while (left <= right) {
    val mid = left + (right - left) / 2

    when {
        nums[mid] == target -> return true
        nums[left] == nums[mid] -> left++      // ambiguous: shrink
        nums[left] < nums[mid] -> {            // left half sorted
            if (target in nums[left]..nums[mid]) right = mid - 1
            else left = mid + 1
        }
        else -> {                              // right half sorted
            if (target in nums[mid]..nums[right]) left = mid + 1
            else right = mid - 1
        }
    }
}
return false

Why left++ on the tie? Equal endpoints make both halves “look sorted” ambiguously — advancing one step removes a duplicate and re-tests. Worst case degrades to O(n) (all duplicates), but typical stays O(log n).

Approach 1 — Binary search with ambiguity shrink (the repo’s version, optimal)

class SearchInRotatedArray_II {
    /**
     * @param nums   rotated sorted array with duplicates
     * @param target search value
     * @return       true iff found
     */
    fun search(nums: IntArray, target: Int): Boolean {
        var left = 0
        var right = nums.lastIndex

        while (left <= right) {
            val mid = left + (right - left) / 2

            when {
                nums[mid] == target -> return true
                nums[left] == nums[mid] -> left++
                nums[left] < nums[mid] -> {
                    if (target in nums[left]..nums[mid]) right = mid - 1
                    else left = mid + 1
                }
                else -> {
                    if (target in nums[mid]..nums[right]) left = mid + 1
                    else right = mid - 1
                }
            }
        }
        return false
    }
}

public class SearchInRotatedSortedArrayII {
    /**
     * @param nums   rotated sorted array with duplicates
     * @param target search value
     * @return       true iff found
     */
    public boolean search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) return true;

            if (nums[left] == nums[mid]) left++;
            else if (nums[left] < nums[mid]) {
                if (target >= nums[left] && target <= nums[mid]) right = mid - 1;
                else left = mid + 1;
            } else {
                if (target >= nums[mid] && target <= nums[right]) left = mid + 1;
                else right = mid - 1;
            }
        }
        return false;
    }
}

#include <vector>

class SearchInRotatedSortedArrayII {
public:
    /**
     * @param nums   rotated sorted array with duplicates
     * @param target search value
     * @return       true iff found
     */
    bool search(std::vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) return true;

            if (nums[left] == nums[mid]) left++;
            else if (nums[left] < nums[mid]) {
                if (target >= nums[left] && target <= nums[mid]) right = mid - 1;
                else left = mid + 1;
            } else {
                if (target >= nums[mid] && target <= nums[right]) left = mid + 1;
                else right = mid - 1;
            }
        }
        return false;
    }
};

def search(nums: list[int], target: int) -> bool:
    """
    @param nums:   rotated sorted array with duplicates
    @param target: search value
    @return:       true iff found
    """
    left, right = 0, len(nums) - 1

    while left <= right:
        mid = (left + right) // 2

        if nums[mid] == target:
            return True

        if nums[left] == nums[mid]:
            left += 1
        elif nums[left] < nums[mid]:
            if nums[left] <= target <= nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        else:
            if nums[mid] <= target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1

    return False

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums   rotated sorted array with duplicates
    /// @param target search value
    /// @return       true iff found
    pub fn search(nums: Vec<i32>, target: i32) -> bool {
        let (mut left, mut right) = (0, nums.len() - 1);

        while left <= right {
            let mid = left + (right - left) / 2;

            if nums[mid] == target { return true; }

            if nums[left] == nums[mid] { left += 1; }
            else if nums[left] < nums[mid] {
                if target >= nums[left] && target <= nums[mid] { right = mid - 1; }
                else { left = mid + 1; }
            } else {
                if target >= nums[mid] && target <= nums[right] { left = mid + 1; }
                else { right = mid - 1; }
            }
        }
        false
    }
}
}

Dry run

Input: nums = [2,5,6,0,0,1,2], target = 0.

left=0, right=6.  mid=3 (0).  found -> true ✓

Input: [1,0,1,1,1], target = 0: mid=2 (1).  nums[0]==1 == mid -> left=1.
  mid=(1+4)/2=2 (1): nums[1]=0 != 1.  nums[1] < nums[2]: right-half check: 0 in [1..1]? no
  -> right=1.  mid=1 (0): found ✓

Complexity

Time. O(log n) typical, O(n) worst (all duplicates):

$$ T(n) = O(\log n) $$

Space. Constants:

$$ S(n) = O(1) $$

Variants & follow-ups

• Search In Rotated Sorted Array (1.17) — the no-duplicates sibling.
• Interview follow-up: “Why can’t duplicates keep it O(log n)?” An adversarial all-equal array forces the left++ shrink to walk linearly — no comparison can distinguish. The problem accepts the O(n) worst case (existence only).

1.17 Search In Rotated Sorted Array

Source: src/main/kotlin/binarysearch/SearchInRotatedSortedArray.kt Pattern: rotated-array search · Core page

The Problem

A sorted array of distinct integers was rotated at an unknown pivot. Given the rotated array and a target, return the index of target, or -1 if absent. Must run in $O(\log n)$.

• Constraints: $1 \le n \le 5000$.

Examples

Input:  nums = [4, 5, 6, 7, 0, 1, 2], target = 0
Output: 4

Input:  nums = [4, 5, 6, 7, 0, 1, 2], target = 3
Output: -1

Input:  nums = [1], target = 0
Output: -1

Intuition — one binary search, not two

The naive plan is “find the pivot, then binary search the right run.” That works ($O(\log n)$), but there’s a cleaner formulation that does one binary search. The trick: at every step, at least one half is fully sorted, and we can always tell which one.

Compare nums[mid] with nums[start]:

• nums[start] <= nums[mid] → the left half is sorted. Then target is in the left half iff nums[start] <= target < nums[mid]. If yes, go left; if no, the target (if it exists) must be in the right half.
• Otherwise → the right half is sorted (the pivot lies inside the left half). Then target is in the right half iff nums[mid] < target <= nums[end]. If yes, go right; else go left.

Why is this correct? The two-run picture from 1.5: a rotated array is run 1 (big values) followed by run 2 (small values). If nums[start] <= nums[mid], then start and mid are in the same run (you can’t cross the pivot without values dropping), so [start, mid] is fully sorted and the standard “is target inside this sorted range?” test applies. Same argument mirrored for the right half.

This is still Template B (exact match) from 1.0, with the sorted-range test replacing the plain comparison.

Approach 1 — Find pivot, then binary search

1. Binary search for the rotation index (as in 1.5).
2. Decide which run the target belongs to (compare with nums[0]).
3. Run a plain binary search on that run.

Correct, $O(\log n)$, but two passes and more edge cases to narrate. The one-pass version below is what interviewers want to hear.

Approach 2 — Single-pass rotated binary search (optimal)

/**
 * @param nums   the rotated sorted array (distinct values)
 * @param target the value to find
 * @return       the index of target, or -1 if it is absent
 */
fun search(nums: IntArray, target: Int): Int {
    var (start, end) = 0 to nums.lastIndex

    while (start <= end) {
        val mid = start + (end - start) / 2

        if (nums[mid] == target) return mid

        // Left half [start..mid] is fully sorted.
        if (nums[start] <= nums[mid]) {
            if (nums[start] <= target && target < nums[mid]) {
                end = mid - 1          // target inside the sorted left half
            } else {
                start = mid + 1        // target must be in the right half
            }
        } else {
            // Right half [mid..end] is fully sorted.
            if (nums[mid] < target && target <= nums[end]) {
                start = mid + 1        // target inside the sorted right half
            } else {
                end = mid - 1          // target must be in the left half
            }
        }
    }
    return -1
}

public class SearchInRotatedSortedArray {
    /**
     * @param nums   the rotated sorted array (distinct values)
     * @param target the value to find
     * @return       the index of target, or -1 if it is absent
     */
    public int search(int[] nums, int target) {
        int start = 0, end = nums.length - 1;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] == target) return mid;

            if (nums[start] <= nums[mid]) {                 // left half sorted
                if (nums[start] <= target && target < nums[mid]) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            } else {                                        // right half sorted
                if (nums[mid] < target && target <= nums[end]) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }
        }
        return -1;
    }
}

#include <vector>

class SearchInRotatedSortedArray {
public:
    /**
     * @param nums   the rotated sorted array (distinct values)
     * @param target the value to find
     * @return       the index of target, or -1 if it is absent
     */
    int search(const std::vector<int>& nums, int target) {
        int start = 0, end = (int)nums.size() - 1;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] == target) return mid;

            if (nums[start] <= nums[mid]) {                 // left half sorted
                if (nums[start] <= target && target < nums[mid]) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            } else {                                        // right half sorted
                if (nums[mid] < target && target <= nums[end]) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }
        }
        return -1;
    }
};

def search(nums: list[int], target: int) -> int:
    """
    @param nums:   the rotated sorted array (distinct values)
    @param target: the value to find
    @return:       the index of target, or -1 if it is absent
    """
    start, end = 0, len(nums) - 1
    while start <= end:
        mid = start + (end - start) // 2
        if nums[mid] == target:
            return mid

        if nums[start] <= nums[mid]:            # left half sorted
            if nums[start] <= target < nums[mid]:
                end = mid - 1
            else:
                start = mid + 1
        else:                                   # right half sorted
            if nums[mid] < target <= nums[end]:
                start = mid + 1
            else:
                end = mid - 1
    return -1

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums   the rotated sorted array (distinct values)
    /// @param target the value to find
    /// @return       the index of target, or -1 if it is absent
    pub fn search(nums: Vec<i32>, target: i32) -> i32 {
        let (mut start, mut end) = (0usize, nums.len() - 1);
        while start <= end {
            let mid = start + (end - start) / 2;
            if nums[mid] == target {
                return mid as i32;
            }

            if nums[start] <= nums[mid] {               // left half sorted
                if nums[start] <= target && target < nums[mid] {
                    if mid == 0 { break; }
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            } else {                                    // right half sorted
                if nums[mid] < target && target <= nums[end] {
                    start = mid + 1;
                } else {
                    if mid == 0 { break; }
                    end = mid - 1;
                }
            }
        }
        -1
    }
}
}

Rust note: usize cannot go below zero, so the mid == 0 guards replace the implicit -1 underflow of the other languages; breaking out of the loop is equivalent to “window exhausted, not found”.

Dry run

Input: nums = [4, 5, 6, 7, 0, 1, 2], target = 0

start=0  end=6  mid=3  nums[3]=7 != 0
  nums[0]=4 <= 7  -> left half [4,5,6,7] is sorted
  is 4 <= 0 < 7? NO -> target must be right -> start=4
start=4  end=6  mid=5  nums[5]=1 != 0
  nums[4]=0 <= 1  -> left half [0,1] is sorted
  is 0 <= 0 < 1? YES -> end=4
start=4  end=4  mid=4  nums[4]=0 == 0 -> return 4 ✓

Input: nums = [4, 5, 6, 7, 0, 1, 2], target = 3

start=0  end=6  mid=3  nums[3]=7 != 3
  left half sorted; is 4 <= 3 < 7? NO -> start=4
start=4  end=6  mid=5  nums[5]=1 != 3
  nums[4]=0 <= 1 -> left half [0,1] sorted; is 0 <= 3 < 1? NO -> start=6
start=6  end=6  mid=6  nums[6]=2 != 3
  nums[6]=2 <= nums[6]=2 -> left half [2] sorted; is 2 <= 3 < 2? NO -> start=7
start=7  end=6  -> loop ends, return -1 ✓

The key property to verify by hand: at every step, the branch we take is forced — the sorted-half test is guaranteed to be correct for one of the two halves, so the window always shrinks and never discards the target’s location.

Complexity

Time. The window halves every iteration:

$$ T(n) = O(\log n) $$

Space. $O(1)$ auxiliary.

Variants & follow-ups

• Search In Rotated Sorted Array II (1.16) — duplicates make nums[start] == nums[mid] possible, which breaks the “which half is sorted” test; the fix costs $O(n)$ in the worst case.
• Find Minimum In Rotated Sorted Array (1.5) — the pivot-finding half of this problem, standalone.
• Interview follow-up: “Can we find the pivot with this same loop?” Yes — remove the equality return and the sorted-range test, keep the nums[mid] > nums[end] comparison, and the loop converges to the pivot. That’s 1.5 verbatim.
• Interview follow-up: “Why nums[start] <= nums[mid] with <=?” With distinct values it never matters, but the <= makes the code identical to the duplicate-tolerant version’s sorted-half test — one less thing to rewrite if the interviewer adds duplicates.

1.19 Sqrt(x)

Source: src/main/kotlin/math/Sqrt.kt Pattern: binary search on the answer · Core page

The Problem

mySqrt(x) — the integer square root: the largest r with r² ≤ x, without floating point.

• Constraints: $0 \le x \le 2^{31} - 1$.

Examples

Input:  x = 4   -> Output: 2
Input:  x = 8   -> Output: 2   (2² = 4 ≤ 8 < 3² = 9)

Intuition — binary search the answer in [1, x]

The answer is a number, monotone in r² ≤ x — the 1.0 “binary search over the answer” shape: search r in [1, x], comparing r² to x:

var (left, right) = 1 to x
while (left <= right) {
    val mid = left + (right - left) / 2
    val square = mid.toLong() * mid        // Long: mid² can overflow Int

    when {
        square < x -> left = mid + 1
        square > x -> right = mid - 1
        else -> return mid
    }
}
return right                               // largest r with r² <= x

Why toLong()? 46341² > Int.MAX_VALUE — squaring mid in Int overflows and corrupts the comparison. The Long cast is the 1.x overflow hygiene.

Why return right? The loop exits with left > right — right is the last candidate whose square was ≤ x (the exact match returns early). The [1, x] range with the </> branches pins right at the floor.

Approach 1 — Linear scan (O(√x))

Square every integer up to the answer: correct, slow.

Approach 2 — Binary search on the answer (the repo’s version, optimal)

class Sqrt {
    /**
     * @param x non-negative integer
     * @return  integer square root (floor)
     */
    fun mySqrt(x: Int): Int {
        if (x < 2) return x

        var (left, right) = 1 to x
        while (left <= right) {
            val mid = left + (right - left) / 2
            val square = mid.toLong() * mid

            when {
                square < x -> left = mid + 1
                square > x -> right = mid - 1
                else -> return mid
            }
        }
        return right
    }
}

public class Sqrt {
    /**
     * @param x non-negative integer
     * @return  integer square root (floor)
     */
    public int mySqrt(int x) {
        if (x < 2) return x;

        int left = 1, right = x;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            long square = (long) mid * mid;      // Long: mid² can overflow

            if (square < x) left = mid + 1;
            else if (square > x) right = mid - 1;
            else return mid;
        }
        return right;
    }
}

class Sqrt {
public:
    /**
     * @param x non-negative integer
     * @return  integer square root (floor)
     */
    int mySqrt(int x) {
        if (x < 2) return x;

        int left = 1, right = x;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            long long square = (long long) mid * mid;   // Long: mid² can overflow

            if (square < x) left = mid + 1;
            else if (square > x) right = mid - 1;
            else return mid;
        }
        return right;
    }
};

def my_sqrt(x: int) -> int:
    """
    @param x: non-negative integer
    @return:  integer square root (floor)
    """
    if x < 2:
        return x

    left, right = 1, x
    while left <= right:
        mid = left + (right - left) // 2
        square = mid * mid

        if square < x:
            left = mid + 1
        elif square > x:
            right = mid - 1
        else:
            return mid
    return right

#![allow(unused)]
fn main() {
impl Solution {
    /// @param x non-negative integer
    /// @return  integer square root (floor)
    pub fn my_sqrt(x: i32) -> i32 {
        if x < 2 { return x; }

        let mut left = 1i64;
        let mut right = x as i64;
        while left <= right {
            let mid = left + (right - left) / 2;
            let square = mid * mid;          // i64: mid² can overflow i32

            if square < x as i64 { left = mid + 1; }
            else if square > x as i64 { right = mid - 1; }
            else { return mid as i32; }
        }
        right as i32
    }
}
}

Dry run

Input: x = 8.

left=1, right=8
mid=4: 16 > 8 -> right=3
mid=2: 4 < 8 -> left=3
mid=3: 9 > 8 -> right=2
left=3 > right=2 -> exit.  return right = 2 ✓

The comparison walks the invariant: left stays ≤ √x (square too small), right stays ≥ √x (square too big). At exit they cross with right as the last “small enough” candidate — exactly the floor. x = 9: mid=5 (25>9 → r=4), mid=2 (4<9 → l=3), mid=3 (9==9 → return 3) ✓.

Complexity

Time. Halving the search range:

$$ T(x) = O(\log x) $$

Space. Scalars:

$$ S(x) = O(1) $$

Variants & follow-ups

• Find Peak Element (1.6) — the same search-over-values family.
• Split Array Largest Sum (1.20) — “binary search the answer” on a different monotone predicate.
• Interview follow-up: “Why mid.toLong() * mid and not mid * mid?” 46341² = 2147488281 > Int.MAX_VALUE — the product silently wraps in Int. The Long cast is the 1.x overflow lesson: the check happens before the arithmetic, not after.

1.20 Split Array Largest Sum

Source: src/main/kotlin/array/dp/SplitArrayLargestSum.kt Pattern: minimize the max — binary search the answer · Core page

The Problem

Split nums into k contiguous subarrays minimizing the largest sum among them.

• Constraints: $1 \le k \le n \le 1000$.

Examples

Input:  nums = [7,2,5,10,8], k = 2   -> Output: 18   ([7,2,5] and [10,8])
Input:  nums = [1,2,3,4,5], k = 2    -> Output: 9    ([1,2,3] and [4,5])

Intuition — “minimize the max” is binary-searchable

If a cap C can split the array into ≤ k parts each ≤ C, then any larger cap also works — monotone. Binary search the smallest feasible cap in [max(nums), sum(nums)]:

canSplit(C): greedy-pack: walk nums, start a new part whenever the running sum would exceed C.
             feasible iff parts ≤ k.

binary search: lo = max(nums), hi = sum(nums)
  mid = (lo + hi) / 2
  canSplit(mid) ? hi = mid : lo = mid + 1
return lo

Why max(nums) as the floor? No part can hold less than the biggest element — C < max(nums) is infeasible by construction. The 1.x “answer must lie in [lo, hi]” tightening.

Why greedy packing for feasibility? To test a cap, greedily extend the current part as far as possible — any feasible split can be rearranged into the greedy one (exchange argument), so the greedy part count is the minimum possible. The repo’s memoized DP (2.x dfs(i, splitsLeft) over prefix sums) is the exact alternative; the binary search is the canonical LeetCode answer.

Approach 1 — DP over (index, parts) (the repo’s version)

dfs(i, k) = min largest sum splitting nums[i:] into k parts (prefix-sum lookups, prune when currentSum > best): O(n²k).

Approach 2 — Binary search the answer (optimal)

class SplitArrayLargestSum {
    /**
     * @param nums input array
     * @param k    number of subarrays
     * @return     minimized largest subarray sum
     */
    fun splitArray(nums: IntArray, k: Int): Int {
        var lo = 0L
        var hi = 0L
        for (num in nums) { lo = maxOf(lo, num.toLong()); hi += num }

        fun canSplit(cap: Long): Boolean {
            var parts = 1
            var running = 0L
            for (num in nums) {
                if (running + num > cap) { parts++; running = 0 }
                running += num
            }
            return parts <= k
        }

        while (lo < hi) {
            val mid = lo + (hi - lo) / 2
            if (canSplit(mid)) hi = mid
            else lo = mid + 1
        }
        return lo.toInt()
    }
}

public class SplitArrayLargestSum {
    /**
     * @param nums input array
     * @param k    number of subarrays
     * @return     minimized largest subarray sum
     */
    public int splitArray(int[] nums, int k) {
        long lo = 0, hi = 0;
        for (int num : nums) { lo = Math.max(lo, num); hi += num; }

        while (lo < hi) {
            long mid = lo + (hi - lo) / 2;

            int parts = 1;
            long running = 0;
            for (int num : nums) {
                if (running + num > mid) { parts++; running = 0; }
                running += num;
            }

            if (parts <= k) hi = mid;
            else lo = mid + 1;
        }
        return (int) lo;
    }
}

#include <vector>
#include <algorithm>

class SplitArrayLargestSum {
public:
    /**
     * @param nums input array
     * @param k    number of subarrays
     * @return     minimized largest subarray sum
     */
    int splitArray(std::vector<int>& nums, int k) {
        long lo = 0, hi = 0;
        for (int num : nums) { lo = std::max(lo, (long)num); hi += num; }

        while (lo < hi) {
            long mid = lo + (hi - lo) / 2;

            int parts = 1;
            long running = 0;
            for (int num : nums) {
                if (running + num > mid) { parts++; running = 0; }
                running += num;
            }

            if (parts <= k) hi = mid;
            else lo = mid + 1;
        }
        return (int)lo;
    }
};

def split_array(nums: list[int], k: int) -> int:
    """
    @param nums: input array
    @param k:    number of subarrays
    @return:     minimized largest subarray sum
    """
    def can_split(cap: int) -> bool:
        parts = 1
        running = 0
        for num in nums:
            if running + num > cap:
                parts += 1
                running = 0
            running += num
        return parts <= k

    lo, hi = max(nums), sum(nums)
    while lo < hi:
        mid = (lo + hi) // 2
        if can_split(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums input array
    /// @param k    number of subarrays
    /// @return     minimized largest subarray sum
    pub fn split_array(nums: Vec<i32>, k: i32) -> i32 {
        let can_split = |cap: i64| -> bool {
            let mut parts = 1i64;
            let mut running = 0i64;
            for &num in &nums {
                if running + num as i64 > cap { parts += 1; running = 0; }
                running += num as i64;
            }
            parts <= k as i64
        };

        let mut lo = *nums.iter().max().unwrap() as i64;
        let mut hi: i64 = nums.iter().map(|&v| v as i64).sum();

        while lo < hi {
            let mid = lo + (hi - lo) / 2;
            if can_split(mid) { hi = mid; } else { lo = mid + 1; }
        }
        lo as i32
    }
}
}

Dry run

Input: nums = [7,2,5,10,8], k = 2.

lo = max = 10, hi = sum = 32
mid = 21: canSplit(21)? 7+2+5=14, +10=24 > 21 -> new part.  [14][10+8=18] = 2 parts ≤ 2 ✓ -> hi=21
mid = 15: 7+2+5=14, +10>15 -> [14][10], 8 -> 3 parts > 2 ✗ -> lo=16
mid = 18: 7+2+5=14, +10>18 -> [14][10], 8: 10+8=18 ≤ 18 -> [14][18] = 2 parts ✓ -> hi=18
mid = 17: 14, +10>17 -> [14][10], 8 -> 3 parts ✗ -> lo=18
lo == hi == 18.  Output: 18 ✓

The monotone predicate is the crux: cap 18 works (2 parts), cap 17 doesn’t (3 parts) — the boundary is exactly the answer. The greedy pack computes the minimum part count for each cap, and the search zooms to the smallest feasible cap.

Complexity

Time. O(n) feasibility × O(log Σ) iterations:

$$ T(n) = O(n \log \Sigma) $$

Space. Scalars:

$$ S(n) = O(1) $$

Variants & follow-ups

• Capacity To Ship Packages (1.2) — the same “minimize the max with a feasible-cap binary search”, with days instead of parts.
• Koko Eating Bananas (1.3) — the same shape, eating speed instead of cap.
• Interview follow-up: “Why is the greedy part count the minimum?” If a cap is feasible with some split, the greedy (extend each part maximally) uses at most as many parts — any split’s parts can be merged into greedier ones without exceeding the cap. So greedyParts ≤ any split's parts; testing greedyParts ≤ k decides feasibility exactly.

1.21 Search A 2D Matrix II

Source: src/main/kotlin/array/SearchA2dMatrix_II.kt Pattern: staircase search · Core page

The Problem

Search a target in a matrix sorted per row and per column (not globally).

• Constraints: m, n ≤ 300.

Examples

Input:  matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
Output: true

Intuition — start at the top-right; each step eliminates a row or column

At (row, col) (top-right), the cell is the row’s max and the column’s min. matrix[r][c] > target → the whole column is bigger → col--; < target → the whole row is smaller → row++:

var (row, col) = matrix.size - 1 to 0     // bottom-left works too

while (row >= 0 && col < matrix[0].size) {
    when {
        matrix[row][col] > target -> row--
        matrix[row][col] < target -> col++
        else -> return true
    }
}
return false

Why one elimination per step? The corner guarantees it: at the top-right, going left shrinks everything, going down grows everything — the binary-search “halve” becomes “eliminate a row or column”. O(m+n) steps.

Approach 1 — Binary search each row (O(m log n))

Correct, ignores the column ordering.

Approach 2 — Staircase walk (the repo’s version, optimal)

class SearchA2dMatrix_II {
    /**
     * @param matrix row-and-column sorted matrix
     * @param target search value
     * @return       true iff found
     */
    fun searchMatrix(matrix: Array<IntArray>, target: Int): Boolean {
        var (row, col) = matrix.size - 1 to 0

        while (row >= 0 && col < matrix[0].size) {
            when {
                matrix[row][col] > target -> row--
                matrix[row][col] < target -> col++
                else -> return true
            }
        }
        return false
    }
}

public class SearchA2DMatrixII {
    /**
     * @param matrix row-and-column sorted matrix
     * @param target search value
     * @return       true iff found
     */
    public boolean searchMatrix(int[][] matrix, int target) {
        int row = matrix.length - 1, col = 0;

        while (row >= 0 && col < matrix[0].length) {
            if (matrix[row][col] == target) return true;
            else if (matrix[row][col] > target) row--;
            else col++;
        }
        return false;
    }
}

#include <vector>

class SearchA2DMatrixII {
public:
    /**
     * @param matrix row-and-column sorted matrix
     * @param target search value
     * @return       true iff found
     */
    bool searchMatrix(std::vector<std::vector<int>>& matrix, int target) {
        int row = matrix.size() - 1, col = 0;

        while (row >= 0 && col < matrix[0].size()) {
            if (matrix[row][col] == target) return true;
            else if (matrix[row][col] > target) row--;
            else col++;
        }
        return false;
    }
};

def search_matrix(matrix: list[list[int]], target: int) -> bool:
    """
    @param matrix: row-and-column sorted matrix
    @param target: search value
    @return:       true iff found
    """
    row, col = len(matrix) - 1, 0

    while row >= 0 and col < len(matrix[0]):
        if matrix[row][col] == target:
            return True
        elif matrix[row][col] > target:
            row -= 1
        else:
            col += 1

    return False

#![allow(unused)]
fn main() {
impl Solution {
    /// @param matrix row-and-column sorted matrix
    /// @param target search value
    /// @return       true iff found
    pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
        let (mut row, mut col) = (matrix.len() as i32 - 1, 0);

        while row >= 0 && (col as usize) < matrix[0].len() {
            let cell = matrix[row as usize][col as usize];
            if cell == target { return true; }
            else if cell > target { row -= 1; }
            else { col += 1; }
        }
        false
    }
}
}

Dry run

Input: the example, target = 5.

start (4,0)=18 > 5 -> row 3.  (3,0)=10 > 5 -> row 2.  (2,0)=3 < 5 -> col 1.
(2,1)=6 > 5 -> row 1.  (1,1)=5 == 5 -> true ✓

Each step shrinks the search space by a full row or column — the walk can’t loop (row only decreases, col only increases).

Complexity

Time. At most m+n steps:

$$ T(m, n) = O(m + n) $$

Space. Constants:

$$ S(m, n) = O(1) $$

Variants & follow-ups

• Search A 2D Matrix (1.5) — the globally-sorted version (true binary search).
• Interview follow-up: “Why the corner and not the center?” The corner has the row-max/column-min property that makes every comparison decisive — the center doesn’t. The corner choice is the entire algorithm.

1.18 Search Insert Position

Source: src/main/kotlin/binarysearch/SearchInsertionPosition.kt Pattern: lower bound · Core page (this is the “hello world” of binary search)

The Problem

Given a sorted array of distinct integers and a target, return the index where target is found, or the index where it would be inserted to keep the array sorted.

• Constraints: $1 \le n \le 10^4$.

Examples

Input:  nums = [1, 3, 5, 6], target = 5  -> Output: 2   (found at index 2)
Input:  nums = [1, 3, 5, 6], target = 2  -> Output: 1   (would sit between 1 and 3)
Input:  nums = [1, 3, 5, 6], target = 7  -> Output: 4   (would be appended)
Input:  nums = [1, 3, 5, 6], target = 0  -> Output: 0   (would be prepended)

Intuition

The required answer is exactly the first index where nums[i] >= target — the lower bound of target:

• if target exists, that index is where it is (found),
• if not, that index is the insertion point (the first element bigger than it).

This is Template A (1.0) with predicate $P(i) = nums[i] \ge target$ over the inclusive range $[0, n]$, where index n represents “beyond the end” (always true — an imaginary sentinel). The loop converges to the first true, and returning it answers both cases with one mechanism.

The subtle bit: the search space must include n (append case). That’s why right starts at nums.size, not nums.size - 1.

Approach 1 — Linear scan

Walk the array until nums[i] >= target. $O(n)$. Fine for $n \le 10^4$, but this problem is the canonical building block (it’s the insertion step of binary insertion sort, and the find step of many range structures), so the $O(\log n)$ version is the one that matters.

Approach 2 — Lower-bound binary search (optimal)

/**
 * @param nums   the sorted array of distinct integers
 * @param target the value to find or insert
 * @return       the index of target if present, else the index where it would be inserted
 */
fun searchInsert(nums: IntArray, target: Int): Int {
    var start = 0
    var end = nums.size            // EXCLUSIVE upper bound: index n is the "append" sentinel

    while (start < end) {
        val mid = start + (end - start) / 2
        when {
            nums[mid] == target -> return mid
            nums[mid] > target  -> end = mid        // target would go before mid
            else                -> start = mid + 1  // target goes after mid
        }
    }
    return start
}

public class SearchInsertPosition {
    /**
     * @param nums   the sorted array of distinct integers
     * @param target the value to find or insert
     * @return       the index of target if present, else the index where it would be inserted
     */
    public int searchInsert(int[] nums, int target) {
        int start = 0, end = nums.length;           // end is exclusive (append sentinel)
        while (start < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] == target) return mid;
            if (nums[mid] > target) end = mid;
            else start = mid + 1;
        }
        return start;
    }
}

#include <vector>

class SearchInsertPosition {
public:
    /**
     * @param nums   the sorted array of distinct integers
     * @param target the value to find or insert
     * @return       the index of target if present, else the index where it would be inserted
     */
    int searchInsert(const std::vector<int>& nums, int target) {
        int start = 0, end = (int)nums.size();      // end is exclusive
        while (start < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] == target) return mid;
            if (nums[mid] > target) end = mid;
            else start = mid + 1;
        }
        return start;
    }
};

def search_insert(nums: list[int], target: int) -> int:
    """
    @param nums:   the sorted array of distinct integers
    @param target: the value to find or insert
    @return:       the index of target if present, else the index where it would be inserted
    """
    start, end = 0, len(nums)         # end is exclusive (append sentinel)
    while start < end:
        mid = start + (end - start) // 2
        if nums[mid] == target:
            return mid
        if nums[mid] > target:
            end = mid
        else:
            start = mid + 1
    return start

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums   the sorted array of distinct integers
    /// @param target the value to find or insert
    /// @return       the index of target if present, else the index where it would be inserted
    pub fn search_insert(nums: Vec<i32>, target: i32) -> i32 {
        let (mut start, mut end) = (0usize, nums.len());   // end is exclusive
        while start < end {
            let mid = start + (end - start) / 2;
            if nums[mid] == target {
                return mid as i32;
            }
            if nums[mid] > target {
                end = mid;
            } else {
                start = mid + 1;
            }
        }
        start as i32
    }
}
}

Dry run

Input: nums = [1, 3, 5, 6], target = 2

start=0  end=4  mid=2  nums[2]=5 > 2 -> end=2
start=0  end=2  mid=1  nums[1]=3 > 2 -> end=1
start=0  end=1  mid=0  nums[0]=1 < 2 -> start=1
start=1  end=1  -> return 1 ✓   (between 1 and 3)

Input: nums = [1, 3, 5, 6], target = 7

start=0  end=4  mid=2  nums[2]=5 < 7 -> start=3
start=3  end=4  mid=3  nums[3]=6 < 7 -> start=4
start=4  end=4  -> return 4 ✓   (append; the sentinel index was reached without ever reading out of bounds)

Input: nums = [1, 3, 5, 6], target = 0

start=0  end=4  mid=2  nums[2]=5 > 0 -> end=2
start=0  end=2  mid=1  nums[1]=3 > 0 -> end=1
start=0  end=1  mid=0  nums[0]=1 > 0 -> end=0
start=0  end=0  -> return 0 ✓   (prepend)

Notice the loop never reads nums[end] — that’s what makes the exclusive bound safe: the append case (target=7) terminates with start == end == 4 before any out-of-bounds access.

Complexity

Time.

$$ T(n) = \lceil \log_2(n+1) \rceil = O(\log n) $$

Space. $O(1)$.

Variants & follow-ups

• Find First And Last Position (1.3) — two lower-bound searches (one for >= target, one for > target), same machinery.
• Kth Missing Positive Number (1.11) — a lower bound on a derived array (arr[i] - i - 1 = missing count).
• Interview follow-up: “Change the code to find the last index where nums[i] <= target.” Swap the branches (start = mid when true, with care for the infinite-loop trap) — the mirror-image of this page. Knowing both directions = owning the pattern.
• Interview follow-up: “Why doesn’t end ever go below start?” The exclusive bound + start = mid + 1 guarantee strict progress; the only way to loop forever would be start = mid with end = start + 1, which this template never does.

1.19 Single Element In A Sorted Array

Source: src/main/kotlin/binarysearch/SingleElementInASortedArray.kt Pattern: parity-based search · Gym page

The Problem

You are given a sorted array where every element appears exactly twice, except one element that appears exactly once. Find that single element. Must run in $O(\log n)$ and use $O(1)$ space.

• Constraints: $1 \le n \le 10^5$, n is odd.

Examples

Input:  nums = [1, 1, 2, 3, 3, 4, 4, 8, 8]
Output: 2

Input:  nums = [3, 3, 7, 7, 10, 11, 11]
Output: 10

Intuition — pairs line up, until they don’t

Before the single element, the array reads as perfect pairs starting at even indices:

index:  0  1  2  3  4  5  6  7  8
nums:   1  1  2  3  3  4  4  8  8
        └─┘  └────┘  └────┘  └────┘   (pairs before the lone 2 at index 2)
               ^
        first pair that is BROKEN = (index 2, 3) -> the lone element is at index 2

After the single element, every pair starts at an odd index:

index:  0  1  2  3  4  5  6
nums:   3  3  7  7  10 11 11
                    └──┘  └──┘        (pairs after the lone 10 at index 4)

So the invariant is: for every index i strictly before the lone element, nums[2i] == nums[2i+1]; at and after it, the pair structure is shifted by one. We can test the “healthy pair” property at any even position e:

$$ P(e) = (nums[e] == nums[e+1]) $$

$P$ is true before the single element and false from the single element onward — monotone! Find the first false (Template A), and the answer is nums[firstFalse * 2]… more concretely, with the classic trick: force mid to be even, then:

• if nums[mid] == nums[mid + 1] → pairs intact at mid → lone element is to the right → low = mid + 2,
• else → the lone element is at mid or to its left → high = mid.

Forcing mid even (if (mid % 2 == 1) mid--) guarantees we only ever compare the first member of a potential pair with its partner. The loop converges to the lone element’s position.

Approach 1 — XOR everything

XOR of all elements: paired values cancel ($x \oplus x = 0$), leaving the lone value. $O(n)$ time, $O(1)$ space. Correct — and the fastest constant — but it doesn’t use the sorted structure, so the $O(\log n)$ requirement fails.

Approach 2 — Parity binary search (optimal)

/**
 * @param nums the sorted array where every value repeats twice except one
 * @return     the value that appears exactly once
 */
fun singleNonDuplicate(nums: IntArray): Int {
    var low = 0
    var high = nums.size - 1

    while (low < high) {
        var mid = low + (high - low) / 2
        // Force mid to be even so we always compare the first element of a pair.
        if (mid % 2 == 1) {
            mid--
        }

        if (nums[mid] == nums[mid + 1]) {
            low = mid + 2      // pair intact -> lone element is to the right
        } else {
            high = mid         // pair broken -> lone element is at or left of mid
        }
    }
    return nums[low]
}

public class SingleElementInSortedArray {
    /**
     * @param nums the sorted array where every value repeats twice except one
     * @return     the value that appears exactly once
     */
    public int singleNonDuplicate(int[] nums) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (mid % 2 == 1) mid--;               // make mid even
            if (nums[mid] == nums[mid + 1]) {
                low = mid + 2;                     // pair intact -> right side
            } else {
                high = mid;                        // pair broken -> at or left
            }
        }
        return nums[low];
    }
}

#include <vector>

class SingleElementInSortedArray {
public:
    /**
     * @param nums the sorted array where every value repeats twice except one
     * @return     the value that appears exactly once
     */
    int singleNonDuplicate(const std::vector<int>& nums) {
        int low = 0, high = (int)nums.size() - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (mid % 2 == 1) mid--;
            if (nums[mid] == nums[mid + 1]) low = mid + 2;
            else high = mid;
        }
        return nums[low];
    }
};

def single_non_duplicate(nums: list[int]) -> int:
    """
    @param nums: the sorted array where every value repeats twice except one
    @return:     the value that appears exactly once
    """
    low, high = 0, len(nums) - 1
    while low < high:
        mid = low + (high - low) // 2
        if mid % 2 == 1:
            mid -= 1                       # make mid even
        if nums[mid] == nums[mid + 1]:
            low = mid + 2                  # pair intact -> right side
        else:
            high = mid                     # pair broken -> at or left
    return nums[low]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the sorted array where every value repeats twice except one
    /// @return     the value that appears exactly once
    pub fn single_non_duplicate(nums: Vec<i32>) -> i32 {
        let (mut low, mut high) = (0usize, nums.len() - 1);
        while low < high {
            let mut mid = low + (high - low) / 2;
            if mid % 2 == 1 {
                mid -= 1;                  // make mid even
            }
            if nums[mid] == nums[mid + 1] {
                low = mid + 2;             // pair intact -> right side
            } else {
                high = mid;                // pair broken -> at or left
            }
        }
        nums[low]
    }
}
}

Dry run

Input: nums = [1, 1, 2, 3, 3, 4, 4, 8, 8]

low=0  high=8  mid=4  even -> compare nums[4]=3 vs nums[5]=4  -> 3 != 4 BROKEN -> high=4
low=0  high=4  mid=2  even -> compare nums[2]=2 vs nums[3]=3  -> 2 != 3 BROKEN -> high=2
low=0  high=2  mid=1  odd -> mid=0 -> compare nums[0]=1 vs nums[1]=1 -> 1 == 1 INTACT -> low=2
low=2  high=2  -> return nums[2] = 2 ✓

Every broken pair tells us the lone element is at mid or to its left; every intact pair pushes us right. The parity trick (mid-- when odd) means we always compare the left member of a pair with its partner — without it, comparing nums[odd] with nums[odd+1] would be comparing across a boundary (two different pairs), and the test would be meaningless.

Input: nums = [3, 3, 7, 7, 10, 11, 11]

low=0  high=6  mid=3  odd -> mid=2 -> compare nums[2]=7 vs nums[3]=7 -> INTACT -> low=4
low=4  high=6  mid=5  odd -> mid=4 -> compare nums[4]=10 vs nums[5]=11 -> BROKEN -> high=4
low=4  high=4  -> return nums[4] = 10 ✓

Complexity

Time. Each iteration halves the range; the parity fix is $O(1)$:

$$ T(n) = O(\log n) $$

Space. $O(1)$.

Variants & follow-ups

• Find Minimum In Rotated Sorted Array (1.5) — same “monotone property on indices” style; here the property is pair health, there it’s “which run am I in”.
• XOR approach — always mention it as the constant-time-optimization alternative when the array needn’t be sorted; interviewers love hearing both.
• Interview follow-up: “Why must n be odd?” Because $n = 2t + 1$: t pairs plus the lone element. The parity argument (mid even ⇒ pair boundary) relies on it.
• Interview follow-up: “Now values can repeat more than twice (e.g. triples).” The pair-parity argument collapses; you’d need a different predicate (compare against nums[0] runs) — a good place to stop and say “the structure is gone”.

1.20 Valley Element

Source: src/main/kotlin/binarysearch/ValleyElement.kt Pattern: monotone slope descent (mirror) · Variant page

The Problem

A valley (local minimum) in an array is an element strictly smaller than both its neighbors, with the boundaries treated as $+\infty$ (Int.MAX_VALUE). The repository ships two variants:

• findValleyElementBinary — returns the value of any valley,
• findValley — returns the value of any valley with a slightly different branch ordering.

Return the value of any valley, or null/-1 for an empty array.

Examples

Input:  nums = [5, 3, 1, 2, 4]      -> Output: 1   (the minimum, and a valley)
Input:  nums = [5, 4, 3, 2, 1]      -> Output: 1   (monotone decreasing; last element is a valley: right neighbor = +∞)
Input:  nums = [1, 2, 3, 4, 5]      -> Output: 1   (monotone increasing; first element is a valley: left neighbor = +∞)

Intuition — mirror of the peak

1.6 climbs toward a peak; this problem descends toward a valley. The slope test is flipped:

• nums[mid] > nums[mid + 1] — the array is falling at mid → a valley exists strictly to the right → left = mid + 1.
• otherwise (nums[mid] < nums[mid + 1]) — rising at mid → a valley exists at mid or to its left → right = mid.

The correctness argument is the mirror of the peak argument: a falling prefix either reaches the last element (a valley because its right neighbor is $+\infty$) or turns upward (the turn is a valley). One of those must happen, so the right half provably contains a valley.

The boundary-safe version reads both neighbors with Int.MAX_VALUE sentinels and can early-return on a direct hit — exactly the pattern of 1.7.

Approach — valley-descent binary search

/**
 * @param nums the input array (boundaries treated as +infinity)
 * @return     the value of any valley element, or null if nums is empty
 */
fun findValleyElementBinary(nums: IntArray): Int? {
    if (nums.isEmpty()) return null

    var (left, right) = 0 to nums.size

    while (left < right) {
        val mid = left + (right - left) / 2

        // Sentinel reads: outside the array counts as +infinity.
        val leftNeighbor  = if (mid > 0) nums[mid - 1] else Int.MAX_VALUE
        val rightNeighbor = if (mid < nums.size - 1) nums[mid + 1] else Int.MAX_VALUE

        when {
            // Direct hit: strictly smaller than both neighbors.
            nums[mid] < leftNeighbor && nums[mid] < rightNeighbor -> return nums[mid]
            // Still falling to the right -> valley is strictly to the right.
            nums[mid] > rightNeighbor -> left = mid + 1
            // Rising to the left -> valley is at or to the left.
            else -> right = mid
        }
    }
    return null // Unreachable for a valid non-empty array
}

/**
 * @param arr the input array (boundaries treated as +infinity)
 * @return    the value of any valley element, or null if arr is empty
 */
fun findValley(arr: IntArray): Int? {
    if (arr.isEmpty()) return null
    if (arr.size == 1) return arr[0]

    var low = 0
    var high = arr.size - 1
    while (low <= high) {
        val mid = low + (high - low) / 2
        val leftVal  = if (mid > 0) arr[mid - 1] else Int.MAX_VALUE
        val rightVal = if (mid < arr.size - 1) arr[mid + 1] else Int.MAX_VALUE

        when {
            arr[mid] <= leftVal && arr[mid] <= rightVal -> return arr[mid]
            leftVal < arr[mid] -> high = mid - 1   // moving toward the descending slope
            else               -> low = mid + 1
        }
    }
    return null
}

public class ValleyElement {
    /**
     * @param nums the input array (boundaries treated as +infinity)
     * @return     the value of any valley element, or -1 if nums is empty
     */
    public int findValleyElementBinary(int[] nums) {
        if (nums.length == 0) return -1;
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + (right - left) / 2;
            int leftNeighbor  = mid > 0 ? nums[mid - 1] : Integer.MAX_VALUE;
            int rightNeighbor = mid < nums.length - 1 ? nums[mid + 1] : Integer.MAX_VALUE;
            if (nums[mid] < leftNeighbor && nums[mid] < rightNeighbor) return nums[mid];
            if (nums[mid] > rightNeighbor) left = mid + 1;
            else right = mid;
        }
        return -1;
    }
}

#include <vector>
#include <climits>

class ValleyElement {
public:
    /**
     * @param nums the input array (boundaries treated as +infinity)
     * @return     the value of any valley element, or -1 if nums is empty
     */
    int findValleyElementBinary(const std::vector<int>& nums) {
        if (nums.empty()) return -1;
        int left = 0, right = (int)nums.size();
        while (left < right) {
            int mid = left + (right - left) / 2;
            int leftNeighbor  = mid > 0 ? nums[mid - 1] : INT_MAX;
            int rightNeighbor = mid < (int)nums.size() - 1 ? nums[mid + 1] : INT_MAX;
            if (nums[mid] < leftNeighbor && nums[mid] < rightNeighbor) return nums[mid];
            if (nums[mid] > rightNeighbor) left = mid + 1;
            else right = mid;
        }
        return -1;
    }
};

def find_valley(nums: list[int]) -> int:
    """
    @param nums: the input array (boundaries treated as +infinity)
    @return:     the value of any valley element, or -1 if nums is empty
    """
    if not nums:
        return -1
    left, right = 0, len(nums)
    while left < right:
        mid = left + (right - left) // 2
        left_neighbor  = nums[mid - 1] if mid > 0 else float("inf")
        right_neighbor = nums[mid + 1] if mid < len(nums) - 1 else float("inf")
        if nums[mid] < left_neighbor and nums[mid] < right_neighbor:
            return nums[mid]
        if nums[mid] > right_neighbor:
            left = mid + 1
        else:
            right = mid
    return -1

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the input array (boundaries treated as +infinity)
    /// @return     the value of any valley element, or -1 if nums is empty
    pub fn find_valley(nums: Vec<i32>) -> i32 {
        if nums.is_empty() {
            return -1;
        }
        let (mut left, mut right) = (0usize, nums.len());
        while left < right {
            let mid = left + (right - left) / 2;
            let left_neighbor  = if mid > 0 { nums[mid - 1] } else { i32::MAX };
            let right_neighbor = if mid + 1 < nums.len() { nums[mid + 1] } else { i32::MAX };
            if nums[mid] < left_neighbor && nums[mid] < right_neighbor {
                return nums[mid];
            }
            if nums[mid] > right_neighbor {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        -1
    }
}
}

Dry run

Input: nums = [5, 3, 1, 2, 4]

left=0  right=5  mid=2  nums[2]=1, L=3, R=2
  1 < 3 && 1 < 2? YES -> return 1 ✓

Input: nums = [5, 4, 3, 2, 1] (monotone decreasing — valley at the end)

left=0  right=5  mid=2  nums[2]=3, L=4, R=2
  3 < 4 && 3 < 2? NO  |  3 > 2 (falling) -> left=3
left=3  right=5  mid=4  nums[4]=1, L=2, R=+inf
  1 < 2 && 1 < +inf? YES -> return 1 ✓   (the right sentinel certifies the last element)

Input: nums = [1, 2, 3, 4, 5] (monotone increasing — valley at the start)

left=0  right=5  mid=2  nums[2]=3, L=2, R=4
  3 < 2 && 3 < 4? NO  |  3 > 4? NO -> right=2
left=0  right=2  mid=1  nums[1]=2, L=1, R=3
  2 < 1? NO | 2 > 3? NO -> right=1
left=0  right=1  mid=0  nums[0]=1, L=+inf, R=2
  1 < +inf && 1 < 2? YES -> return 1 ✓   (the left sentinel certifies the first element)

Complexity

Time. $O(\log n)$ — the sentinel reads keep every step at constant work.

Space. $O(1)$.

Variants & follow-ups

• 1.6 / 1.7 — the peak twin; flip every comparison and swap MIN/MAX sentinels to get this page.
• Find the maximum of a bitonic array — same structure, “climb the slope” the other way.
• Interview follow-up: “What if the array has a plateau of equal values?” The </> comparisons break (a flat run is neither rising nor falling). With <= and >= the algorithm still returns some valley of the flattened array, but the guarantee weakens — another reason the boundary-safe style with explicit neighbor checks is preferred when inputs are messy.

1.21 Apartment Hunting

Source: src/main/kotlin/binarysearch/ApartmentHunting.kt Pattern: binary search + nearest-neighbor · Gym page

The Problem

You’re apartment-hunting on a street of B blocks. Each block is a map of amenities → boolean (does this block have a gym/school/store?). You need a set of required amenities. Define the score of a block as the maximum distance from it to the nearest block providing each required amenity. Find the block with the minimum score. Return its index (or -1 if any required amenity is missing from the street entirely).

• Constraints: small B (≤ 100 in practice), few amenities.

Examples

blocks = [
  {gym: false, school: true,  store: false},
  {gym: true,  school: false, store: false},
  {gym: true,  school: true,  store: false},
  {gym: false, school: true,  store: false},
  {gym: false, school: true,  store: true}
]
requirements = [gym, school, store]

Block 3 is optimal: gym at distance 1, school at 0, store at 1 -> score = max(1, 0, 1) = 1.

Intuition — turn “nearest distance” into a binary search

The naive plan: for each block and each required amenity, scan all blocks to find the nearest one with that amenity. That’s $O(B^2 R)$ — fine for tiny inputs, but the interesting refinement is:

1. Precompute, for each amenity, the sorted list of block indices that have it. (A simple pass over the blocks: $O(B \cdot A)$ where A is amenities per block.)
2. For a query block b, the nearest block with a given amenity is the nearest neighbor of b in that sorted list — found by binary search on the list ($O(\log K)$ where $K$ = number of blocks with that amenity), checking the two candidates around b’s insertion point.

Then the score of b is the max over all required amenities of these nearest distances: $O(R \log K)$ per block, $O(B R \log K)$ total. The binary search here is the classic library function — the same lower-bound idea from 1.18, used as a subroutine.

The repo also ships a hand-rolled binarySearch that returns the insertion point as -(low + 1) on a miss — the standard C-style convention — which makes the “candidate check” code explicit and self-contained.

Approach 1 — Brute force (all-pairs scan)

For each block, for each requirement, scan every block. $O(B^2 R)$. Simple, obviously correct; use it to validate the fast version.

Approach 2 — Amenity lists + binary-search nearest neighbor (optimal)

/**
 * @param blocks      each block maps amenity name -> presence (true/false)
 * @param requirements the amenities the apartment must be near
 * @return            the index of the block minimizing the max distance to every
 *                    required amenity, or -1 if any required amenity is absent citywide
 */
fun findBestBlock(blocks: List<Map<String, Boolean>>, requirements: List<String>): Int {
    // Step 1: amenity -> sorted list of blocks that have it.
    val amenityMap = mutableMapOf<String, MutableList<Int>>()
    blocks.forEachIndexed { index, block ->
        block.forEach { (amenity, present) ->
            if (present) {
                amenityMap.getOrPut(amenity) { mutableListOf() }.add(index)
            }
        }
    }

    // Any missing requirement makes the whole hunt impossible.
    requirements.forEach {
        if (amenityMap[it].isNullOrEmpty()) return -1
    }

    // Step 2: for each block, max over requirements of the nearest distance.
    var bestBlock = -1
    var bestMaxDistance = Int.MAX_VALUE

    blocks.forEachIndexed { index, _ ->
        val maxDistance = requirements
            .map { amenity -> closestDistance(index, amenityMap[amenity]!!) }
            .maxOrNull()!!

        if (maxDistance < bestMaxDistance) {
            bestMaxDistance = maxDistance
            bestBlock = index
        }
    }
    return bestBlock
}

/**
 * @param blockIndex      the block we are scoring
 * @param blocksWithAmenity the sorted list of blocks that have the amenity
 * @return                the minimum distance from blockIndex to a block with the amenity
 */
fun closestDistance(blockIndex: Int, blocksWithAmenity: List<Int>): Int {
    val pos = blocksWithAmenity.binarySearch(blockIndex)   // standard lower-bound search
    return if (pos >= 0) 0                                  // the block itself has it
    else {
        val insertPoint = -pos - 1
        val leftDistance = if (insertPoint > 0) blockIndex - blocksWithAmenity[insertPoint - 1] else Int.MAX_VALUE
        val rightDistance = if (insertPoint < blocksWithAmenity.size) blocksWithAmenity[insertPoint] - blockIndex else Int.MAX_VALUE
        minOf(leftDistance, rightDistance)
    }
}

The other languages use their standard library’s binary-search-with-insertion-point. Kotlin’s binarySearch returns -insertionPoint - 1 on a miss (same convention as Java’s Collections.binarySearch), which is exactly what closestDistance exploits.

import java.util.*;

public class ApartmentHunting {
    /**
     * @param blocks       each block maps amenity name -> presence
     * @param requirements the amenities the apartment must be near
     * @return             index of the optimal block, or -1 if a requirement is missing citywide
     */
    public int findBestBlock(List<Map<String, Boolean>> blocks, List<String> requirements) {
        Map<String, List<Integer>> amenityMap = new HashMap<>();
        for (int i = 0; i < blocks.size(); i++) {
            for (Map.Entry<String, Boolean> e : blocks.get(i).entrySet()) {
                if (e.getValue()) {
                    amenityMap.computeIfAbsent(e.getKey(), k -> new ArrayList<>()).add(i);
                }
            }
        }
        for (String req : requirements) {
            if (!amenityMap.containsKey(req)) return -1;
        }

        int bestBlock = -1, bestScore = Integer.MAX_VALUE;
        for (int i = 0; i < blocks.size(); i++) {
            int score = 0;
            for (String req : requirements) {
                score = Math.max(score, closestDistance(i, amenityMap.get(req)));
            }
            if (score < bestScore) { bestScore = score; bestBlock = i; }
        }
        return bestBlock;
    }

    /**
     * @param blockIndex the block being scored
     * @param blocksWithAmenity sorted list of blocks having the amenity
     * @return           minimum distance to such a block
     */
    private int closestDistance(int blockIndex, List<Integer> blocksWithAmenity) {
        int pos = Collections.binarySearch(blocksWithAmenity, blockIndex);
        if (pos >= 0) return 0;
        int insertPoint = -pos - 1;
        int left = insertPoint > 0 ? blockIndex - blocksWithAmenity.get(insertPoint - 1) : Integer.MAX_VALUE;
        int right = insertPoint < blocksWithAmenity.size() ? blocksWithAmenity.get(insertPoint) - blockIndex : Integer.MAX_VALUE;
        return Math.min(left, right);
    }
}

#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <climits>

class ApartmentHunting {
public:
    /**
     * @param blocks       each block maps amenity name -> presence
     * @param requirements the amenities the apartment must be near
     * @return             index of the optimal block, or -1 if a requirement is missing citywide
     */
    int findBestBlock(const std::vector<std::map<std::string, bool>>& blocks,
                      const std::vector<std::string>& requirements) {
        std::map<std::string, std::vector<int>> amenityMap;
        for (int i = 0; i < (int)blocks.size(); i++) {
            for (const auto& [amenity, present] : blocks[i]) {
                if (present) amenityMap[amenity].push_back(i);
            }
        }
        for (const auto& req : requirements) {
            if (!amenityMap.count(req)) return -1;
        }

        int bestBlock = -1, bestScore = INT_MAX;
        for (int i = 0; i < (int)blocks.size(); i++) {
            int score = 0;
            for (const auto& req : requirements) {
                score = std::max(score, closestDistance(i, amenityMap[req]));
            }
            if (score < bestScore) { bestScore = score; bestBlock = i; }
        }
        return bestBlock;
    }

private:
    /**
     * @param blockIndex       the block being scored
     * @param blocksWithAmenity sorted list of blocks having the amenity
     * @return                 minimum distance to such a block
     */
    int closestDistance(int blockIndex, const std::vector<int>& blocksWithAmenity) {
        auto it = std::lower_bound(blocksWithAmenity.begin(), blocksWithAmenity.end(), blockIndex);
        if (it != blocksWithAmenity.end() && *it == blockIndex) return 0;
        int left = INT_MAX, right = INT_MAX;
        if (it != blocksWithAmenity.begin()) left = blockIndex - *(it - 1);
        if (it != blocksWithAmenity.end())  right = *it - blockIndex;
        return std::min(left, right);
    }
};

from bisect import bisect_left

def find_best_block(blocks: list[dict[str, bool]], requirements: list[str]) -> int:
    """
    @param blocks:       each block maps amenity name -> presence
    @param requirements: the amenities the apartment must be near
    @return:             index of the optimal block, or -1 if a requirement is missing citywide
    """
    amenity_map: dict[str, list[int]] = {}
    for index, block in enumerate(blocks):
        for amenity, present in block.items():
            if present:
                amenity_map.setdefault(amenity, []).append(index)

    for req in requirements:
        if req not in amenity_map:
            return -1

    def closest_distance(block_index: int, positions: list[int]) -> int:
        """
        @param block_index: the block being scored
        @param positions:   sorted list of blocks having the amenity
        @return:            minimum distance to such a block
        """
        pos = bisect_left(positions, block_index)
        if pos < len(positions) and positions[pos] == block_index:
            return 0
        left = block_index - positions[pos - 1] if pos > 0 else float("inf")
        right = positions[pos] - block_index if pos < len(positions) else float("inf")
        return min(left, right)

    best_block, best_score = -1, float("inf")
    for index in range(len(blocks)):
        score = max(closest_distance(index, amenity_map[req]) for req in requirements)
        if score < best_score:
            best_score, best_block = score, index
    return best_block

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param blocks       each block maps amenity name -> presence
    /// @param requirements the amenities the apartment must be near
    /// @return             index of the optimal block, or -1 if a requirement is missing citywide
    pub fn find_best_block(
        blocks: Vec<HashMap<String, bool>>,
        requirements: Vec<String>,
    ) -> i32 {
        let mut amenity_map: HashMap<String, Vec<i32>> = HashMap::new();
        for (i, block) in blocks.iter().enumerate() {
            for (amenity, present) in block {
                if *present {
                    amenity_map.entry(amenity.clone()).or_default().push(i as i32);
                }
            }
        }
        for req in &requirements {
            if !amenity_map.contains_key(req) {
                return -1;
            }
        }

        let mut best_block = -1;
        let mut best_score = i32::MAX;
        for i in 0..blocks.len() as i32 {
            let mut score = 0;
            for req in &requirements {
                let positions = &amenity_map[req];
                score = score.max(Self::closest_distance(i, positions));
            }
            if score < best_score {
                best_score = score;
                best_block = i;
            }
        }
        best_block
    }

    /// @param block_index the block being scored
    /// @param positions   sorted list of blocks having the amenity
    /// @return            minimum distance to such a block
    fn closest_distance(block_index: i32, positions: &[i32]) -> i32 {
        match positions.binary_search(&block_index) {
            Ok(_) => 0,
            Err(insert_point) => {
                let left = if insert_point > 0 { block_index - positions[insert_point - 1] } else { i32::MAX };
                let right = if insert_point < positions.len() { positions[insert_point] - block_index } else { i32::MAX };
                left.min(right)
            }
        }
    }
}
}

Dry run

Input: the example blocks above. Step 1 builds the amenity lists:

gym    -> [1, 2]
school -> [0, 2, 3, 4]
store  -> [4]

Step 2 scores each block (nearest distances per requirement):

Trace closestDistance(3, gym = [1, 2]): binary search for 3 in [1, 2] → miss, insertion point 2 → left candidate = 3 − 2 = 1, no right candidate → 1. ✓

Trace closestDistance(3, store = [4]): binary search for 3 → miss, insertion point 0 → right candidate = 4 − 3 = 1 → 1. ✓

Block 3 wins with score 1 — matching the problem’s stated answer. The binary search only ever inspects the two neighbors of the insertion point, not all blocks.

Complexity

Preprocessing: $O(B \cdot A)$ to build the amenity lists (A amenities per block).

Scoring: for each of $B$ blocks and $R$ requirements, one binary search over a list of size $K$ (max blocks sharing an amenity):

$$ T(B, R) = O(B \cdot R \cdot \log K), \qquad S = O(B \cdot A) $$

With $B = 100$, that’s ~100 × 3 × 7 ≈ 2100 operations — vs 30,000 for the brute force — and the gap widens as the street grows.

Variants & follow-ups

• Best Time To Buy And Sell Stock (same “min over blocks” pattern? no — the nearest-neighbor idea recurs in range-query problems, e.g. finding the closest greater element).
• Interview follow-up: “Solve it in $O(B \cdot R)$ with two passes.” For each amenity, do a left-to-right pass recording “distance to nearest on the left” and a right-to-left pass for “nearest on the right”; then score[b] = max over amenities of min(left[b], right[b]). This removes the log factor and is the “optimal” answer interviewers often expect — the binary search version trades a pass for an index structure. Both are worth narrating.
• Interview follow-up: “What if requirements are huge?” Precompute nearest[i][amenity] for all amenities in the two-pass way; queries then become $O(1)$ per block-amenity pair. The binary search version wins when only a small subset of amenities is queried.

Chapter 2 — Dynamic Programming

Source: src/main/kotlin/dynamic_programming/, src/main/kotlin/array/dp/, src/main/kotlin/graph/dp/ (and friends)

Master idea: DP is organized recursion — the same subproblems, computed once, reused many times. Every DP in this book is: state → recurrence → base case → answer, and the “aha” is always discovering the right state.

Prerequisites: the recurrence math in Reference §4.

Problems at a glance

| 2.14 | Count Ways To Pick K Coins Divisible By M | memoized (idx, k, rem) | $O(nkm)$ | → | | 2.15 | Maximal Square | min-of-three DP | $O(mn)$ | → | | 2.16 | Coin Change | unbounded-knapsack minimization | $O(AC)$ | → | | 2.17 | House Robber | include/exclude two-variable DP | $O(n)$ | → | | 2.18 | Maximum Subarray | Kadane best-ending-here | $O(n)$ | → | | 2.19 | Longest Increasing Subsequence | dp over all previous | $O(n^2)$ | → | | 2.20 | Burst Balloons | interval DP + sentinels | $O(n^3)$ | → | | 2.21 | Target Sum | (index, sum) memo | $O(nS)$ | → | | 2.22 | Interleaving String | (i, j) matching memo | $O(mn)$ | → | | 2.23 | Regular Expression Matching | (i, j) memo with * | $O(mn)$ | → | | 2.24 | Delete Operations For Two Strings | LCS → deletions | $O(mn)$ | → | | 2.25 | Cherry Pickup | two-walker DP | $O(n^3)$ | → | | 2.26 | Racecar | (pos, speed) DFS | $O(win·sp)$ | → | | 2.27 | Min Taps To Water Garden | interval covering greedy | $O(n)$ | → | | 2.28 | Shortest Common Supersequence | LCS + backtrace | $O(mn)$ | → | | 2.29 | Min Cost Climbing Stairs | two-step DP | $O(n)$ | → | | 2.30 | Coin Change II | unbounded-knapsack count | $O(ca)$ | → | | 2.31 | Unique Paths | grid DP / combinatorics | $O(mn)$ | → | | 2.32 | Unique Paths II | obstacle-zeroed DP | $O(mn)$ | → | | 2.33 | Palindrome Partitioning II | palindrome table + min cuts | $O(n^2)$ | → | | 2.34 | Valid Palindrome III | LPS DP | $O(n^2)$ | → | | 2.35 | Longest Palindromic Subsequence | LPS memo / LCS(s, rev) | $O(n^2)$ | → | | 2.36 | Stone Game | relative-score range DP | $O(n^2)$ | → | | 2.37 | Minimum Path Sum | grid min DP | $O(mn)$ | → | | 2.38 | Continuous Subarray Sum | prefix-mod repetition | $O(n)$ | → | | 2.39 | Number Of Zero-Filled Subarrays | run counting | $O(n)$ | → | | 2.40 | Subarray Product Less Than K | sliding product | $O(n)$ | → | | 2.41 | String Chain | sorted-length DP | $O(nL^2)$ | → | | 2.42 | Partition Array Into Two Arrays | meet-in-the-middle | $O(2^{n/2}log)$ | → |

Reading order

2.2 and 2.3 first — they’re the ur-examples of the state-shape dp[i][j]. Then 2.1 (same table, different recurrence), then the knapsack family (2.4–2.6) which is the most frequently re-appearing pattern in real interviews, then the interval DPs (2.10, 2.11), then the gyms (2.8, 2.9, 2.13). End with 2.12 which is the anti-DP — it proves you know when not to reach for a DP table.

2.0 Pattern Primer — Organized Recursion

Dynamic programming is recursion with a memo pad. That sentence is the entire chapter. The hard part is never the memoization — it’s finding the right state. This page gives you the recipe used on every page of this chapter.

The recipe

Every DP problem is four answers:

1. State — what does dp[...] represent? (The dimensions of the table ARE the state.)
2. Recurrence — how does dp[i][j] depend on smaller states?
3. Base cases — which cells are known without computing?
4. Answer — which cell (or max over cells) is the answer?

If you can write those four things in words, the code writes itself. Most interviewers are actually grading your ability to narrate these four, not to type the loop.

The two implementation styles

Top-down (memoized recursion). Write the recurrence as a recursive function; on entry, check a memo table; on exit, store the result.

fun solve(i: Int, j: Int): Int {
    memo[i][j]?.let { return it }          // already computed?
    // base cases, then:
    val result = ...                       // recurrence
    memo[i][j] = result
    return result
}

Bottom-up (table filling). Fill the table in dependency order — every cell’s dependencies must already be filled.

Top-down is easier to get right (it mirrors the recurrence literally) and only computes reachable states; bottom-up is faster per cell (no function-call overhead, better cache locality) and avoids stack-depth issues on long recurrences. Interview answer: write top-down first for correctness, then offer bottom-up as the optimization. Both appear in this chapter.

The math: why DP beats brute force

Brute force solves every subproblem independently — the total work is the number of leaves of the recursion tree. DP solves each distinct subproblem once. If the state space has $S$ states and each takes $O(T)$ to combine, then:

$$ T_{\text{DP}} = O(S \cdot T) \quad \text{vs} \quad T_{\text{brute}} = O(\text{number of leaves}) $$

The classic example (Fibonacci): brute force is $T(n) = T(n-1) + T(n-2) + O(1)$, solved by the recurrence to $O(\phi^n)$ (exponential); DP collapses the state space ${0..n}$ to $O(n)$ total work. The overlapping subproblems property is exactly what makes the memo table pay for itself: see Reference §4 for the Master Theorem and how to recognize which recurrences are polynomial.

The two properties (name them out loud)

• Optimal substructure: the optimal solution contains optimal solutions to subproblems. (If you can’t state this, you can’t prove the recurrence.)
• Overlapping subproblems: the same subproblem is reached through many different paths. (If not true, memoization is wasted effort and you should just recurse.)

Both are needed. Knapsack, edit distance, and LCS have both; quicksort-style divide-and-conquer has the first but not the second — which is why those get recursion, not DP.

Common state shapes in this chapter

The optimization ladder (say this in interviews)

1. Write brute force recursion.
2. Add a memo → top-down DP.
3. Convert to bottom-up → iterative DP.
4. Notice you only need the last row / two rows → rolling array (space $O(1)$–$O(\min)$).
5. Only if asked: formalize with matrices / convex hull / other exotic tricks.

Every page in this chapter shows at least steps 1–2, most show 3–4, and several show 5.

When NOT to use DP

If the subproblems don’t overlap, or the state space is astronomically large (e.g. Closest Subsequence Sum in 1.22), DP is wrong tool. Meeting-in-the-middle, greedy, or divide-and-conquer take its place. Knowing the boundary is a senior signal.

2.1 Longest Common Substring

Source: src/main/kotlin/array/dp/LongestCommonSubarray.kt Pattern: 2D DP on string prefixes · Core page

The Problem

Given two strings (arrays) s1 of length $m$ and s2 of length $n$, return the length of the longest contiguous substring common to both.

• Constraints: $1 \le m, n \le 10^3$.

Examples

s1 = "abcde", s2 = "abfce"   -> 2   ("ab")
s1 = "abcd",  s2 = "bc"      -> 2   ("bc")
s1 = "abc",   s2 = "def"     -> 0

Intuition — the state must remember continuity

Contiguity is the whole difficulty. If we used the LCS state (“best common subsequence of the first i / first j characters”), a discontiguous match would be allowed — wrong. The fix is a sharper state:

$$ dp[i][j] = \text{length of the longest common substring that ENDS exactly at } s1[i-1] \text{ and } s2[j-1] $$

With “ends exactly at”, the recurrence is brutally simple:

$$ dp[i][j] = \begin{cases} dp[i-1][j-1] + 1 & s1[i-1] = s2[j-1] \[1mm] 0 & \text{otherwise} \end{cases} $$

If the last characters match, extend the diagonal streak by 1 (the previous common substring ending at (i-1, j-1) can be extended); if they don’t, no common substring can end here — reset to 0. The answer is the max over all cells:

$$ \text{answer} = \max_{i,j} dp[i][j] $$

Why the max? The best common substring could end anywhere in both strings; every cell records the streak ending at that pair, so the global maximum over the table is the longest contiguous match.

Approach 1 — Brute force

For each of the $O(m^2)$ substrings of s1, check membership in s2: $O(m^2 n)$ (or $O(m^2)$ with a suffix automaton — overkill here). Exponential-ish blowup in practice; the DP is the expected answer.

Approach 2 — Bottom-up DP (optimal)

/**
 * @param s1 the first string (or array)
 * @param s2 the second string (or array)
 * @return   the length of the longest contiguous substring common to both
 */
fun longestCommonSubstring(s1: String, s2: String): Int {
    val m = s1.length
    val n = s2.length
    val dp = Array(m + 1) { IntArray(n + 1) }   // row 0 and col 0 are the empty-string padding
    var maxLen = 0

    for (i in 1..m) {
        for (j in 1..n) {
            if (s1[i - 1] == s2[j - 1]) {
                // Extend the diagonal streak: the substring ending at (i-1, j-1) + this char.
                dp[i][j] = dp[i - 1][j - 1] + 1
                maxLen = maxOf(maxLen, dp[i][j])
            } else {
                // Characters differ -> no common substring can END here. Reset.
                dp[i][j] = 0
            }
        }
    }
    return maxLen
}

public class LongestCommonSubstring {
    /**
     * @param s1 the first string (or array)
     * @param s2 the second string (or array)
     * @return   the length of the longest contiguous substring common to both
     */
    public int longestCommonSubstring(String s1, String s2) {
        int m = s1.length(), n = s2.length();
        int[][] dp = new int[m + 1][n + 1];
        int maxLen = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    maxLen = Math.max(maxLen, dp[i][j]);
                } else {
                    dp[i][j] = 0;
                }
            }
        }
        return maxLen;
    }
}

#include <string>
#include <vector>
#include <algorithm>

class LongestCommonSubstring {
public:
    /**
     * @param s1 the first string
     * @param s2 the second string
     * @return   the length of the longest contiguous substring common to both
     */
    int longestCommonSubstring(const std::string& s1, const std::string& s2) {
        int m = (int)s1.size(), n = (int)s2.size();
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));
        int maxLen = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1[i - 1] == s2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    maxLen = std::max(maxLen, dp[i][j]);
                }
            }
        }
        return maxLen;
    }
};

def longest_common_substring(s1: str, s2: str) -> int:
    """
    @param s1: the first string
    @param s2: the second string
    @return:   the length of the longest contiguous substring common to both
    """
    m, n = len(s1), len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    max_len = 0
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
                max_len = max(max_len, dp[i][j])
            else:
                dp[i][j] = 0
    return max_len

#![allow(unused)]
fn main() {
impl Solution {
    /// @param s1 the first string
    /// @param s2 the second string
    /// @return   the length of the longest contiguous substring common to both
    pub fn longest_common_substring(s1: String, s2: String) -> i32 {
        let (b1, b2) = (s1.as_bytes(), s2.as_bytes());
        let (m, n) = (b1.len(), b2.len());
        let mut dp = vec![vec![0i32; n + 1]; m + 1];
        let mut max_len = 0i32;
        for i in 1..=m {
            for j in 1..=n {
                if b1[i - 1] == b2[j - 1] {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    max_len = max_len.max(dp[i][j]);
                }
            }
        }
        max_len
    }
}
}

Note on the repository file: the repo’s LongestCommonSubarray.kt carries both a memoized-recursion attempt and the tabular findLength_tabular shown here. The tabular version is the one to study — the memoized version on that file has scratch-state issues (it compares nums1[i] with itself and recurses i + 1 instead of i - 1), a good reminder that a broken top-down attempt should be discarded in favor of the clean bottom-up table. We present the clean version above.

Dry run

Input: s1 = "abcde", s2 = "abfce". Fill the table (row by row; only the diagonal cells matter):

      ""   a   b   f   c   e
""     0   0   0   0   0   0
a      0   1   0   0   0   0
b      0   0   2   0   0   0
c      0   0   0   0   1   0
d      0   0   0   0   0   0
e      0   0   0   0   0   1

Trace the interesting cells:

i=1,j=1: 'a'=='a' -> dp=dp[0][0]+1=1        (streak "a")
i=2,j=2: 'b'=='b' -> dp=dp[1][1]+1=2        (streak "ab" — extended diagonally)
i=3,j=3: 'c' vs 'f' -> 0                    (streak broken at the mismatch)
i=3,j=4: 'c'=='c' -> dp=dp[2][3]+1=0+1=1    (new streak "c")
i=5,j=5: 'e'=='e' -> dp=dp[4][4]+1=0+1=1    (new streak "e")

Max over the table = 2 (“ab”). The crucial detail: the “c” match at (3,4) does not extend to 3, because the substring ending at (2,3) was 0 — the mismatch at f broke the diagonal. That’s contiguity enforced by the recurrence itself.

Complexity

Time. Every cell is computed once with $O(1)$ work:

$$ T(m, n) = O(mn) $$

Space. The full table is $\Theta(mn)$; but each cell only reads dp[i-1][j-1], so a rolling array of size 2 (or even 1 with careful overwrite order) reduces space to $O(\min(m, n))$.

Variants & follow-ups

• 2.3 — drop the “ends exactly at” sharpening and the same table computes the discontiguous longest common subsequence. The contrast between the two states is the single best interview teaching moment in this chapter.
• 2.2 — same table shape, three-way recurrence.
• Interview follow-up: “Return the substring, not just the length.” Track the (i, j) of the maximum cell; the substring is s1[i - maxLen .. i). One extra variable.
• Interview follow-up: “Can you do it with suffix automata / rolling hash + binary search?” For huge strings, binary search on the length $L$ + rolling-hash equality check gives $O((m+n)\log \min(m,n))$ — a genuinely different tradeoff worth mentioning after the DP.

2.2 Minimum Edit Distance

Source: src/main/kotlin/string/dynamic_programming/EditDistance.kt Pattern: 2D DP on string prefixes · Core page

The Problem

Given two words word1 (length $m$) and word2 (length $n$), return the minimum number of operations to convert word1 into word2. Allowed operations (each costs 1):

• Insert a character,

• Delete a character,

• Replace a character.

• Constraints: $0 \le m, n \le 500$.

Examples

word1 = "horse", word2 = "ros"   -> 3
  horse -> rorse (replace 'h' with 'r')
  rorse -> rose   (delete 'r')
  rose  -> ros    (delete 'e')

word1 = "intention", word2 = "execution" -> 5

Intuition — the three operations are three recursive subproblems

Classic state on prefixes:

$$ dp[i][j] = \text{min cost to convert } word1[0..i) \text{ into } word2[0..j) $$

Split on the last characters:

• Match (word1[i-1] == word2[j-1]): no operation needed on the last characters; solve the prefixes: $dp[i][j] = dp[i-1][j-1]$.
• Mismatch: three options, each a different recursive subproblem, pay 1 and take the min:
  • Replace: dp[i-1][j-1] + 1 — make the last chars equal, then solve the prefixes.
  • Delete from word1: dp[i-1][j] + 1 — drop word1’s last char, now converting word1[0..i-1) to word2[0..j).
  • Insert into word1: dp[i][j-1] + 1 — insert word2’s last char at the end of word1, now converting word1[0..i) to word2[0..j-1).

$$ dp[i][j] = \begin{cases} dp[i-1][j-1] & \text{match} \[1mm] 1 + \min(dp[i-1][j-1],; dp[i-1][j],; dp[i][j-1]) & \text{mismatch} \end{cases} $$

Base cases: dp[0][j] = j (insert j chars), dp[i][0] = i (delete i chars).

Why these three cover everything: any edit script’s last operation (in the optimal order) is one of these three, applied to the last character — insert, delete, or replace. So the optimal script = optimal prefix script + last operation. That’s optimal substructure, stated cleanly.

Approach 1 — Brute-force recursion

Recurse on every choice of operation. The recursion tree branches 3× per mismatch → up to $3^{\min(m,n)}$ leaves. Exponential — the memo table is what saves it.

Approach 2 — Memoized recursion (the repo’s style)

/**
 * @param word1 the source word
 * @param word2 the target word
 * @return      the minimum number of insert/delete/replace operations to convert word1 to word2
 */
fun minDistance(word1: String, word2: String): Int {
    val memo = mutableMapOf<String, Int>()

    /**
     * @param m the length of the word1 prefix under consideration
     * @param n the length of the word2 prefix under consideration
     * @return  min cost to convert word1[0..m) into word2[0..n)
     */
    fun solve(m: Int, n: Int): Int {
        val state = "$m.$n"
        memo[state]?.let { return it }

        return when {
            m == 0 -> n                                          // insert n chars
            n == 0 -> m                                          // delete m chars
            word1[m - 1] == word2[n - 1] -> solve(m - 1, n - 1)  // match, free
            else -> {
                val insert  = solve(m, n - 1)     // word1 gains word2[n-1]
                val delete  = solve(m - 1, n)     // word1 loses word1[m-1]
                val replace = solve(m - 1, n - 1) // both last chars replaced
                1 + minOf(insert, delete, replace)
            }
        }.also { memo[state] = it }
    }
    return solve(word1.length, word2.length)
}

The repository’s EditDistance.kt is exactly this shape (memoized recursion over (m, n) states). The Map<String, Int> key is a pragmatic stand-in for a 2D array; a Array<IntArray> with -1 sentinels is faster and is what the bottom-up version uses below.

Approach 3 — Bottom-up (optimal)

/**
 * @param word1 the source word
 * @param word2 the target word
 * @return      the minimum edit distance (insert/delete/replace, cost 1 each)
 */
fun minDistance(word1: String, word2: String): Int {
    val m = word1.length
    val n = word2.length
    val dp = Array(m + 1) { IntArray(n + 1) }

    for (i in 0..m) dp[i][0] = i     // delete i chars to reach ""
    for (j in 0..n) dp[0][j] = j     // insert j chars to reach word2 from ""

    for (i in 1..m) {
        for (j in 1..n) {
            dp[i][j] = if (word1[i - 1] == word2[j - 1]) {
                dp[i - 1][j - 1]                       // match: free
            } else {
                1 + minOf(
                    dp[i - 1][j - 1],   // replace
                    dp[i - 1][j],       // delete from word1
                    dp[i][j - 1]        // insert into word1
                )
            }
        }
    }
    return dp[m][n]
}

public class EditDistance {
    /**
     * @param word1 the source word
     * @param word2 the target word
     * @return      the minimum edit distance (insert/delete/replace, cost 1 each)
     */
    public int minDistance(String word1, String word2) {
        int m = word1.length(), n = word2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) dp[i][0] = i;
        for (int j = 0; j <= n; j++) dp[0][j] = j;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = 1 + Math.min(dp[i - 1][j - 1],
                                    Math.min(dp[i - 1][j], dp[i][j - 1]));
                }
            }
        }
        return dp[m][n];
    }
}

#include <string>
#include <vector>
#include <algorithm>

class EditDistance {
public:
    /**
     * @param word1 the source word
     * @param word2 the target word
     * @return      the minimum edit distance (insert/delete/replace, cost 1 each)
     */
    int minDistance(const std::string& word1, const std::string& word2) {
        int m = (int)word1.size(), n = (int)word2.size();
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));
        for (int i = 0; i <= m; i++) dp[i][0] = i;
        for (int j = 0; j <= n; j++) dp[0][j] = j;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = 1 + std::min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]});
                }
            }
        }
        return dp[m][n];
    }
};

def min_distance(word1: str, word2: str) -> int:
    """
    @param word1: the source word
    @param word2: the target word
    @return:      the minimum edit distance (insert/delete/replace, cost 1 each)
    """
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i - 1] == word2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                dp[i][j] = 1 + min(
                    dp[i - 1][j - 1],   # replace
                    dp[i - 1][j],       # delete from word1
                    dp[i][j - 1]        # insert into word1
                )
    return dp[m][n]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param word1 the source word
    /// @param word2 the target word
    /// @return      the minimum edit distance (insert/delete/replace, cost 1 each)
    pub fn min_distance(word1: String, word2: String) -> i32 {
        let (b1, b2) = (word1.as_bytes(), word2.as_bytes());
        let (m, n) = (b1.len(), b2.len());
        let mut dp = vec![vec![0i32; n + 1]; m + 1];
        for i in 0..=m { dp[i][0] = i as i32; }
        for j in 0..=n { dp[0][j] = j as i32; }

        for i in 1..=m {
            for j in 1..=n {
                dp[i][j] = if b1[i - 1] == b2[j - 1] {
                    dp[i - 1][j - 1]
                } else {
                    1 + dp[i - 1][j - 1].min(dp[i - 1][j]).min(dp[i][j - 1])
                };
            }
        }
        dp[m][n]
    }
}
}

Approach 4 — The one-row “extreme optimization”

The notes’ “extreme optimization” collapses the two rows into one — the only cell still needed from the previous row is the diagonal dp[i-1][j-1], carried in a prevDiagonal variable that’s saved before each cell is overwritten:

fun minDistance(s1: String, s2: String): Int {
    val m = s1.length
    val n = s2.length

    // Keep the shorter string as the row width
    if (m < n) return minDistance(s2, s1)

    val dp = IntArray(n + 1)
    for (j in 0..n) dp[j] = j                 // first row: s1 empty, j insertions

    for (i in 1..m) {
        var prevDiagonal = dp[0]              // dp[i-1][j-1] from the previous row
        dp[0] = i                             // first column: s2 empty, i deletions

        for (j in 1..n) {
            val temp = dp[j]                  // save current before overwriting
            dp[j] = when {
                s1[i - 1] == s2[j - 1] -> prevDiagonal
                else -> 1 + minOf(prevDiagonal, dp[j], dp[j - 1])
            }
            prevDiagonal = temp               // becomes the diagonal for the next j
        }
    }
    return dp[n]
}

dp[j] at the moment of the minOf is the old row’s dp[i-1][j] (delete), dp[j-1] is this row’s dp[i][j-1] (insert), and prevDiagonal is dp[i-1][j-1] (replace) — one array holding three rows’ worth of information through careful timing. $O(n)$ space, same $O(mn)$ time.

Dry run

Input: word1 = "horse", word2 = "ros". Fill the table:

      ""   r   o   s
""     0   1   2   3
h      1   1   2   3
o      2   2   1   2
r      3   2   2   2
s      4   3   3   2
e      5   4   4   3

Trace the interesting cells:

i=1 (h): j=1: 'h' vs 'r' mismatch -> 1 + min(dp[0][0]=0, dp[0][1]=1, dp[1][0]=1) = 1  (replace h->r)
i=2 (o): j=2: 'o'=='o' match -> dp[1][1] = 1
i=2 (o): j=3: 'o' vs 's' mismatch -> 1 + min(dp[1][2]=2, dp[1][3]=3, dp[2][2]=1) = 2
i=5 (e): j=3: 'e' vs 's' mismatch -> 1 + min(dp[4][2]=3, dp[4][3]=2, dp[5][2]=4) = 3

Answer = dp[5][3] = 3. Reconstruction (bottom-right, follow the min):

(5,3) 'e' vs 's' -> delete 'e' (came from dp[4][3])
(4,3) 's' == 's' -> match, move diagonal (came from dp[3][2])
(3,2) 'r' vs 'o' -> replace 'r' with 'o' (came from dp[2][1])
(2,1) 'o' == 'o' -> match, diagonal (came from dp[1][0])
(1,0) -> delete 'h' (base case dp[1][0] = 1)
Script: delete h, match o, replace r->o, match s = 3 operations ✓

Complexity

Time. $O(mn)$ — every cell computed once.

Space. Full table $\Theta(mn)$; the recurrence reads only the previous row, so two rolling rows give $O(n)$ space. (With a single row plus a saved diagonal, $O(n)$ is achievable too — the classic trick.)

Variants & follow-ups

• 2.3 — LCS = edit distance where only insert/delete are allowed: $m + n - 2 \cdot \text{LCS}$.
• Delete Operations For Two Strings — exactly that identity, implemented in the repo.
• Spell-check / diff — the real-world systems built on this recurrence; saying “git diff’s Myers algorithm is a variant of this” is a strong senior signal.
• Interview follow-up: “What if operations have different costs (replace = 2)?” The recurrence is unchanged — only the constants in the mismatch branch change. One line.
• Interview follow-up: “Print the edit script.” Backtrack from dp[m][n] like the dry run: match → diagonal, else → the cell that produced the min, emitting the operation. $O(m + n)$ after the table.

2.3 Longest Common Subsequence

Source: src/main/kotlin/google/GoogleCheatSheet_II.kt (the LCS block) · src/main/kotlin/string/dynamic_programming/ Pattern: 2D DP on string prefixes · Core page

The Problem

Given two strings s (length $m$) and t (length $n$), return the length of the longest common subsequence — the longest sequence of characters that appears in both strings, in order, not necessarily contiguously.

• Constraints: $1 \le m, n \le 10^3$.

Examples

s = "abcde", t = "ace"    -> 3   ("ace")
s = "abc",   t = "abc"    -> 3
s = "abc",   t = "def"    -> 0
s = "AGGTAB", t = "GXTXAYB" -> 4   ("GTAB")

Intuition — “match or skip” on prefixes

The state is the classic prefix pair:

$$ dp[i][j] = \text{length of the LCS of } s[0..i) \text{ and } t[0..j) $$

The recurrence comes from a clean case split on the last characters:

• s[i-1] == t[j-1]: this character can be the last of the LCS (any LCS of the prefixes can have it appended — matching it is never worse than skipping it, by the exchange argument that appending a common character only helps). So:

$$ dp[i][j] = dp[i-1][j-1] + 1 $$

• s[i-1] != t[j-1]: the last characters can’t both be in the LCS, so the best is either the LCS of s[0..i-1) with t[0..j) or of s[0..i) with t[0..j-1):

$$ dp[i][j] = \max(dp[i-1][j], ; dp[i][j-1]) $$

Answer: $dp[m][n]$. Base case: $dp[0][] = dp[][0] = 0$ (one string empty ⇒ LCS empty).

Why “match” wins on equality: suppose a best LCS of the prefixes doesn’t use s[i-1]. Then it’s an LCS of $s[0..i-1)$ and $t[0..j)$, length $\le dp[i-1][j-1] + 1$ — but appending the matched character to some LCS of $s[0..i-1), t[0..j-1)$ gives length $dp[i-1][j-1] + 1$, which is at least as good. So matching is optimal.

Approach 1 — Brute force

Enumerate all $2^m$ subsequences of s and check containment in t. Exponential — this is the textbook “DP is the only way” problem.

Approach 2 — Bottom-up DP (optimal)

/**
 * @param s the first string
 * @param t the second string
 * @return  the length of the longest common subsequence of s and t
 */
fun longestCommonSubsequence(s: String, t: String): Int {
    val dp = Array(s.length + 1) { IntArray(t.length + 1) }

    for (i in 1..s.length) {
        for (j in 1..t.length) {
            dp[i][j] = when {
                s[i - 1] == t[j - 1] -> dp[i - 1][j - 1] + 1          // extend the diagonal
                else                 -> maxOf(dp[i - 1][j], dp[i][j - 1]) // best of skipping one side
            }
        }
    }
    return dp[s.length][t.length]
}

public class LongestCommonSubsequence {
    /**
     * @param s the first string
     * @param t the second string
     * @return  the length of the longest common subsequence of s and t
     */
    public int longestCommonSubsequence(String s, String t) {
        int m = s.length(), n = t.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }
}

#include <string>
#include <vector>
#include <algorithm>

class LongestCommonSubsequence {
public:
    /**
     * @param s the first string
     * @param t the second string
     * @return  the length of the longest common subsequence of s and t
     */
    int longestCommonSubsequence(const std::string& s, const std::string& t) {
        int m = (int)s.size(), n = (int)t.size();
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = std::max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return dp[m][n];
    }
};

def longest_common_subsequence(s: str, t: str) -> int:
    """
    @param s: the first string
    @param t: the second string
    @return:  the length of the longest common subsequence of s and t
    """
    m, n = len(s), len(t)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s[i - 1] == t[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    return dp[m][n]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param s the first string
    /// @param t the second string
    /// @return  the length of the longest common subsequence of s and t
    pub fn longest_common_subsequence(s: String, t: String) -> i32 {
        let (bs, bt) = (s.as_bytes(), t.as_bytes());
        let (m, n) = (bs.len(), bt.len());
        let mut dp = vec![vec![0i32; n + 1]; m + 1];
        for i in 1..=m {
            for j in 1..=n {
                dp[i][j] = if bs[i - 1] == bt[j - 1] {
                    dp[i - 1][j - 1] + 1
                } else {
                    dp[i - 1][j].max(dp[i][j - 1])
                };
            }
        }
        dp[m][n]
    }
}
}

Dry run

Input: s = "AGGTAB", t = "GXTXAYB". The classic worked example. Fill the table:

      ""  G   X   T   X   A   Y   B
""     0   0   0   0   0   0   0   0
A      0   0   0   0   0   1   1   1
G      0   1   1   1   1   1   1   1
G      0   1   1   1   1   1   1   1
T      0   1   1   2   2   2   2   2
A      0   1   1   2   2   3   3   3
B      0   1   1   2   2   3   3   4

Trace the interesting cells:

i=1 (A):  j=5: 'A'=='A' -> dp[0][4]+1 = 1          (new match; extends from row 0)
i=4 (T):  j=3: 'T'=='T' -> dp[3][2]+1 = 1+1 = 2    ("GT")
          j=4: 'T' vs 'X' -> max(dp[3][4], dp[4][3]) = max(1, 2) = 2  (skip propagates the 2)
i=5 (A):  j=5: 'A'=='A' -> dp[4][4]+1 = 2+1 = 3    ("GTA")
i=6 (B):  j=7: 'B'=='B' -> dp[5][6]+1 = 3+1 = 4    ("GTAB")

Answer = dp[6][7] = 4. Reading the diagonal back: matches at (1,5)→A, (4,3)→T, (5,5)→A… wait — reconstructing from the table (start at bottom-right, move up-left on matches): B(6,7), then A(5,5), then T(4,3), then G(2,1) → “GTAB” reversed. The path is the reconstruction story — walk it once by hand.

Complexity

Time.

$$ T(m, n) = O(mn) $$

Space. Full table $\Theta(mn)$; rolling to two rows gives $O(n)$ (each cell reads only dp[i-1][j-1], dp[i-1][j], dp[i][j-1]).

Variants & follow-ups

• 2.1 — the contiguous twin; compare the two states (“ends exactly at” vs “best prefix pair”) out loud in an interview.
• 2.2 — same table, but the “skip” branch becomes three explicit operations with +1 cost.
• Delete Operations For Two Strings (src/main/kotlin/string/dynamic_programming/DeleteOperationsForTwoStrings.kt) — m + n - 2 * LCS; the LCS is the “keep” set.
• Interview follow-up: “Print the LCS, not just its length.” Backtrack from dp[m][n]: on a match move diagonally and emit; on unequal cells move to the larger neighbor. $O(m + n)$ after the table.
• Interview follow-up: “Is there a faster-than-$O(mn)$ method?” For typical strings, the Hunt–Szymanski algorithm runs in $O((r + n) \log n)$ where $r$ = number of matches — worth naming as the “when the alphabet is small / matches are sparse” variant.

2.4 0/1 Knapsack

Source: src/main/kotlin/dynamic_programming/01Knapsack.kt Pattern: capacity-state DP · Core page — the most reusable DP in this book

The Problem

Given n items, each with a weight and a value, and a knapsack with capacity, pick a subset of items whose total weight ≤ capacity maximizing total value. “0/1” means each item is taken whole or not at all — no fractions, no repeats.

• Constraints: $n$ small (≤ 100 in interviews), capacity up to ~$10^4$ (the DP table must fit in memory).

Examples

items = [(w=10, v=60), (w=20, v=100), (w=30, v=120)], capacity = 50
Output: 220
Explanation: take items 2 and 3: weight 20+30=50, value 100+120=220.
             Taking item 1+3 gives 60+120=180 (weight 40, worse); 1+2 gives 160. 220 wins.

Intuition — the “take or skip” fork in the road

Walk through the items one at a time. When you meet item i, you face exactly two futures — take it or skip it:

$$ dp[i][c] = \max!\big(\underbrace{dp[i-1][c]}{\text{skip } i}, \underbrace{dp[i-1][c - w_i] + v_i}{\text{take } i \text{ (if it fits)}}\big) $$

State: $dp[i][c]$ = max value using the first i items with capacity c.

• Skip: the best value with the previous items and the same capacity.
• Take: pay w_i of capacity, pocket v_i, then solve the subproblem with the previous items and the remaining capacity c - w_i.

Why optimal substructure holds: any optimal selection either excludes item i (then it’s an optimal selection of the first i-1 items with capacity c) or includes it (then the rest is an optimal selection of the first i-1 items with capacity c - w_i). There’s no third case. This exhaustive fork is the entire algorithm.

The 1D trick (the interview gem): the recurrence only reads row i-1. If we keep a single array and iterate capacity descending, dp[c-w] still holds the previous item’s value when we read it — because descending order means c-w < c was not yet overwritten this round. One array, exact same semantics.

Approach 1 — Brute force

Enumerate all $2^n$ subsets. For $n = 100$: impossible. The “capacity” dimension of the state is what buys polynomial time — at the price of the table.

Approach 2 — Bottom-up 2D (the reference implementation)

/**
 * @param items    each item has a weight and a value
 * @param capacity the total weight the knapsack can carry
 * @return         the maximum total value achievable with total weight <= capacity
 */
fun knapsack2D(items: List<Item>, capacity: Int): Int {
    val n = items.size
    // dp[i][c] = max value using the first i items with capacity c
    val dp = Array(n + 1) { IntArray(capacity + 1) }

    items.forEachIndexed { idx, (w, v) ->
        val i = idx + 1                // 1-indexed row
        for (c in 0..capacity) {
            dp[i][c] = if (w <= c) {
                maxOf(
                    dp[i - 1][c],          // skip item i
                    dp[i - 1][c - w] + v   // take item i (use remaining capacity c - w)
                )
            } else {
                dp[i - 1][c]               // too heavy: must skip
            }
        }
    }
    return dp[n][capacity]
}

Approach 3 — 1D rolling array (space-optimal)

/**
 * @param items    each item has a weight and a value
 * @param capacity the total weight the knapsack can carry
 * @return         the maximum total value achievable with total weight <= capacity
 */
fun knapsack(items: List<Item>, capacity: Int): Int {
    val dp = IntArray(capacity + 1)

    items.forEach { (w, v) ->
        // DESCENDING: dp[c - w] is still the PREVIOUS item's row (not yet overwritten),
        // which enforces the 0/1 rule (each item used at most once).
        for (c in capacity downTo w) {
            dp[c] = maxOf(dp[c], dp[c - w] + v)
        }
    }
    return dp[capacity]
}

public class ZeroOneKnapsack {
    /**
     * @param weights  the weight of each item
     * @param values   the value of each item
     * @param capacity the total weight the knapsack can carry
     * @return         the maximum total value achievable with total weight <= capacity
     */
    public int knapsack(int[] weights, int[] values, int capacity) {
        int[] dp = new int[capacity + 1];
        for (int i = 0; i < weights.length; i++) {
            for (int c = capacity; c >= weights[i]; c--) {   // descending = 0/1 semantics
                dp[c] = Math.max(dp[c], dp[c - weights[i]] + values[i]);
            }
        }
        return dp[capacity];
    }
}

#include <vector>
#include <algorithm>

class ZeroOneKnapsack {
public:
    /**
     * @param weights  the weight of each item
     * @param values   the value of each item
     * @param capacity the total weight the knapsack can carry
     * @return         the maximum total value achievable with total weight <= capacity
     */
    int knapsack(const std::vector<int>& weights, const std::vector<int>& values, int capacity) {
        std::vector<int> dp(capacity + 1, 0);
        for (int i = 0; i < (int)weights.size(); i++) {
            for (int c = capacity; c >= weights[i]; c--) {   // descending = 0/1 semantics
                dp[c] = std::max(dp[c], dp[c - weights[i]] + values[i]);
            }
        }
        return dp[capacity];
    }
};

def knapsack(weights: list[int], values: list[int], capacity: int) -> int:
    """
    @param weights:  the weight of each item
    @param values:   the value of each item
    @param capacity: the total weight the knapsack can carry
    @return:         the maximum total value achievable with total weight <= capacity
    """
    dp = [0] * (capacity + 1)
    for w, v in zip(weights, values):
        for c in range(capacity, w - 1, -1):     # descending = 0/1 semantics
            dp[c] = max(dp[c], dp[c - w] + v)
    return dp[capacity]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param weights  the weight of each item
    /// @param values   the value of each item
    /// @param capacity the total weight the knapsack can carry
    /// @return         the maximum total value achievable with total weight <= capacity
    pub fn knapsack(weights: Vec<i32>, values: Vec<i32>, capacity: i32) -> i32 {
        let cap = capacity as usize;
        let mut dp = vec![0i32; cap + 1];
        for (w, v) in weights.iter().zip(values.iter()) {
            let mut c = cap;
            while c >= *w as usize {
                dp[c] = dp[c].max(dp[c - *w as usize] + v);   // descending = 0/1 semantics
                c -= 1;
            }
        }
        dp[cap]
    }
}
}

Dry run

Input: weights = [10, 20, 30], values = [60, 100, 120], capacity = 50.

1D trace (row after each item; - means unreachable-or-unused capacity slot):

capacity:    0  10  20  30  40  50
initial:     0   0   0   0   0   0
after item1 (w10,v60):   0  60  60  60  60  60
after item2 (w20,v100):  0  60 100 160 160 160
after item3 (w30,v120):  0  60 100 160 180 220
                                            ^ answer = 220

Trace the interesting updates (item 3, c = 50):

c=50: dp[50] = max(dp[50]=160, dp[50-30]+120 = dp[20]+120 = 100+120 = 220) -> 220 ✓
c=40: dp[40] = max(dp[40]=160, dp[40-30]+120 = dp[10]+120 = 60+120 = 180) -> 180
c=30: dp[30] = max(dp[30]=160, dp[0]+120 = 120)                            -> 160 (skip wins)

The descending order is what keeps dp[20] at 100 (item-2 row) when item 3 reads it — if we’d gone ascending, item 3 would have overwritten dp[20] earlier and dp[50] would wrongly become max(160, dp[20]+120) with a contaminated dp[20].

Complexity

Time. One pass per item over the capacity axis:

$$ T(n, W) = O(nW) $$

Space. 2D: $\Theta(nW)$. 1D rolling: $O(W)$.

Variants & follow-ups

• 2.5 — the one-line change (ascending loop) that turns “each item once” into “each item unlimited times”. Know why the loop direction flips the semantics.
• 2.6 — 0/1 knapsack with values == weights, asking “can we hit exactly sum/2?” (boolean DP).
• Target Sum / Coin Change II (src/main/kotlin/array/dp/) — counting versions of the same capacity state.
• Interview follow-up: “Can you reconstruct which items were taken?” Keep a choice table take[i][c] (or backtrack through the 2D table): at dp[i][c], if dp[i][c] != dp[i-1][c], item i was taken. $O(n)$ reconstruction after the table.
• Interview follow-up: “What if capacity is huge (10^9)?” $O(nW)$ dies; you’d switch to meet-in-the-middle over items ($O(2^{n/2})$) — exactly the tool from 1.22. Naming the failure mode of DP = senior signal.

2.5 Unbounded Knapsack

Source: src/main/kotlin/dynamic_programming/UnboundedKnapsack.kt Pattern: capacity-state DP (forward pass) · Variant page — the one-line difference

The Problem

Same knapsack as 2.4, except each item can be taken any number of times. Maximize total value with total weight ≤ capacity.

Examples

items = [(w=5, v=10), (w=10, v=30), (w=15, v=20)], capacity = 100
Output: 300
Explanation: take item 2 (w=10, v=30) ten times: value 300, weight exactly 100.

items = [(w=1, v=1), (w=50, v=30)], capacity = 100
Output: 100
Explanation: 100 × item 1 = 100 value beats 2 × item 2 = 60.

Intuition — forwards instead of backwards

Compare the two recurrences side by side:

$$ \text{0/1: } dp[c] = \max(dp[c],; dp[c - w] + v) \quad \text{with } c \text{ descending} $$

$$ \text{unbounded: } dp[c] = \max(dp[c],; dp[c - w] + v) \quad \text{with } c \text{ ascending} $$

Same formula — only the loop direction changes. Here’s the reasoning in one sentence:

• Descending means dp[c - w] was computed before the current item touched it → it reflects “previous items only” → the current item can appear at most once in any combination (0/1).
• Ascending means dp[c - w] may already include the current item (since c - w < c was visited earlier in this same loop) → the current item can appear multiple times (unbounded).

In the unbounded loop, when we compute dp[15] for an item of weight 5, the dp[10] it reads may itself have been built from two copies of this item — so dp[15] can represent three copies. The forward pass literally lets items “stack on themselves,” which is exactly the unbounded semantics.

Why this is the right formulation (not “loop items inside capacities”): a naive unbounded DP might try “for each item, for each count k, …” — that’s $O(nW \cdot W/k)$ and wrong-headed. The forward capacity loop is the same $O(nW)$ as 0/1. The only cost is mental: you must remember which direction means which.

Approach — forward-pass capacity DP (optimal)

/**
 * @param items    each item has a weight and a value; items can be reused any number of times
 * @param capacity the total weight the knapsack can carry
 * @return         the maximum total value achievable with total weight <= capacity
 */
fun unboundedKnapsack(items: List<Item>, capacity: Int): Int {
    val dp = IntArray(capacity + 1)

    items.forEach { (w, v) ->
        // ASCENDING: dp[c - w] was already updated by the CURRENT item earlier in this loop,
        // so the item can "stack" on itself -> unlimited copies allowed.
        for (c in w..capacity) {
            dp[c] = maxOf(dp[c], dp[c - w] + v)
        }
    }
    return dp[capacity]
}

public class UnboundedKnapsack {
    /**
     * @param weights  the weight of each item
     * @param values   the value of each item
     * @param capacity the total weight the knapsack can carry
     * @return         the maximum total value achievable with total weight <= capacity
     */
    public int unboundedKnapsack(int[] weights, int[] values, int capacity) {
        int[] dp = new int[capacity + 1];
        for (int i = 0; i < weights.length; i++) {
            for (int c = weights[i]; c <= capacity; c++) {   // ascending = unbounded semantics
                dp[c] = Math.max(dp[c], dp[c - weights[i]] + values[i]);
            }
        }
        return dp[capacity];
    }
}

#include <vector>
#include <algorithm>

class UnboundedKnapsack {
public:
    /**
     * @param weights  the weight of each item
     * @param values   the value of each item
     * @param capacity the total weight the knapsack can carry
     * @return         the maximum total value achievable with total weight <= capacity
     */
    int unboundedKnapsack(const std::vector<int>& weights, const std::vector<int>& values, int capacity) {
        std::vector<int> dp(capacity + 1, 0);
        for (int i = 0; i < (int)weights.size(); i++) {
            for (int c = weights[i]; c <= capacity; c++) {   // ascending = unbounded semantics
                dp[c] = std::max(dp[c], dp[c - weights[i]] + values[i]);
            }
        }
        return dp[capacity];
    }
};

def unbounded_knapsack(weights: list[int], values: list[int], capacity: int) -> int:
    """
    @param weights:  the weight of each item
    @param values:   the value of each item
    @param capacity: the total weight the knapsack can carry
    @return:         the maximum total value achievable with total weight <= capacity
    """
    dp = [0] * (capacity + 1)
    for w, v in zip(weights, values):
        for c in range(w, capacity + 1):       # ascending = unbounded semantics
            dp[c] = max(dp[c], dp[c - w] + v)
    return dp[capacity]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param weights  the weight of each item
    /// @param values   the value of each item
    /// @param capacity the total weight the knapsack can carry
    /// @return         the maximum total value achievable with total weight <= capacity
    pub fn unbounded_knapsack(weights: Vec<i32>, values: Vec<i32>, capacity: i32) -> i32 {
        let cap = capacity as usize;
        let mut dp = vec![0i32; cap + 1];
        for (w, v) in weights.iter().zip(values.iter()) {
            let mut c = *w as usize;
            while c <= cap {                     // ascending = unbounded semantics
                dp[c] = dp[c].max(dp[c - *w as usize] + v);
                c += 1;
            }
        }
        dp[cap]
    }
}
}

Dry run — watch an item stack on itself

Input: weights = [5, 10, 15], values = [10, 30, 20], capacity = 30.

Trace just item 2 (w=10, v=30) in ascending order:

dp before item2: capacity 0..30  ->  all from item1 (w=5,v=10): dp = [0,0,0,0,0,10,10,10,10,10,20,20,...]
c=10: dp[10] = max(20, dp[0]+30 = 30)                 = 30
c=15: dp[15] = max(10, dp[5]+30 = 10+30 = 40)         = 40
c=20: dp[20] = max(20, dp[10]+30 = 30+30 = 60)        = 60   <- TWO copies of item2!
c=25: dp[25] = max(10, dp[15]+30 = 40+30 = 70)        = 70   <- item2 + item2-ish mix
c=30: dp[30] = max(20, dp[20]+30 = 60+30 = 90)        = 90   <- THREE copies: 30+30+30

The dp[20] read at c=30 already contains two copies of item 2 (it was computed earlier in this same loop at c=20). That’s the stacking. In the 0/1 descending version, dp[20] would still be the item-1 value, and dp[30] would cap at max(20, 30+20)=50-ish — no stacking.

Full table after all items: dp[30] = 90 (three copies of item 2). With capacity = 100: dp[100] = 300 (ten copies), matching the example.

Complexity

Time. Same shape as 0/1:

$$ T(n, W) = O(nW) $$

Space. $O(W)$.

Variants & follow-ups

• 2.4 — the twin; the loop-direction contrast is the single most asked “do you actually understand it?” question in knapsack interviews.
• Coin Change (src/main/kotlin/array/dp/CoinChange.kt) — unbounded knapsack with value = 1 per coin and “minimize coins to hit exact sum” instead of maximize.
• Coin Change II (src/main/kotlin/array/dp/CoinChange_II.kt) — the counting version: dp[c] += dp[c - coin], same forward loop.
• Interview follow-up: “What if we also cap copies of item i at K_i?” That’s bounded knapsack — binary-split the copies into $\log K_i$ pseudo-items, each with 0/1 semantics, giving $O(nW \log K)$. A great “where would you even start” question.

2.6 Partition Equal Subset Sum

Source: src/main/kotlin/dynamic_programming/PartitionEqualSubsetSum.kt Pattern: subset-sum reachability (boolean knapsack) · Core page

The Problem

Given a non-empty array nums of positive integers, can you partition it into two subsets with equal sums?

• Constraints: $1 \le n \le 200$, $1 \le nums[i] \le 100$ → total sum ≤ 20,000.

Examples

Input:  nums = [1, 5, 11, 5]   -> true   (partition {1,5,5} and {11}; both sum to 11)
Input:  nums = [1, 2, 3, 5]    -> false  (total 11 is odd, impossible)
Input:  nums = [1, 2, 5]       -> false  (even total 8, but no subset sums to 4)

Intuition — reduce to subset-sum

Two observations collapse the problem:

1. The target is forced. If the total sum $S$ is odd, an equal split is impossible → false immediately. Otherwise both halves must sum to $S/2$.
2. The question becomes: does any subset of nums sum to exactly $S/2$? (The other half is whatever’s left — automatically $S/2$.)

That’s subset-sum, which is 0/1 knapsack with value == weight and a boolean question. State:

$$ dp[s] = \text{can some subset of the items seen so far sum to exactly } s $$

Recurrence (per item x, descending over sums — the 0/1 discipline from 2.4):

$$ dp[s] = dp[s] ;\lor; dp[s - x] $$

meaning “reachable before (skip x)” or “reachable by taking x (from state s−x)”. Base: dp[0] = true (empty subset sums to 0). Answer: dp[target].

Why descending? Exactly the 0/1 argument: reading dp[s - x] in descending order guarantees it reflects previous items only, so each number is used at most once. The dry run below shows the catastrophic result of ascending order.

Approach 1 — Brute force

Enumerate all $2^n$ subsets, check sums. $2^{200}$ — astronomically impossible. DP is the only reasonable answer.

Approach 2 — Top-down memoized DFS (the repo’s first version)

/**
 * @param nums the array of positive integers
 * @return     true iff nums can be split into two subsets of equal sum
 */
fun canPartition(nums: IntArray): Boolean {
    val sum = nums.sum()
    if (sum % 2 != 0) return false
    val target = sum / 2

    // memo[i][s] = -1 unknown, 0 false, 1 true
    val memo = Array(nums.size) { IntArray(target + 1) { -1 } }

    /**
     * @param i          the current item index
     * @param currentSum the running sum of the chosen subset
     * @return           true iff a subset of nums[i..] can reach `target` from currentSum
     */
    fun dfs(i: Int, currentSum: Int): Boolean = when {
        currentSum == target -> true
        i == nums.size      -> false
        memo[i][currentSum] != -1 -> memo[i][currentSum] == 1
        else -> (
            dfs(i + 1, currentSum + nums[i]) ||   // take nums[i]
            dfs(i + 1, currentSum)                // skip nums[i]
        ).also { memo[i][currentSum] = if (it) 1 else 0 }
    }
    return dfs(0, 0)
}

Approach 3 — Bottom-up boolean knapsack (optimal)

/**
 * @param nums the array of positive integers
 * @return     true iff nums can be split into two subsets of equal sum
 */
fun canPartitionBottomUp(nums: IntArray): Boolean {
    val sum = nums.sum()
    if (sum % 2 != 0) return false

    val target = sum / 2
    val dp = BooleanArray(target + 1).apply { this[0] = true }   // empty subset sums to 0

    for (num in nums) {
        for (s in target downTo num) {          // DESCENDING: 0/1 usage of each number
            dp[s] = dp[s] || dp[s - num]
        }
    }
    return dp[target]
}

public class PartitionEqualSubsetSum {
    /**
     * @param nums the array of positive integers
     * @return     true iff nums can be split into two subsets of equal sum
     */
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int x : nums) sum += x;
        if (sum % 2 != 0) return false;

        int target = sum / 2;
        boolean[] dp = new boolean[target + 1];
        dp[0] = true;                                    // empty subset sums to 0

        for (int num : nums) {
            for (int s = target; s >= num; s--) {        // descending: 0/1 semantics
                dp[s] = dp[s] || dp[s - num];
            }
        }
        return dp[target];
    }
}

#include <vector>

class PartitionEqualSubsetSum {
public:
    /**
     * @param nums the array of positive integers
     * @return     true iff nums can be split into two subsets of equal sum
     */
    bool canPartition(const std::vector<int>& nums) {
        int sum = 0;
        for (int x : nums) sum += x;
        if (sum % 2 != 0) return false;

        int target = sum / 2;
        std::vector<bool> dp(target + 1, false);
        dp[0] = true;

        for (int num : nums) {
            for (int s = target; s >= num; s--) {        // descending: 0/1 semantics
                dp[s] = dp[s] || dp[s - num];
            }
        }
        return dp[target];
    }
};

def can_partition(nums: list[int]) -> bool:
    """
    @param nums: the array of positive integers
    @return:     True iff nums can be split into two subsets of equal sum
    """
    total = sum(nums)
    if total % 2 != 0:
        return False

    target = total // 2
    dp = [False] * (target + 1)
    dp[0] = True                                 # empty subset sums to 0

    for num in nums:
        for s in range(target, num - 1, -1):     # descending: 0/1 semantics
            dp[s] = dp[s] or dp[s - num]
    return dp[target]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the array of positive integers
    /// @return     true iff nums can be split into two subsets of equal sum
    pub fn can_partition(nums: Vec<i32>) -> bool {
        let sum: i32 = nums.iter().sum();
        if sum % 2 != 0 {
            return false;
        }
        let target = (sum / 2) as usize;
        let mut dp = vec![false; target + 1];
        dp[0] = true;                                    // empty subset sums to 0

        for num in nums {
            let mut s = target;
            while s >= num as usize {                    // descending: 0/1 semantics
                dp[s] = dp[s] || dp[s - num as usize];
                s -= 1;
            }
        }
        dp[target]
    }
}
}

Dry run

Input: nums = [1, 5, 11, 5]. sum = 22, target = 11.

dp (booleans over sums 0..11):
initial:        T F F F F F F F F F F F
after 1:        T T F F F F F F F F F F      (1 reachable)
after 5:        T T F F F F T T F F F F      (5 and 6 reachable)
after 11:       T T F F F F T T F F F T      (11 reachable!)
after 5 (2nd):  T T F F F T T T T T T T      (5,6,7,8,10,11 all reachable)
Answer: dp[11] = true ✓  (subset {11}, or {1,5,5})

Trace the interesting update (second 5, s = 10):

s=10: dp[10] = dp[10] || dp[5] = false || true -> true   ({5,5} — the two 5s, each used once)

Now the “why descending” demonstration — nums = [1, 5], sum = 6, target = 3:

In ascending order, item 1 “reaches” sum 3 by stacking itself three times — a subset sum that doesn’t exist with 0/1 semantics. Descending order prevents the self-stack, exactly as in 2.4.

Complexity

Time. One pass per item over the sum axis:

$$ T(n, S) = O!\left(n \cdot \frac{S}{2}\right) = O(nS) $$

With $n = 200$, $S = 20{,}000$: $\approx 2 \times 10^6$ operations.

Space. $O(S/2)$ for the boolean array (or $O(nS/2)$ for the memoized version).

Variants & follow-ups

• 2.4 — the general value-maximizing knapsack this reduces from.
• Target Sum (src/main/kotlin/array/dp/TargetSum.kt) — “count subsets reaching a signed target”: a one-line transform to subset-sum counting.
• Partition Array Into Two Arrays To Minimize Sum Difference (src/main/kotlin/array/dp/) — the minimization twin: find the reachable sum closest to $S/2$.
• Interview follow-up: “Why can we ignore values > target?” They can never be part of a subset summing to ≤ target; skipping them is free (the s >= num loop bound already handles it).
• Interview follow-up: “This is a decision problem; is there a bitset trick?” Yes — dp |= dp << num on a bitset of length $S/2$ gives $O(nS/64)$ word-level parallelism. Naming it shows depth, but only after the plain DP is solid.

2.7 Maximum Product Subarray

Source: src/main/kotlin/dynamic_programming/MaximumProductSubarray.kt Pattern: two-track DP (max AND min) · Core page — the sign-flip lesson

The Problem

Given an integer array nums, find the contiguous subarray (non-empty) with the largest product, and return that product. Values may be negative or zero.

• Constraints: $1 \le n \le 2 \times 10^4$, $-10 \le nums[i] \le 10$.

Examples

Input:  nums = [2, 3, -2, 4]    -> 6   (the subarray [2, 3])
Input:  nums = [-2, 0, -1]      -> 0   (either 0, or a negative — 0 wins; subarray [0])
Input:  nums = [-2, 3, -4]      -> 24  (-2 × 3 × -4 — two negatives flip positive)
Input:  nums = [-1, -2, -3]     -> 6   ([-2, -3] or [-1,-2,-3] = 6)

Intuition — why tracking only the max fails

The obvious DP “max product ending at i = max(nums[i], maxPrev × nums[i])” is wrong, and the counterexample is [-2, 3, -4]:

• At index 1, max ending here = max(3, -2×3) = 3.
• At index 2, max ending here = max(-4, 3×-4) = -4. Answer would be 3 — but the true answer is 24 = (-2 × 3 × -4).

The missing information: the minimum product ending at i-1. Because a negative × negative is positive, the smallest value can become the largest after multiplying by a negative. So the DP must track both extremes:

$$ \begin{aligned} \maxEnd_i &= \max\big(nums[i],; \maxEnd_{i-1} \cdot nums[i],; \minEnd_{i-1} \cdot nums[i]\big) \ \minEnd_i &= \min\big(nums[i],; \maxEnd_{i-1} \cdot nums[i],; \minEnd_{i-1} \cdot nums[i]\big) \end{aligned} $$

Three candidates each, and the three cases have names:

1. Start fresh — nums[i] alone (e.g. after a zero resets the streak, or when the previous products are worse).
2. Extend the max streak — maxEnd × nums[i] (positive × positive, or negative × negative when the sign works out).
3. Flip the min streak — minEnd × nums[i] (negative × negative = positive — this is the case the naive DP forgets).

The answer is the running max of maxEnd over all positions (the best subarray can end anywhere).

Approach 1 — Brute force

Try every subarray: $O(n^2)$ pairs, each product $O(1)$ incremental → $O(n^2)$ time. $n = 2 \times 10^4$ → $4 \times 10^8$ — too slow.

Approach 2 — Two-track DP (optimal)

/**
 * @param nums the integer array (may contain negatives and zeros)
 * @return     the maximum product of any contiguous non-empty subarray
 */
fun maxProduct(nums: IntArray): Int {
    if (nums.isEmpty()) return 0

    var maxEnd = nums[0]   // max product of a subarray ENDING at the current position
    var minEnd = nums[0]   // min product of a subarray ENDING at the current position
    var result = maxEnd    // global best so far

    for (i in 1 until nums.size) {
        val x = nums[i]

        // Case 1: start fresh with x. Case 2: extend the previous max. Case 3: flip the previous min.
        val newMax = maxOf(x, maxEnd * x, minEnd * x)
        val newMin = minOf(x, maxEnd * x, minEnd * x)

        maxEnd = newMax
        minEnd = newMin
        result = maxOf(result, maxEnd)
    }
    return result
}

public class MaximumProductSubarray {
    /**
     * @param nums the integer array (may contain negatives and zeros)
     * @return     the maximum product of any contiguous non-empty subarray
     */
    public int maxProduct(int[] nums) {
        int maxEnd = nums[0], minEnd = nums[0], result = nums[0];
        for (int i = 1; i < nums.length; i++) {
            int x = nums[i];
            int newMax = Math.max(x, Math.max(maxEnd * x, minEnd * x));
            int newMin = Math.min(x, Math.min(maxEnd * x, minEnd * x));
            maxEnd = newMax;
            minEnd = newMin;
            result = Math.max(result, maxEnd);
        }
        return result;
    }
}

#include <vector>
#include <algorithm>

class MaximumProductSubarray {
public:
    /**
     * @param nums the integer array (may contain negatives and zeros)
     * @return     the maximum product of any contiguous non-empty subarray
     */
    int maxProduct(const std::vector<int>& nums) {
        int maxEnd = nums[0], minEnd = nums[0], result = nums[0];
        for (int i = 1; i < (int)nums.size(); i++) {
            int x = nums[i];
            int newMax = std::max({x, maxEnd * x, minEnd * x});
            int newMin = std::min({x, maxEnd * x, minEnd * x});
            maxEnd = newMax;
            minEnd = newMin;
            result = std::max(result, maxEnd);
        }
        return result;
    }
};

def max_product(nums: list[int]) -> int:
    """
    @param nums: the integer array (may contain negatives and zeros)
    @return:     the maximum product of any contiguous non-empty subarray
    """
    max_end = min_end = result = nums[0]
    for x in nums[1:]:
        new_max = max(x, max_end * x, min_end * x)   # start fresh / extend max / flip min
        new_min = min(x, max_end * x, min_end * x)
        max_end, min_end = new_max, new_min
        result = max(result, max_end)
    return result

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums the integer array (may contain negatives and zeros)
    /// @return     the maximum product of any contiguous non-empty subarray
    pub fn max_product(nums: Vec<i32>) -> i32 {
        let (mut max_end, mut min_end, mut result) = (nums[0], nums[0], nums[0]);
        for &x in &nums[1..] {
            let new_max = x.max(max_end * x).max(min_end * x);
            let new_min = x.min(max_end * x).min(min_end * x);
            max_end = new_max;
            min_end = new_min;
            result = result.max(max_end);
        }
        result
    }
}
}

Note on the repository file: the repo’s MaximumProductSubarray.kt contains a stray val m = mapOf(1 to 2, 2 to 4, 5 to 6) scratch line — leftover experimentation, harmless but irrelevant. The book listing above is the same algorithm, clean. (Removing scratch is a “clean up your own mess” courtesy; the logic is untouched.)

Dry run

Input: nums = [-2, 3, -4]

i=0: maxEnd = -2, minEnd = -2, result = -2
i=1 (x=3):
  newMax = max(3, -2*3 = -6, -2*3 = -6) = 3
  newMin = min(3, -6, -6) = -6
  maxEnd = 3, minEnd = -6, result = max(-2, 3) = 3
i=2 (x=-4):
  newMax = max(-4, 3*-4 = -12, -6*-4 = 24) = 24      <- the FLIP: min * negative = 24
  newMin = min(-4, -12, 24) = -12
  maxEnd = 24, minEnd = -12, result = max(3, 24) = 24
Answer: 24 ✓

The critical line is i=2: only minEnd = -6 (the worst product ending at index 1) could become 24 when multiplied by -4. The naive max-only DP would have answered 3 — wrong by 8×.

Input with a zero: nums = [-2, 0, -1]

i=0: maxEnd = minEnd = result = -2
i=1 (x=0):
  newMax = max(0, -2*0, -2*0) = 0      <- zero resets both streaks
  newMin = min(0, 0, 0) = 0
  maxEnd = 0, minEnd = 0, result = 0
i=2 (x=-1):
  newMax = max(-1, 0*-1, 0*-1) = 0     <- the subarray [0] beats [-1] and [0,-1]
  result stays 0
Answer: 0 ✓

Note the zero handling is free: max(x, ...) with x = 0 naturally starts a fresh streak, which is why “subarray containing a zero” cases never need special-casing.

Complexity

Time. One pass, $O(1)$ per element:

$$ T(n) = O(n) $$

Space. $O(1)$ — three scalars.

Variants & follow-ups

• Maximum Sum Subarray / Kadane’s algorithm (src/main/kotlin/array/dp/KadensAlgorithm.kt, MaximumSumSubArray.kt) — the sum version needs only ONE tracker, because addition is sign-agnostic (“the max prefix sum can only help”). Saying why sum needs one tracker but product needs two is the interview payoff.
• Interview follow-up: “What if all values are negative?” The max(x, ...) term handles it: the best product is either a pair of negatives or a triple that ends negative-or-positive — e.g. [-1, -2, -3]: at i=1 the best is [-1, -2] = 2; at i=2, max(-3, 2·-3, 6·-3) = -3, so the running max stays 2… but wait — [-2, -3] = 6 isn’t captured by “ending at i” trackers at i=1! Let’s trace honestly: i=1 trackers only see subarrays ending at index 1: [-2] and [-1,-2] → maxEnd=2, minEnd=-2. At i=2 (x=-3): candidates are [-3], 2·-3=-6 (extend [-1,-2]), -2·-3=6 (extend [-2]) → newMax=6. So result = max(2, 6) = 6 ✓. The two-track DP does capture [-2,-3] because minEnd=-2 at i=1 is the subarray [-2]. So: all-negative arrays are handled with zero special-casing — the min track is what makes it work.
• Interview follow-up: “Prove tracking min is sufficient.” Any product ending at i is nums[i] times a product ending at i-1 (or fresh). Products ending at i-1 range between minEnd and maxEnd (they’re all products of a contiguous suffix); multiplying by a fixed sign x moves the extremes of that range to minEnd·x and maxEnd·x. So the two extremes capture the entire range — nothing else is needed. That’s the formal argument.

2.8 Frog Jump

Source: src/main/kotlin/dynamic_programming/FrogJump.kt · FrogJumpTopDown.kt Pattern: set-valued DP state · Gym page

The Problem

A frog is crossing a river on stones. stones[i] is the position of the i-th stone (strictly increasing, starting at 0). The frog starts on stone 0 and must land on the last stone.

Rule: if the frog’s last jump was k units, its next jump must be exactly k-1, k, or k+1 units (and k > 0). The first jump is always exactly 1 unit. Can the frog make it?

• Constraints: $2 \le n \le 2000$, positions up to $2^{31}-1$.

Examples

Input:  stones = [0, 1, 3, 5, 6, 8, 12, 17]
Output: true
Explanation: 0→1 (k=1), 1→3 (k=2), 3→5 (k=2), 5→8 (k=3), 8→12 (k=4), 12→17 (k=5)

Input:  stones = [0, 1, 2, 3, 4, 8, 9, 11]
Output: false
Explanation: from 4 the reachable jumps are k-1,k,k+1 of the jump that arrived;
             the gap to 8 can't be made under the rule.

Intuition — the state is “what jumps can land me here?”

The tricky part: a position alone doesn’t determine the future — the last jump size k matters (it constrains the next jump). So the state must be a pair:

$$ \text{state} = (\text{stone position } p, \text{last jump } k) $$

There are two classic encodings, and the repo ships both:

Bottom-up (FrogJump.kt): stoneMap[p] = the set of jump sizes k with which the frog can arrive at position p. Propagate:

for each stone p, for each k in stoneMap[p]:
    for step in {k-1, k, k+1} (step > 0):
        if p + step is a stone:  add step to stoneMap[p + step]

stoneMap values are sets → the “state space” is the set of reachable (position, jump) pairs. Each pair is processed once → $O(n^2)$ total (each stone holds at most $O(n)$ jumps).

Top-down (FrogJumpTopDown.kt): solve(pos, k) = “can I reach the last stone from pos, given last jump k?” — memoized over the (pos, k) pairs. Same state space, recursion-first style.

Why sets, not a boolean? Two frogs can reach the same stone with different last jumps, and those different ks lead to different futures. A single boolean “reachable” discards exactly the information the rule needs. The set is the honest state.

Approach 1 — Bottom-up with reachable-jump sets (the repo’s first version)

/**
 * @param stones the positions of the stones, strictly increasing, starting at 0
 * @return       true iff the frog can reach the last stone under the k-1/k/k+1 rule
 */
fun canCross(stones: IntArray): Boolean {
    // The very first jump is fixed: 0 -> 1.
    if (stones[1] != 1) return false

    // Map: stone position -> set of jump sizes 'k' that can land on this stone.
    val stoneMap = mutableMapOf<Int, MutableSet<Int>>()
    stones.forEach { stone -> stoneMap[stone] = mutableSetOf() }
    stoneMap[0]?.add(0)   // the "jump" that arrives at the start

    for (stone in stones) {
        for (k in stoneMap[stone]!!) {
            for (step in k - 1..k + 1) {
                if (step > 0) {
                    val nextStone = stone + step
                    if (stoneMap.containsKey(nextStone)) {   // O(1) stone lookup
                        stoneMap[nextStone]?.add(step)
                    }
                }
            }
        }
    }
    return stoneMap[stones.last()]?.isNotEmpty() ?: false
}

Approach 2 — Top-down memoized recursion (the repo’s second version)

/**
 * @param stones the positions of the stones, strictly increasing, starting at 0
 * @return       true iff the frog can reach the last stone under the k-1/k/k+1 rule
 */
fun canCross(stones: IntArray): Boolean {
    val stoneSet = stones.toSet()               // O(1) membership tests
    val cache = mutableMapOf<Pair<Int, Int>, Boolean>()

    /**
     * @param pos the current stone position
     * @param k   the size of the last jump used to reach pos
     * @return    true iff the last stone is reachable from (pos, k)
     */
    fun isValidJump(pos: Int, nextJump: Int) = nextJump > 0 && (pos + nextJump) in stoneSet

    fun solve(pos: Int, k: Int): Boolean =
        cache.getOrPut(Pair(pos, k)) {
            pos == stones.last() || (k - 1..k + 1).any { nextJump ->
                isValidJump(pos, nextJump) && solve(pos + nextJump, nextJump)
            }
        }

    return solve(0, 0)
}

import java.util.*;

public class FrogJump {
    /**
     * @param stones the positions of the stones, strictly increasing, starting at 0
     * @return       true iff the frog can reach the last stone under the k-1/k/k+1 rule
     */
    public boolean canCross(int[] stones) {
        Map<Integer, Set<Integer>> stoneMap = new HashMap<>();
        for (int s : stones) stoneMap.put(s, new HashSet<>());
        stoneMap.get(0).add(0);                        // "arrival" jump at the start

        for (int stone : stones) {
            for (int k : stoneMap.get(stone)) {
                for (int step = k - 1; step <= k + 1; step++) {
                    if (step > 0 && stoneMap.containsKey(stone + step)) {
                        stoneMap.get(stone + step).add(step);
                    }
                }
            }
        }
        return !stoneMap.get(stones[stones.length - 1]).isEmpty();
    }
}

#include <vector>
#include <unordered_map>
#include <unordered_set>

class FrogJump {
public:
    /**
     * @param stones the positions of the stones, strictly increasing, starting at 0
     * @return       true iff the frog can reach the last stone under the k-1/k/k+1 rule
     */
    bool canCross(const std::vector<int>& stones) {
        std::unordered_map<int, std::unordered_set<int>> stoneMap;
        for (int s : stones) stoneMap[s];
        stoneMap[0].insert(0);

        for (int stone : stones) {
            for (int k : stoneMap[stone]) {
                for (int step = k - 1; step <= k + 1; step++) {
                    if (step > 0 && stoneMap.count(stone + step)) {
                        stoneMap[stone + step].insert(step);
                    }
                }
            }
        }
        return !stoneMap[stones.back()].empty();
    }
};

def can_cross(stones: list[int]) -> bool:
    """
    @param stones: the positions of the stones, strictly increasing, starting at 0
    @return:       True iff the frog can reach the last stone under the k-1/k/k+1 rule
    """
    stone_map: dict[int, set[int]] = {s: set() for s in stones}
    stone_map[0].add(0)                        # "arrival" jump at the start

    for stone in stones:
        for k in list(stone_map[stone]):
            for step in (k - 1, k, k + 1):
                if step > 0 and (stone + step) in stone_map:
                    stone_map[stone + step].add(step)
    return bool(stone_map[stones[-1]])

#![allow(unused)]
fn main() {
use std::collections::{HashMap, HashSet};

impl Solution {
    /// @param stones the positions of the stones, strictly increasing, starting at 0
    /// @return       true iff the frog can reach the last stone under the k-1/k/k+1 rule
    pub fn can_cross(stones: Vec<i32>) -> bool {
        let mut stone_map: HashMap<i32, HashSet<i32>> =
            stones.iter().map(|&s| (s, HashSet::new())).collect();
        stone_map.get_mut(&0).unwrap().insert(0);       // "arrival" jump at the start

        for &stone in &stones {
            let jumps: Vec<i32> = stone_map[&stone].iter().cloned().collect();
            for k in jumps {
                for step in (k - 1)..=(k + 1) {
                    if step > 0 && stone_map.contains_key(&(stone + step)) {
                        stone_map.get_mut(&(stone + step)).unwrap().insert(step);
                    }
                }
            }
        }
        !stone_map[stones.last().unwrap()].is_empty()
    }
}
}

1. FrogJumpTopDown.kt — the whole DP in a getOrPut + any

2.8 documents the canonical version (set of reachable jumps per stone). This file compresses it to a two-line recurrence:

class FrogJumpTopDown {
    data class State(val pos: Int, val k: Int)

    fun canCross(stones: IntArray): Boolean {
        val stoneSet = stones.toSet()
        val cache = mutableMapOf<State, Boolean>()

        fun isValidJump(pos: Int, nextJump: Int) =
            nextJump > 0 && (pos + nextJump) in stoneSet

        fun solve(pos: Int, k: Int): Boolean =
            cache.getOrPut(State(pos, k)) {
                pos == stones.last() || (k - 1..k + 1).any { nextJump ->
                    isValidJump(pos, nextJump) && solve(pos + nextJump, nextJump)
                }
            }

        return solve(0, 0)
    }
}

What’s cool:

• (k - 1..k + 1).any { ... } — the three candidate jump lengths (k-1, k, k+1) are a range expression, not a loop. any short-circuits on the first successful jump.
• isValidJump as a named lambda-expression — nextJump > 0 && (pos + nextJump) in stoneSet; the stone-set membership IS the boundary check (no bounds arithmetic).
• pos == stones.last() — the base case is a boolean OR’d into the recurrence, not a separate branch.
• data class State — (pos, k) hashed by the map; the 17.4 state-value idiom.

The imperative version’s two loops (outer stones, inner jumps) are gone — the recurrence is the whole file.

Dry run

Input: stones = [0, 1, 3, 5, 6, 8, 12, 17]. Bottom-up propagation:

init:       stoneMap[0] = {0}
stone 0:    k=0 -> steps 1 -> land on 1    => stoneMap[1] = {1}
stone 1:    k=1 -> steps 1,2 -> land on 2?(no), 3  => stoneMap[3] = {2}
stone 3:    k=2 -> steps 1,2,3 -> land on 4?(no),5,6 => stoneMap[5]={2}, stoneMap[6]={3}
stone 5:    k=2 -> steps 1,2,3 -> land on 6,7?(no),8 => stoneMap[6]={3,2}, stoneMap[8]={3}
stone 6:    k=3 -> steps 2,3,4 -> land on 8,9?(no),10? => stoneMap[8]={3,2}
            k=2 -> steps 1,2,3 -> land on 7,8,9 -> stoneMap[8]={3,2} (2 already there)
stone 8:    k=3 -> steps 2,3,4 -> land on 10?,11?,12 => stoneMap[12]={4}
            k=2 -> steps 1,2,3 -> land on 9,10,11 -> nothing new
stone 12:   k=4 -> steps 3,4,5 -> land on 15?,16?,17 => stoneMap[17]={5}  ✓
stone 17:   stoneMap[17] = {5} non-empty -> true ✓

The answer emerges from watching a single jump size thread through the stones: 0→1 (k=1), 1→3 (k=2), 3→5 (k=2), 5→8 (k=3), 8→12 (k=4), 12→17 (k=5). Note stone 6 gets two jumps ({2, 3}) — the set is essential, because the k=3 arrival is what later enables the 8→12 jump.

Why the O(1) stone lookup matters: positions are sparse (gaps of any size), so stoneMap.containsKey avoids scanning. Without it, “is there a stone at p+step” would be $O(n)$ per probe.

Complexity

Time. Each stone holds up to $O(n)$ jumps; each jump spawns 3 probes:

$$ T(n) = O(n^2) \quad \text{(each (stone, jump) pair processed once)} $$

Space. The map holds one set per stone: $O(n^2)$ worst case.

Variants & follow-ups

• House Robber / classic jump games — different constraints, no jump-size memory; those are simpler 1D DPs. The memory of the last jump is what makes this state 2D.
• Interview follow-up: “Why can’t we use a boolean reachable[] array?” Because reachable[p] doesn’t record how you arrived; the next jump depends on the arrival jump. Two arrivals with different k have different futures — the set IS the state.
• Interview follow-up: “Can the top-down version skip the memo and still work?” Only for tiny inputs; without memoization solve(pos, k) is exponential (each call branches 3 ways and the same (pos, k) recurs across many paths). The memo is what makes it $O(n^2)$.

2.9 Super Egg Drop

Source: src/main/kotlin/dynamic_programming/SuperEggDropping.kt Pattern: state-inversion DP · Gym boss — the inverted table trick

The Problem

You have k eggs and a building with n floors. An egg dropped from floor f breaks if f >= F (the unknown critical floor) and survives otherwise. Once broken, an egg is gone. Find the minimum number of drops (in the worst case) needed to determine F with certainty.

• Constraints: $1 \le k \le 100$, $1 \le n \le 10^4$.

Examples

k = 1, n = 2  -> 2   (with one egg you must scan: floor 1, then floor 2)
k = 2, n = 6  -> 3   (drop from 3: break → scan 1..2 with 1 egg (2 more); survive → floors 4..6 with 2 eggs...)
k = 3, n = 14 -> 4   (the classic "2 eggs 14 floors"... with 3 eggs, 4 drops cover 15 floors)
k = 2, n = 100 -> 14 (the classic "2 eggs, 100 floors" answer)

Intuition — flip the question upside down

The direct DP (“minimum drops for k eggs and n floors”) has the recurrence:

$$ \text{drops}(k, n) = 1 + \min_{1 \le f \le n} \max!\big(\underbrace{\text{drops}(k-1, f-1)}{\text{breaks: k-1 eggs, f-1 floors below}}, \underbrace{\text{drops}(k, n-f)}{\text{survives: k eggs, n-f floors above}}\big) $$

That’s correct but $O(kn^2)$ — with $k = 100$ and $n = 10^4$, that’s $100 \times 10^8 = 10^{10}$ operations — far too slow. The repo uses the inverted state, which is the interview-gold trick:

$$ dp[\text{eggs}][\text{moves}] = \text{maximum number of floors that can be decisively tested with } \text{eggs} \text{ eggs and } \text{moves} \text{ moves} $$

The inversion: instead of asking “how many moves do k eggs need for n floors?”, ask “how many floors can k eggs cover in m moves?” The answer to the original problem is the smallest m with dp[k][m] >= n.

The recurrence (the beautiful part). With m moves and e eggs, drop once:

• If the egg breaks: you have e-1 eggs and m-1 moves left → can cover dp[e-1][m-1] floors below.
• If it survives: you have e eggs and m-1 moves → can cover dp[e][m-1] floors above.

So the drop at floor dp[e-1][m-1] + 1 is optimal, and the total coverage is:

$$ dp[e][m] = dp[e-1][m-1] + 1 + dp[e][m-1] $$

(one floor for the drop itself + what you can cover below + what you can cover above). With one move, one egg covers 1 floor (dp[1][1] = 1); with no floors to test, dp[e][0] = 0. The recurrence builds the whole “coverage” table, and the answer is the first m where dp[k][m] >= n.

Why this beats the direct DP: computing a single column m costs $O(k)$ (one pass over eggs), and the loop runs until coverage ≥ n — at most $\lceil \log_2 n \rceil$… no, actually up to n moves in the worst case with 1 egg, but with k ≥ 2 it’s $O(\sqrt n)$-ish; more precisely the loop runs m times and each column is $O(k)$, giving $O(k \cdot m)$ where m is the answer — tiny in practice (e.g. 14 for k=2, n=100).

Approach 1 — Direct DP (the “obvious” recurrence)

The $\min\max$ recurrence above, computed over all floors: $O(k n^2)$ time, $O(kn)$ space. Works for small inputs, and a good first answer to narrate — then the interviewer says “n is 10^4” and you invert.

Approach 2 — Inverted-state DP (optimal)

/**
 * @param k the number of eggs available
 * @param n the number of floors in the building
 * @return  the minimum number of drops (worst case) to determine the critical floor
 */
fun superEggDrop(k: Int, n: Int): Int {
    // dp[eggs][moves] = max floors decidable with `eggs` eggs and `moves` moves.
    val dp = Array(k + 1) { IntArray(n + 1) }
    var moves = 0

    // Grow the number of moves until k eggs can cover all n floors.
    while (dp[k][moves] < n) {
        moves++
        for (eggs in 1..k) {
            dp[eggs][moves] = dp[eggs][moves - 1] + dp[eggs - 1][moves - 1] + 1
        }
    }
    return moves
}

public class SuperEggDrop {
    /**
     * @param k the number of eggs available
     * @param n the number of floors in the building
     * @return  the minimum number of drops (worst case) to determine the critical floor
     */
    public int superEggDrop(int k, int n) {
        int[][] dp = new int[k + 1][n + 1];   // dp[eggs][moves] = floors coverable
        int moves = 0;
        while (dp[k][moves] < n) {
            moves++;
            for (int eggs = 1; eggs <= k; eggs++) {
                dp[eggs][moves] = dp[eggs][moves - 1] + dp[eggs - 1][moves - 1] + 1;
            }
        }
        return moves;
    }
}

#include <vector>

class SuperEggDrop {
public:
    /**
     * @param k the number of eggs available
     * @param n the number of floors in the building
     * @return  the minimum number of drops (worst case) to determine the critical floor
     */
    int superEggDrop(int k, int n) {
        std::vector<std::vector<int>> dp(k + 1, std::vector<int>(n + 1, 0));
        int moves = 0;
        while (dp[k][moves] < n) {
            moves++;
            for (int eggs = 1; eggs <= k; eggs++) {
                dp[eggs][moves] = dp[eggs][moves - 1] + dp[eggs - 1][moves - 1] + 1;
            }
        }
        return moves;
    }
};

def super_egg_drop(k: int, n: int) -> int:
    """
    @param k: the number of eggs available
    @param n: the number of floors in the building
    @return:  the minimum number of drops (worst case) to determine the critical floor
    """
    # dp[eggs][moves] = max floors decidable with `eggs` eggs and `moves` moves
    dp = [[0] * (n + 1) for _ in range(k + 1)]
    moves = 0
    while dp[k][moves] < n:
        moves += 1
        for eggs in range(1, k + 1):
            dp[eggs][moves] = dp[eggs][moves - 1] + dp[eggs - 1][moves - 1] + 1
    return moves

#![allow(unused)]
fn main() {
impl Solution {
    /// @param k the number of eggs available
    /// @param n the number of floors in the building
    /// @return  the minimum number of drops (worst case) to determine the critical floor
    pub fn super_egg_drop(k: i32, n: i32) -> i32 {
        let k = k as usize;
        let n = n as usize;
        let mut dp = vec![vec![0usize; n + 1]; k + 1];   // dp[eggs][moves] = floors coverable
        let mut moves = 0;
        while dp[k][moves] < n {
            moves += 1;
            for eggs in 1..=k {
                dp[eggs][moves] = dp[eggs][moves - 1] + dp[eggs - 1][moves - 1] + 1;
            }
        }
        moves as i32
    }
}
}

Dry run — watch the coverage table grow

Input: k = 2, n = 6. Table (rows = eggs, columns = moves):

        moves:   0   1   2   3
eggs=0          0   0   0   0
eggs=1          0   1   2   3        (1 egg, m moves covers m floors: linear scan)
eggs=2          0   1   3   6        (2 eggs, 3 moves covers 6 floors!)

Trace the cells:

moves=1: dp[1][1] = dp[1][0] + dp[0][0] + 1 = 1
         dp[2][1] = dp[2][0] + dp[1][0] + 1 = 1
moves=2: dp[1][2] = 0 + 1 + 1 = 2          (1 egg: floors 1, 2)
         dp[2][2] = dp[2][1] + dp[1][1] + 1 = 1 + 1 + 1 = 3
moves=3: dp[2][3] = dp[2][2] + dp[1][2] + 1 = 3 + 2 + 1 = 6

Loop check: after moves=1, dp[2][1] = 1 < 6 → keep going. After moves=2, dp[2][2] = 3 < 6 → keep going. After moves=3, dp[2][3] = 6 >= 6 → return 3. ✓ (matches the example)

The strategy behind 6 floors in 3 drops with 2 eggs: drop from floor dp[1][2] + 1 = 3. If it breaks → 1 egg, 2 moves left, floors 1–2 (linear scan). If it survives → 2 eggs, 2 moves left, floors 4–6, and by symmetry those 3 floors are coverable in 2 moves (drop from 5, etc.). Each move “spends” the current drop plus recursively covers both branches — exactly what the recurrence adds up.

Complexity

Time. The loop runs m times (m = answer), each pass is $O(k)$:

$$ T(k, n) = O(k \cdot m), \qquad m = \text{the answer} $$

The answer grows slowly: for $k \ge 2$ it’s $O(\sqrt{n})$ in the worst egg-constrained case and $O(\log n)$ when $k$ is large (the binary-search-with-many-eggs regime). With $n = 10^4$ and $k \le 100$: at most a few hundred column updates. (The direct DP would need $k \cdot n^2 = 10^{10}$ cells of work.)

Space. The table is $(k+1) \times (m+1)$ — roughly $O(k \cdot m)$, and since each cell reads only the previous column, it can be rolled to $O(k)$.

Variants & follow-ups

• Interview follow-up: “Why does 1 egg take exactly n drops?” With one egg you cannot afford a break (no egg left to continue), so you must scan linearly from floor 1 — the coverage table’s dp[1][m] = m is that scan.
• Interview follow-up: “Where does the $+1$ in the recurrence come from?” The current drop itself tests one specific floor; everything else is what the two outcomes let you explore. The recurrence is the formal way of saying “one drop buys you a floor plus two subproblems.”
• Interview follow-up: “Relate this to binary search.” With unlimited eggs (k ≥ log n), the strategy is pure binary search — dp[k][m] = 2^m - 1 (the recurrence telescopes to a geometric series). The table smoothly interpolates between linear scan (1 egg) and binary search (many eggs).

2.10 Minimum Cost To Cut A Stick

Source: src/main/kotlin/dynamic_programming/MinimumCostToCutAStick.kt Pattern: interval DP · Core page — the interval-DP template

The Problem

You have a wooden stick of length n. You must make all the cuts at the positions given in cuts (you can cut in any order). The cost of a cut is the length of the stick segment you are cutting. Minimize the total cost.

• Constraints: $2 \le n \le 10^6$, $1 \le cuts.length \le 100$.

Examples

n = 7, cuts = [1, 3, 4, 5]
Output: 16
Explanation: cutting at 3 first (cost 7), then 1 (cost 3), then 4 (cost 3), then 5 (cost 3)? 
             Let's find the optimal order: cut 3 → cost 7 (whole stick).
             Left [0,3]: cut 1 → cost 3. Right [3,7]: cut 5 → cost 4, then 4 → cost 2.
             Total = 7+3+4+2 = 16.

n = 9, cuts = [5, 6, 1, 4, 2]
Output: 22

Intuition — “the last cut” is the anchor

This is the canonical interval DP. The trap is thinking about the first cut; the insight is to think about the last cut.

Imagine a segment [left, right] (bounded by two already-made cuts). Whatever order we cut inside it, consider the last cut made inside this segment, at position k:

• Cutting the segment into [left, k] and [k, right] — but by the time this is the last cut, both halves are already fully cut.
• Total cost for [left, right] = (cost to fully cut [left, k]) + (cost to fully cut [k, right]) + the cost of the last cut itself, which is the current segment length points[right] - points[left] (because at that moment the two halves are still attached, so the segment being cut is the whole [left, right]).

That gives the recurrence:

$$ dp[left][right] = \min_{k \in (left, right)} \Big( dp[left][k] + dp[k][right] + \underbrace{(points[right] - points[left])}_{\text{cost of the last cut}} \Big) $$

with dp[left][left+1] = 0 (no cuts between two adjacent cut-points). The answer is dp[0][m-1] where points = [0] + sorted(cuts) + [n] — the cut positions plus the two ends of the stick.

Why the last cut, not the first? The cost of a cut depends on the current segment length, which is determined by which cuts have already been made. Reasoning forward, the first cut’s cost is always n (fixed) but it splits into subproblems of unknown length relationships. Reasoning backward, when the last cut at k happens, the segment [left, right] is still whole (both halves uncut), so its cost is deterministic: points[right] - points[left]. Backward reasoning turns an unknown future into a known present.

Why sort the cuts? The interval [left, right] must be a contiguous range of cut positions; only with sorted cuts do the subintervals partition cleanly.

Approach 1 — Try all permutations

There are m! orders of the m cuts. For m = 100: astronomically impossible. The DP collapses this to $O(m^3)$.

Approach 2 — Interval DP (optimal)

/**
 * @param n    the length of the stick
 * @param cuts the positions where cuts must be made (any order)
 * @return     the minimum total cost to make all cuts
 */
fun minCost(n: Int, cuts: IntArray): Int {
    val points = (intArrayOf(0) + cuts.sortedArray() + n)   // [0, ...sorted cuts..., n]
    val m = points.size
    val cache = Array(m) { IntArray(m) { -1 } }

    /**
     * @param left  index of the left boundary cut-point
     * @param right index of the right boundary cut-point
     * @return      minimum cost to fully cut the segment (points[left], points[right])
     */
    fun solve(left: Int, right: Int): Int = when {
        cache[left][right] != -1 -> cache[left][right]
        left + 1 >= right        -> 0                     // no cuts inside: free
        else -> (left + 1 until right).minOf { k ->
            // Last cut at points[k]; the two halves are solved first, then this
            // whole segment is cut once, costing its full length.
            (points[right] - points[left]) + solve(left, k) + solve(k, right)
        }.also { cache[left][right] = it }
    }

    return solve(0, m - 1)
}

import java.util.Arrays;

public class MinimumCostToCutAStick {
    private int[] points;
    private int[][] memo;

    /**
     * @param n    the length of the stick
     * @param cuts the positions where cuts must be made (any order)
     * @return     the minimum total cost to make all cuts
     */
    public int minCost(int n, int[] cuts) {
        int[] sorted = cuts.clone();
        Arrays.sort(sorted);
        points = new int[sorted.length + 2];
        points[0] = 0;
        System.arraycopy(sorted, 0, points, 1, sorted.length);
        points[points.length - 1] = n;

        memo = new int[points.length][points.length];
        for (int[] row : memo) Arrays.fill(row, -1);
        return solve(0, points.length - 1);
    }

    /**
     * @param left  index of the left boundary cut-point
     * @param right index of the right boundary cut-point
     * @return      minimum cost to fully cut the segment (points[left], points[right])
     */
    private int solve(int left, int right) {
        if (memo[left][right] != -1) return memo[left][right];
        if (left + 1 >= right) return 0;
        int best = Integer.MAX_VALUE;
        for (int k = left + 1; k < right; k++) {
            best = Math.min(best,
                (points[right] - points[left]) + solve(left, k) + solve(k, right));
        }
        return memo[left][right] = best;
    }
}

#include <vector>
#include <algorithm>
#include <climits>

class MinimumCostToCutAStick {
    std::vector<int> points;
    std::vector<std::vector<int>> memo;

public:
    /**
     * @param n    the length of the stick
     * @param cuts the positions where cuts must be made (any order)
     * @return     the minimum total cost to make all cuts
     */
    int minCost(int n, std::vector<int> cuts) {
        std::sort(cuts.begin(), cuts.end());
        points = {0};
        points.insert(points.end(), cuts.begin(), cuts.end());
        points.push_back(n);

        int m = (int)points.size();
        memo.assign(m, std::vector<int>(m, -1));
        return solve(0, m - 1);
    }

private:
    /**
     * @param left  index of the left boundary cut-point
     * @param right index of the right boundary cut-point
     * @return      minimum cost to fully cut the segment (points[left], points[right])
     */
    int solve(int left, int right) {
        if (memo[left][right] != -1) return memo[left][right];
        if (left + 1 >= right) return 0;
        int best = INT_MAX;
        for (int k = left + 1; k < right; k++) {
            best = std::min(best,
                (points[right] - points[left]) + solve(left, k) + solve(k, right));
        }
        return memo[left][right] = best;
    }
};

def min_cost(n: int, cuts: list[int]) -> int:
    """
    @param n:    the length of the stick
    @param cuts: the positions where cuts must be made (any order)
    @return:     the minimum total cost to make all cuts
    """
    points = [0] + sorted(cuts) + [n]
    m = len(points)
    from functools import lru_cache

    @lru_cache(None)
    def solve(left: int, right: int) -> int:
        """
        @param left:  index of the left boundary cut-point
        @param right: index of the right boundary cut-point
        @return:      minimum cost to fully cut the segment (points[left], points[right])
        """
        if left + 1 >= right:
            return 0                                   # no cuts inside: free
        return min(
            (points[right] - points[left]) + solve(left, k) + solve(k, right)
            for k in range(left + 1, right)
        )

    return solve(0, m - 1)

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param n    the length of the stick
    /// @param cuts the positions where cuts must be made (any order)
    /// @return     the minimum total cost to make all cuts
    pub fn min_cost(n: i32, cuts: Vec<i32>) -> i32 {
        let mut cuts = cuts;
        cuts.sort_unstable();
        let mut points = vec![0];
        points.extend(cuts);
        points.push(n);

        let mut memo: HashMap<(usize, usize), i32> = HashMap::new();
        fn solve(points: &[i32], memo: &mut HashMap<(usize, usize), i32>, left: usize, right: usize) -> i32 {
            if left + 1 >= right {
                return 0;
            }
            if let Some(&v) = memo.get(&(left, right)) {
                return v;
            }
            let mut best = i32::MAX;
            for k in (left + 1)..right {
                best = best.min(
                    (points[right] - points[left]) + solve(points, memo, left, k) + solve(points, memo, k, right),
                );
            }
            memo.insert((left, right), best);
            best
        }
        solve(&points, &mut memo, 0, points.len() - 1)
    }
}
}

2. StoneGame.kt — the zero-sum relative score

The “Current Player’s Score − Opponent’s Score” trick lets the DP avoid tracking turns:

fun stoneGame(piles: IntArray): Boolean {
    // Cache stores (i to j) -> Max relative score difference for that range
    val cache = mutableMapOf<Pair<Int, Int>, Int>()

    /**
     * Returns (Current Player's Score - Opponent's Score) for the range [i, j].
     * This "Relative Score" approach avoids needing to track whose turn it is.
     */
    fun pick(i: Int, j: Int): Int = cache.getOrPut(i to j) {
        when (i) {
            j -> piles[i]                        // one pile left: take it all

            // Subtract the opponent's result: the recursive call returns the
            // advantage for the NEXT player.
            else -> maxOf(
                piles[i] - pick(i + 1, j),       // take left, subtract opponent's net gain
                piles[j] - pick(i, j - 1)        // take right, subtract opponent's net gain
            )
        }
    }

    return pick(0, piles.lastIndex) >= 0
}

What’s cool: piles[i] - pick(i+1, j) — the relative score means the recursion never asks “whose turn?”; the sign flips encode it. The when (i) { j -> ... } base case is the single-pile boundary. This is the 2.x interval-DP family (2.10 style) with the zero-sum trick as the differentiator.

Dry run

Input: n = 7, cuts = [1, 3, 4, 5] → points = [0, 1, 3, 4, 5, 7].

Compute bottom-up-ish by increasing interval width (trace the key cells):

Width 1 (adjacent): solve(0,1)=solve(1,2)=...=0      (no cuts inside)
Width 2:
  solve(0,2): segment [0,3], cut at 1: cost (3-0) + 0 + 0 = 3
  solve(1,3): segment [1,4], cut at 3: cost (4-1) + 0 + 0 = 3
  solve(2,4): segment [3,5], cut at 4: cost (5-3) + 0 + 0 = 2
  solve(3,5): segment [4,7], cut at 5: cost (7-4) + 0 + 0 = 3
Width 3:
  solve(0,3): segment [0,4], cuts at {1,3}:
      last cut at 1 -> 4 + solve(0,1)=0 + solve(1,3)=3  = 7
      last cut at 3 -> 4 + solve(0,2)=3 + solve(2,3)=0  = 7   => 7
  solve(1,4): segment [1,5], cuts at {3,4}:
      last at 3 -> 4 + 0 + solve(3,4)=0? wait solve(1,3)=3 ... recompute:
      last at 3 -> (5-1)=4 + solve(1,3)=3 + solve(3,4)=0 = 7
      last at 4 -> 4 + solve(1,4)... hmm (1..4) excludes 4? k in (1,4) = {2,3}
      k=2 (cut 3): 4 + solve(1,2)=0 + solve(2,4)=2 = 6
      k=3 (cut 4): 4 + solve(1,3)=3 + solve(3,4)=0 = 7   => 6
  solve(2,5): segment [3,7], cuts at {4,5}:
      k=3 (cut 4): (7-3)=4 + solve(2,3)=0 + solve(3,5)=3 = 7
      k=4 (cut 5): 4 + solve(2,4)=2 + solve(4,5)=0 = 6      => 6
Width 4:
  solve(0,4): segment [0,5], cuts at {1,3,4}:
      k=1: 5 + solve(0,1)=0 + solve(1,4)=6  = 11
      k=2: 5 + solve(0,2)=3 + solve(2,4)=2  = 10
      k=3: 5 + solve(0,3)=7 + solve(3,4)=0  = 12           => 10
  solve(1,5): segment [1,7], cuts at {3,4,5}:
      k=2: 6 + solve(1,2)=0 + solve(2,5)=6  = 12
      k=3: 6 + solve(1,3)=3 + solve(3,5)=3  = 12
      k=4: 6 + solve(1,4)=6 + solve(4,5)=0  = 12           => 12
Width 5 (the answer):
  solve(0,5): segment [0,7], cuts at {1,3,4,5}:
      k=1: 7 + solve(0,1)=0 + solve(1,5)=12 = 19
      k=2: 7 + solve(0,2)=3 + solve(2,5)=6  = 16   ← best
      k=3: 7 + solve(0,3)=7 + solve(3,5)=3  = 17
      k=4: 7 + solve(0,4)=10 + solve(4,5)=0 = 17
Answer: 16 ✓   (last cut at 3: halves [0,3] cost 3 and [3,7] cost 6, plus the final 7)

The winning strategy reads off the trace: solve [0,3] and [3,7] fully (costs 3 and 6), then cut at 3 (cost 7) — total 16, matching the problem statement’s optimal order.

Complexity

Time. The state space is $O(m^2)$ intervals, each scanning $O(m)$ possible last cuts:

$$ T(n) = O(m^3), \qquad m = #cuts $$

With m ≤ 100: $\approx 10^6$ operations — trivial. (The length n never appears in the DP itself, only through points.)

Space. $O(m^2)$ memo table.

Variants & follow-ups

• 2.11 — the same interval shape with a different “last operation” story.
• Burst Balloons (src/main/kotlin/array/dp/BurstBaloons.kt) — the same “think about the last one” trick: fix the last balloon popped, then the subintervals are independent.
• Interview follow-up: “Why is the cost points[right] - points[left] and not points[k+1] - points[k-1]?” Because the last cut inside [left, right] happens when both halves are still attached — the segment being cut is the entire [left, right]. If we reasoned about the first cut, the future segment lengths would be unknown; backward reasoning makes them known.
• Interview follow-up: “Bottom-up version?” Fill by increasing interval width: for (len in 2..m) for (left in 0..m-len) { right = left+len; ... } — every cell reads strictly smaller intervals, so the order is safe.

2.11 Minimum Cost To Merge Stones

Source: src/main/kotlin/dynamic_programming/MinimumCostToMergeStones.kt · MinimumCostToMergeStones_Intuition.kt Pattern: interval DP with a pile-count dimension · Gym boss

The Problem

You have n piles of stones in a row, stones[i] stones in pile i. You may merge exactly k consecutive piles into one pile, paying a cost equal to the total stones in those k piles. Repeat until one pile remains. Find the minimum total cost, or -1 if impossible.

• Constraints: $1 \le n \le 30$, $1 \le k \le 30$, $n \le 1000$ stones per pile.

Examples

stones = [3, 2, 4, 1], k = 2
Output: 20
Explanation: merge 3+2=5 (cost 5) → [5,4,1]; merge 5+4=9 (cost 9) → [9,1];
             merge 9+1=10 (cost 10) → [10]. Total = 5+9+10 = 24? Hmm — the optimal
             is 3+2=5 → [5,4,1]; 4+1=5 → [5,5]; 5+5=10 → total 5+5+10 = 20 ✓

stones = [3, 2, 4, 1], k = 3
Output: -1
Explanation: 4 piles, k=3: each merge reduces the count by 2. 4 → 2 → 0 piles... 
             can't reach 1. (n-1) % (k-1) = 3 % 2 = 1 ≠ 0 → impossible.

Intuition — two layers of structure

Two ideas stack on top of each other:

Idea 1 — when is it even possible? Each merge turns k piles into 1, reducing the pile count by exactly k-1. To go from n piles to 1 we must reduce by n-1:

$$ (n - 1) \bmod (k - 1) = 0 \quad \Longleftrightarrow \quad \text{possible} $$

If the parity is wrong, no merge sequence exists — return -1 immediately.

Idea 2 — the 3D state. After merging inside a subarray [i, j], the number of piles that range collapses to depends on the boundaries. Let:

$$ dp[i][j][m] = \text{min cost to reduce } stones[i..j] \text{ to exactly } m \text{ piles} $$

Recurrences:

• Reduce to 1 pile: a range becomes 1 pile only after becoming k piles and merging them once. The final merge costs the whole range’s total stones (prefix-sum lookup):

$$ dp[i][j][1] = dp[i][j][k] + (prefix[j+1] - prefix[i]) $$

• Reduce to m piles (1 < m < k): split [i, j] into [i, p] (reduced to 1 pile) and [p+1, j] (reduced to m-1 piles). The merge of those m piles happens later; the cost here is just the sub-costs:

$$ dp[i][j][m] = \min_{p \in {i, i+(k-1), i+2(k-1), \dots}} \big(dp[i][p][1] + dp[p+1][j][m-1]\big) $$

Why step p by k-1? [i, p] must be reducible to exactly 1 pile, which by Idea 1 requires (p - i) % (k - 1) == 0. Skipping impossible split points is both a correctness requirement and a speedup.

Why the m dimension at all? Because ranges don’t always reduce to 1 pile — intermediate ranges hold m piles that will be merged with neighboring piles later. The dimension tracks exactly that “pending merge” state. This is what separates this problem from plain merge-cost DPs.

Approach — 3D memoized interval DP (optimal)

/**
 * @param stones the number of stones in each pile (in order)
 * @param k      exactly k consecutive piles must be merged at each step
 * @return       the minimum total merge cost, or -1 if impossible
 */
fun mergeStones(stones: IntArray, k: Int): Int {
    val n = stones.size

    // Parity check: each merge removes (k-1) piles; reaching 1 pile removes (n-1).
    if ((n - 1) % (k - 1) != 0) return -1

    val prefixSum = IntArray(n + 1)
    stones.forEachIndexed { index, stone -> prefixSum[index + 1] = prefixSum[index] + stone }

    // dp[i][j][m] = min cost to reduce stones[i..j] to exactly m piles; -1 = unknown
    val dp = Array(n) { Array(n) { IntArray(k + 1) { -1 } } }

    /**
     * @param i start index of the range
     * @param j end index of the range (inclusive)
     * @param m target pile count for this range
     * @return  min cost to reduce stones[i..j] to m piles
     */
    fun solve(i: Int, j: Int, m: Int): Int = when {
        dp[i][j][m] != -1 -> dp[i][j][m]

        i == j -> if (m == 1) 0 else Int.MAX_VALUE   // single pile: already 1 pile

        // To make 1 pile: first make k piles, then do ONE final merge of the whole range.
        m == 1 -> solve(i, j, k) + (prefixSum[j + 1] - prefixSum[i])

        // To make m piles: split [i, p] into 1 pile, [p+1, j] into (m-1) piles.
        else -> {
            var minCost = Int.MAX_VALUE
            // p must satisfy (p - i) % (k - 1) == 0 so [i, p] can collapse to 1 pile.
            for (p in i until j step k - 1) {
                val left = solve(i, p, 1)
                val right = solve(p + 1, j, m - 1)
                if (left != Int.MAX_VALUE && right != Int.MAX_VALUE) {
                    minCost = minOf(minCost, left + right)
                }
            }
            minCost
        }
    }.also { dp[i][j][m] = it }

    return solve(0, n - 1, 1)
}

import java.util.Arrays;

public class MinimumCostToMergeStones {
    private int[] prefix;
    private int[][][] memo;
    private int k;

    /**
     * @param stones the number of stones in each pile (in order)
     * @param k      exactly k consecutive piles must be merged at each step
     * @return       the minimum total merge cost, or -1 if impossible
     */
    public int mergeStones(int[] stones, int k) {
        int n = stones.length;
        if ((n - 1) % (k - 1) != 0) return -1;            // parity check

        prefix = new int[n + 1];
        for (int i = 0; i < n; i++) prefix[i + 1] = prefix[i] + stones[i];
        memo = new int[n][n][k + 1];
        for (int[][] a : memo) for (int[] b : a) Arrays.fill(b, -1);
        this.k = k;
        return solve(0, n - 1, 1);
    }

    /**
     * @param i start index of the range
     * @param j end index of the range (inclusive)
     * @param m target pile count for this range
     * @return  min cost to reduce stones[i..j] to m piles
     */
    private int solve(int i, int j, int m) {
        if (memo[i][j][m] != -1) return memo[i][j][m];
        if (i == j) return m == 1 ? 0 : Integer.MAX_VALUE;

        int best = Integer.MAX_VALUE;
        if (m == 1) {
            int sub = solve(i, j, k);
            if (sub != Integer.MAX_VALUE) best = sub + (prefix[j + 1] - prefix[i]);
        } else {
            for (int p = i; p < j; p += k - 1) {           // step by k-1: divisibility
                int left = solve(i, p, 1);
                int right = solve(p + 1, j, m - 1);
                if (left != Integer.MAX_VALUE && right != Integer.MAX_VALUE) {
                    best = Math.min(best, left + right);
                }
            }
        }
        return memo[i][j][m] = best;
    }
}

#include <vector>
#include <algorithm>
#include <climits>

class MinimumCostToMergeStones {
    std::vector<int> prefix;
    std::vector<std::vector<std::vector<int>>> memo;
    int k;

public:
    /**
     * @param stones the number of stones in each pile (in order)
     * @param k      exactly k consecutive piles must be merged at each step
     * @return       the minimum total merge cost, or -1 if impossible
     */
    int mergeStones(const std::vector<int>& stones, int k) {
        int n = (int)stones.size();
        if ((n - 1) % (k - 1) != 0) return -1;

        prefix.assign(n + 1, 0);
        for (int i = 0; i < n; i++) prefix[i + 1] = prefix[i] + stones[i];
        memo.assign(n, std::vector<std::vector<int>>(n, std::vector<int>(k + 1, -1)));
        this->k = k;
        return solve(0, n - 1, 1);
    }

private:
    int solve(int i, int j, int m) {
        if (memo[i][j][m] != -1) return memo[i][j][m];
        if (i == j) return m == 1 ? 0 : INT_MAX;

        int best = INT_MAX;
        if (m == 1) {
            int sub = solve(i, j, k);
            if (sub != INT_MAX) best = sub + (prefix[j + 1] - prefix[i]);
        } else {
            for (int p = i; p < j; p += k - 1) {
                int left = solve(i, p, 1);
                int right = solve(p + 1, j, m - 1);
                if (left != INT_MAX && right != INT_MAX) best = std::min(best, left + right);
            }
        }
        return memo[i][j][m] = best;
    }
};

def merge_stones(stones: list[int], k: int) -> int:
    """
    @param stones: the number of stones in each pile (in order)
    @param k:      exactly k consecutive piles must be merged at each step
    @return:       the minimum total merge cost, or -1 if impossible
    """
    n = len(stones)
    if (n - 1) % (k - 1) != 0:
        return -1                                  # parity check

    prefix = [0] * (n + 1)
    for i, s in enumerate(stones):
        prefix[i + 1] = prefix[i] + s

    from functools import lru_cache

    @lru_cache(None)
    def solve(i: int, j: int, m: int) -> int:
        """
        @param i: start index of the range
        @param j: end index of the range (inclusive)
        @param m: target pile count for this range
        @return:  min cost to reduce stones[i..j] to m piles
        """
        if i == j:
            return 0 if m == 1 else float("inf")
        if m == 1:                                 # first make k piles, then one final merge
            sub = solve(i, j, k)
            return sub + (prefix[j + 1] - prefix[i]) if sub != float("inf") else float("inf")
        best = float("inf")
        for p in range(i, j, k - 1):               # step by k-1: [i,p] must collapse to 1 pile
            left, right = solve(i, p, 1), solve(p + 1, j, m - 1)
            if left != float("inf") and right != float("inf"):
                best = min(best, left + right)
        return best

    return solve(0, n - 1, 1)

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param stones the number of stones in each pile (in order)
    /// @param k      exactly k consecutive piles must be merged at each step
    /// @return       the minimum total merge cost, or -1 if impossible
    pub fn merge_stones(stones: Vec<i32>, k: i32) -> i32 {
        let n = stones.len();
        let k = k as usize;
        if (n - 1) % (k - 1) != 0 {
            return -1;
        }
        let mut prefix = vec![0i32; n + 1];
        for i in 0..n {
            prefix[i + 1] = prefix[i] + stones[i];
        }

        let mut memo: HashMap<(usize, usize, usize), i32> = HashMap::new();
        fn solve(
            memo: &mut HashMap<(usize, usize, usize), i32>,
            prefix: &[i32],
            k: usize,
            i: usize,
            j: usize,
            m: usize,
        ) -> i32 {
            if let Some(&v) = memo.get(&(i, j, m)) {
                return v;
            }
            let result = if i == j {
                if m == 1 { 0 } else { i32::MAX }
            } else if m == 1 {
                let sub = solve(memo, prefix, k, i, j, k);
                if sub == i32::MAX {
                    i32::MAX
                } else {
                    sub + (prefix[j + 1] - prefix[i])
                }
            } else {
                let mut best = i32::MAX;
                let mut p = i;
                while p < j {
                    let left = solve(memo, prefix, k, i, p, 1);
                    let right = solve(memo, prefix, k, p + 1, j, m - 1);
                    if left != i32::MAX && right != i32::MAX {
                        best = best.min(left + right);
                    }
                    p += k - 1;                      // step by k-1: divisibility
                }
                best
            };
            memo.insert((i, j, m), result);
            result
        }
        solve(&mut memo, &prefix, k, 0, n - 1, 1)
    }
}
}

Dry run

Input: stones = [3, 2, 4, 1], k = 2. Parity: (4-1) % (2-1) = 0 ✓.

k = 2 makes every split point valid (step 1), and m ∈ {1, 2}. Trace the key cells:

i == j cases: solve(i,i,1) = 0; solve(i,i,2) = inf

Length-2 ranges (m=1): solve(0,1,1) = solve(0,1,2) + (3+2) = (left+right)+5
   solve(0,1,2): split p=0: solve(0,0,1)=0 + solve(1,1,1)=0 = 0
   solve(0,1,1) = 0 + 5 = 5        (merge 3,2 → cost 5)
   solve(1,2,1) = 0 + (2+4) = 6    (merge 2,4)
   solve(2,3,1) = 0 + (4+1) = 5    (merge 4,1)

Length-3 (m=1): solve(0,2,1): needs solve(0,2,2)
   solve(0,2,2): p=0: solve(0,0,1)=0 + solve(1,2,1)=6 = 6
                 p=1: solve(0,1,1)=5 + solve(2,2,1)=0 = 5  → 5
   solve(0,2,1) = 5 + (3+2+4)=9 = 14
   solve(1,3,1): solve(1,3,2): p=1: 0 + solve(2,3,1)=5 = 5
                               p=2: solve(1,2,1)=6 + 0 = 6 → 5
   solve(1,3,1) = 5 + (2+4+1)=7 = 12

Length-4 (the answer): solve(0,3,1): needs solve(0,3,2)
   solve(0,3,2): p=0: solve(0,0,1)=0 + solve(1,3,1)=12 = 12
                 p=1: solve(0,1,1)=5 + solve(2,3,1)=5  = 10   ← best
                 p=2: solve(0,2,1)=14 + solve(3,3,1)=0 = 14   → 10
   solve(0,3,1) = 10 + (3+2+4+1)=10 = 20
Answer: 20 ✓

The trace reveals the optimal plan: merge [0,1] (3+2=5, cost 5), merge [2,3] (4+1=5, cost 5) — now two piles [5, 5] — then the final merge costs 10. Total 20, matching the example. Note the two independent merges happen first, and the final merge of the whole range is exactly the + (prefix[j+1] - prefix[i]) term.

Impossible case: stones = [3,2,4,1], k = 3 → (4-1) % (3-1) = 3 % 2 = 1 ≠ 0 → return -1 before any DP work.

Complexity

Time. $O(n^3)$ states-ish: $n^2$ ranges × $k$ pile-counts × $n/k$ split points:

$$ T(n) = O!\left(\frac{n^3}{k}\right) \cdot O(1) \approx O(n^3) $$

With n ≤ 30: a few thousand cells — instant.

Space. $O(n^2 k)$ for the memo table.

Variants & follow-ups

• 2.10 — the simpler interval DP; same “last operation” reasoning, no m dimension.
• Burst Balloons (src/main/kotlin/array/dp/BurstBaloons.kt) — same family; fix the last balloon and the subintervals become independent.
• Stone Game (src/main/kotlin/array/dp/StoneGame.kt) — a different game on the same stones, solved by minimax DP; the contrast is a great “which DP is this?” drill.
• Interview follow-up: “Why does the m == 1 case need solve(i, j, k) before adding the total?” Because a range can only become 1 pile by first becoming k piles and then merging them all at once — the +total is that one final merge, and it must happen after the range is reduced to k piles.
• Interview follow-up: “What changes for k = 2?” The problem degenerates to the classic matrix-chain/merge cost (every split valid, m only ever 1 or 2) — a good sanity check that the general solution reduces correctly.

2.13 Maximum Profit In Job Scheduling

Source: src/main/kotlin/dynamic_programming/MaximumProfitInJobScheduling.kt Pattern: sort + binary-search DP · Gym page — DP meets this book’s Chapter 1

The Problem

You have n jobs, each with a startTime, an endTime, and a profit. You can schedule non-overlapping jobs (a job’s start must be ≥ the previous job’s end) to maximize total profit. Return the max profit.

• Constraints: $1 \le n \le 5 \times 10^4$.

Examples

startTime = [1, 2, 3, 3], endTime = [3, 4, 5, 6], profit = [50, 10, 40, 70]
Output: 120
Explanation: job 1 (1→3, 50) + job 3 (3→5, 40) + job 4 (3→6, 70)? No — jobs 3 and 4 both start at 3.
             Best: job 1 (50) + job 4 (70) = 120 (1→3 then 3→6). Or job 1 + job 3 = 90.
             Actually job 1 (50) + job 3 (40) + ... job 3 ends at 5, nothing after. 120 it is.

startTime = [1, 2, 3, 4, 6], endTime = [3, 5, 10, 6, 9], profit = [20, 20, 100, 70, 60]
Output: 150
Explanation: job 4 (4→6, 70) + job 5 (6→9, 60) = 130; job 2 (2→5,20) + job 5 = 80...
             job 1 (20) + job 2 (20) + job 5 (60) = 100; job 3 alone = 100;
             job 2 (2→5, 20) + job 4 (4→6, 70)? overlap. 150 = job 1 (20) + job 4 (70) + job 5 (60) = 150 ✓

Intuition — “skip or take” with a binary search for the predecessor

This is a weighted interval scheduling — the classic DP that every real “resource scheduling” system uses. The recipe:

1. Sort jobs by end time. Now “consider the first i jobs” is a meaningful prefix, and “the last job that doesn’t overlap job i” is a contiguous prefix of the sorted list (all jobs with end <= start_i come before some point).
2. DP on the prefix:

$$ dp[i] = \max!\big(\underbrace{dp[i-1]}{\text{skip job } i}, \underbrace{profit_i + dp[p(i)]}{\text{take job } i}\big) $$

where $p(i)$ = index of the last job before i with end <= start_i — found by binary search on the sorted-by-end list (Chapter 1’s lower-bound machinery from 1.0).

Why $dp[p(i)]$ and not “the best non-overlapping anything”? Any valid schedule ending before start_i is, by the end-time ordering, a schedule among the first p(i) jobs — and the best such schedule is exactly dp[p(i)] by induction. So “take job i” reduces to “best schedule that finishes before job i starts” — one binary search + one lookup.

Why sorting by end (not start)? The prefix property “jobs ≤ some point all end before a deadline” is only true in end-time order. Sorting by start breaks it (a late-starting job can end early).

Approach 1 — Brute force

Try all $2^n$ subsets, check pairwise non-overlap. $2^{50000}$ — the prompt itself is the joke.

Approach 2 — Sort + binary-search DP (optimal)

/**
 * @param startTime the start time of each job
 * @param endTime   the end time of each job
 * @param profit    the profit of each job
 * @return          the maximum profit from non-overlapping jobs
 */
fun jobScheduling(startTime: IntArray, endTime: IntArray, profit: IntArray): Int {
    // Bundle jobs and sort by END time — this gives the "prefix" structure.
    val jobs = startTime.indices
        .map { Job(startTime[it], endTime[it], profit[it]) }
        .sortedBy { it.end }

    val dp = IntArray(jobs.size)
    dp[0] = jobs[0].profit

    for (i in 1 until jobs.size) {
        dp[i] = dp[i - 1]                       // skip job i

        val prevJobIndex = findLastNonOverlappingJob(jobs, i)   // binary search
        val currentProfit = jobs[i].profit + if (prevJobIndex != -1) dp[prevJobIndex] else 0

        dp[i] = maxOf(dp[i], currentProfit)     // take job i (if better)
    }
    return dp.last()
}

/**
 * @param jobs        the jobs sorted by end time
 * @param currentIndex the index of the job being scheduled
 * @return            the index of the last job with end <= jobs[currentIndex].start, or -1
 */
private fun findLastNonOverlappingJob(jobs: List<Job>, currentIndex: Int): Int {
    val currentJob = jobs[currentIndex]
    var low = 0
    var high = currentIndex - 1
    var best = -1

    while (low <= high) {                     // Template: last index with jobs[mid].end <= start
        val mid = (low + high) / 2
        if (jobs[mid].end <= currentJob.start) {
            best = mid
            low = mid + 1                     // candidate works; try a later one
        } else {
            high = mid - 1
        }
    }
    return best
}

import java.util.*;

public class MaximumProfitInJobScheduling {
    /**
     * @param startTime the start time of each job
     * @param endTime   the end time of each job
     * @param profit    the profit of each job
     * @return          the maximum profit from non-overlapping jobs
     */
    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
        int n = startTime.length;
        int[][] jobs = new int[n][3];
        for (int i = 0; i < n; i++) jobs[i] = new int[]{startTime[i], endTime[i], profit[i]};
        Arrays.sort(jobs, (a, b) -> a[1] - b[1]);        // sort by end time

        int[] dp = new int[n];
        dp[0] = jobs[0][2];
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i - 1];                            // skip job i
            int prev = findLastNonOverlapping(jobs, i);   // binary search
            dp[i] = Math.max(dp[i], jobs[i][2] + (prev == -1 ? 0 : dp[prev]));
        }
        return dp[n - 1];
    }

    /**
     * @param jobs the jobs sorted by end time
     * @param i    the index of the job being scheduled
     * @return     the last index with jobs[idx].end <= jobs[i].start, or -1
     */
    private int findLastNonOverlapping(int[][] jobs, int i) {
        int lo = 0, hi = i - 1, best = -1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (jobs[mid][1] <= jobs[i][0]) { best = mid; lo = mid + 1; }
            else hi = mid - 1;
        }
        return best;
    }
}

#include <vector>
#include <algorithm>

class MaximumProfitInJobScheduling {
public:
    /**
     * @param startTime the start time of each job
     * @param endTime   the end time of each job
     * @param profit    the profit of each job
     * @return          the maximum profit from non-overlapping jobs
     */
    int jobScheduling(const std::vector<int>& startTime,
                      const std::vector<int>& endTime,
                      const std::vector<int>& profit) {
        int n = (int)startTime.size();
        std::vector<std::array<int, 3>> jobs(n);
        for (int i = 0; i < n; i++) jobs[i] = {startTime[i], endTime[i], profit[i]};
        std::sort(jobs.begin(), jobs.end(), [](const auto& a, const auto& b) { return a[1] < b[1]; });

        std::vector<int> dp(n);
        dp[0] = jobs[0][2];
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i - 1];                              // skip job i
            int prev = findLastNonOverlapping(jobs, i);     // binary search
            dp[i] = std::max(dp[i], jobs[i][2] + (prev == -1 ? 0 : dp[prev]));
        }
        return dp[n - 1];
    }

private:
    /**
     * @param jobs the jobs sorted by end time
     * @param i    the index of the job being scheduled
     * @return     the last index with jobs[idx][1] <= jobs[i][0], or -1
     */
    int findLastNonOverlapping(const std::vector<std::array<int, 3>>& jobs, int i) {
        int lo = 0, hi = i - 1, best = -1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (jobs[mid][1] <= jobs[i][0]) { best = mid; lo = mid + 1; }
            else hi = mid - 1;
        }
        return best;
    }
};

def job_scheduling(start_time: list[int], end_time: list[int], profit: list[int]) -> int:
    """
    @param start_time: the start time of each job
    @param end_time:   the end time of each job
    @param profit:     the profit of each job
    @return:           the maximum profit from non-overlapping jobs
    """
    jobs = sorted(zip(start_time, end_time, profit), key=lambda j: j[1])   # sort by end
    n = len(jobs)
    dp = [0] * n
    dp[0] = jobs[0][2]

    def last_non_overlapping(i: int) -> int:
        """
        @param i: the index of the job being scheduled
        @return:  the last index with jobs[idx][1] <= jobs[i][0], or -1
        """
        lo, hi, best = 0, i - 1, -1
        while lo <= hi:
            mid = (lo + hi) // 2
            if jobs[mid][1] <= jobs[i][0]:
                best = mid
                lo = mid + 1
            else:
                hi = mid - 1
        return best

    for i in range(1, n):
        dp[i] = dp[i - 1]                                   # skip job i
        prev = last_non_overlapping(i)
        dp[i] = max(dp[i], jobs[i][2] + (dp[prev] if prev != -1 else 0))
    return dp[-1]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param start_time the start time of each job
    /// @param end_time   the end time of each job
    /// @param profit     the profit of each job
    /// @return           the maximum profit from non-overlapping jobs
    pub fn job_scheduling(start_time: Vec<i32>, end_time: Vec<i32>, profit: Vec<i32>) -> i32 {
        let n = start_time.len();
        let mut jobs: Vec<(i32, i32, i32)> = (0..n).map(|i| (start_time[i], end_time[i], profit[i])).collect();
        jobs.sort_by_key(|j| j.1);                           // sort by end time

        let mut dp = vec![0i32; n];
        dp[0] = jobs[0].2;
        for i in 1..n {
            dp[i] = dp[i - 1];                               // skip job i
            // binary search: last job with end <= start of job i
            let (mut lo, mut hi, mut best) = (0usize, i, usize::MAX);
            while lo < hi {
                let mid = (lo + hi) / 2;
                if jobs[mid].1 <= jobs[i].0 {
                    best = mid;
                    lo = mid + 1;
                } else {
                    hi = mid;
                }
            }
            let prev = if best == usize::MAX { 0 } else { dp[best] };
            dp[i] = dp[i].max(jobs[i].2 + prev);
        }
        dp[n - 1]
    }
}
}

Dry run

Input: startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70].

Sort by end: jobs become [1→3:50], [2→4:10], [3→5:40], [3→6:70].

i=0: dp[0] = 50                                        (take job 0)
i=1: skip -> dp[1] = 50
     findLastNonOverlapping(1): jobs[0].end=3 <= 2? NO -> best=-1
     take -> 10 + 0 = 10. dp[1] = max(50, 10) = 50
i=2: skip -> dp[2] = 50
     findLastNonOverlapping(2): jobs[1].end=4 <= 3? NO; jobs[0].end=3 <= 3? YES -> best=0
     take -> 40 + dp[0] = 40 + 50 = 90. dp[2] = max(50, 90) = 90
i=3: skip -> dp[3] = 90
     findLastNonOverlapping(3): jobs[2].end=5<=3?NO; jobs[1].end=4<=3?NO; jobs[0].end=3<=3?YES -> best=0
     take -> 70 + dp[0] = 70 + 50 = 120. dp[3] = max(90, 120) = 120
Answer: 120 ✓  (job 0 then job 3: [1→3] + [3→6])

The binary search at i=3 found jobs[0] (end 3 ≤ start 3 — sharing an instant is allowed) in 2 probes instead of scanning 3 jobs. With $n = 5 \times 10^4$, that’s the difference between $O(n^2)$ (2.5 billion) and $O(n \log n)$ (~800k).

Complexity

Time. Sorting $O(n \log n)$ + one binary search per job:

$$ T(n) = O(n \log n) $$

Space. $O(n)$ (jobs + dp).

Variants & follow-ups

• Weighted interval scheduling — this exact problem is the textbook example; the unweighted version is greedy (earliest finish time), the weighted one needs DP. Saying why (weight makes “more jobs” ≠ “more value”) is a classic probe.
• Interview follow-up: “What if jobs can share boundaries (end == start)?” The code already allows it (end <= start); if instead they couldn’t, flip to end < start — one character.
• Interview follow-up: “Reconstruct the schedule.” Store the choice: if dp[i] came from take, walk back via p(i); else via i-1. $O(n)$ reconstruction after the table.

2.14 Count Ways To Pick K Coins Divisible By M

Source: src/main/kotlin/google/CountNumberOfWaysToPickKCoinsSumDivisibleByM.kt Pattern: memoized (index, count, remainder) · Core page

The Problem

Coins are numbered 0..n-1. Count how many ways to pick exactly k coins such that their sum is divisible by m (result mod $10^9+7$).

• Constraints: $1 \le k \le n$; m fits in Int.

Examples

Input:  n = 4, k = 2, m = 3   -> Output: 2   ({0,3} and {1,2} both sum to a multiple of 3)
Input:  n = 5, k = 3, m = 3   -> Output: 2

Intuition — the state is (index, picks left, remainder); the remainder is the carry

The count-with-a-condition DP needs three axes:

• idx — which coin we’re deciding next;
• k — how many picks remain;
• rem — the running sum modulo m (the only part of the sum that matters for divisibility).

The recurrence is the classic pick/skip:

solve(idx, k, rem):
    k == 0        -> 1 iff rem == 0
    (n - idx) < k -> 0               (not enough coins left — pruning)
    else          -> solve(idx+1, k, rem)                 # skip coin idx
                  +  solve(idx+1, k-1, (rem + idx) % m)   # pick coin idx

Why does rem carry modulo instead of the raw sum? Only sum % m decides divisibility, and (a + b) % m is computable from a % m — so the remainder is a complete summary of the sum, bounded by m instead of by n·m. That’s what keeps the state space at $O(n \cdot k \cdot m)$ rather than exponential.

Why the (n - idx) < k pruning? If fewer coins remain than picks needed, no completion exists — the branch dies without recursion. The same “remaining resources vs remaining needs” cut as 11.2’s reachability frontier, in DP clothing.

The coins are 0-indexed (the repo’s comment: coins = [0, 1, 2, 3]), so picking coin idx adds idx to the sum — (rem + idx) % m. Careful: not idx + 1.

Approach 1 — Enumerate all C(n, k) combinations (exponential)

Generate every k-subset and check the sum: correct, dies at n = 20.

Approach 2 — Memoized (idx, k, rem) (the repo’s version, optimal)

fun countWays(n: Int, k: Int, m: Int): Int {
    val mod = 1_000_000_007
    data class State(val idx: Int, val k: Int, val rem: Int)

    val _cache = mutableMapOf<State, Int>()

    fun solve(idx: Int, k: Int, rem: Int): Int =
        _cache.getOrPut(State(idx, k, rem)) {
            when {
                k == 0 -> if (rem == 0) 1 else 0
                // Pruning: if coins remaining (n - idx) < coins needed (k), stop
                (n - idx) < k || idx == n -> 0
                else -> {
                    val skip = solve(idx + 1, k, rem)
                    val pick = solve(idx + 1, k - 1, (rem + (idx % m)) % m)
                    (skip + pick) % mod
                }
            }
        }

    return solve(0, k, 0)
}

import java.util.*;

public class CountWaysToPickKCoinsDivisibleByM {
    private static final int MOD = 1_000_000_007;

    /**
     * @param n number of coins (0..n-1)
     * @param k coins to pick
     * @param m divisor
     * @return  ways to pick k coins with sum divisible by m
     */
    public int countWays(int n, int k, int m) {
        Map<String, Integer> memo = new HashMap<>();
        return solve(0, k, 0, n, m, memo);
    }

    private int solve(int idx, int k, int rem, int n, int m, Map<String, Integer> memo) {
        if (k == 0) return rem == 0 ? 1 : 0;
        if (n - idx < k || idx == n) return 0;

        String key = idx + "," + k + "," + rem;
        if (memo.containsKey(key)) return memo.get(key);

        int skip = solve(idx + 1, k, rem, n, m, memo);
        int pick = solve(idx + 1, k - 1, (rem + idx) % m, n, m, memo);
        int result = (skip + pick) % MOD;
        memo.put(key, result);
        return result;
    }
}

#include <cstring>

class CountWaysToPickKCoinsDivisibleByM {
    long long memo[31][31][31];
    int n, m, k;
    const long long MOD = 1'000'000'007LL;

    long long solve(int idx, int left, int rem) {
        if (left == 0) return rem == 0 ? 1 : 0;
        if (n - idx < left || idx == n) return 0;
        if (memo[idx][left][rem] != -1) return memo[idx][left][rem];

        long long skip = solve(idx + 1, left, rem);
        long long pick = solve(idx + 1, left - 1, (rem + idx) % m);
        return memo[idx][left][rem] = (skip + pick) % MOD;
    }

public:
    /**
     * @param n number of coins (0..n-1)
     * @param k coins to pick
     * @param m divisor
     * @return  ways to pick k coins with sum divisible by m
     */
    int countWays(int n, int k, int m) {
        this->n = n; this->k = k; this->m = m;
        std::memset(memo, -1, sizeof memo);
        return (int)solve(0, k, 0);
    }
};

from functools import lru_cache

MOD = 1_000_000_007

def count_ways(n: int, k: int, m: int) -> int:
    """
    @param n: number of coins (0..n-1)
    @param k: coins to pick
    @param m: divisor
    @return:  ways to pick k coins with sum divisible by m
    """
    @lru_cache(None)
    def solve(idx: int, left: int, rem: int) -> int:
        if left == 0:
            return 1 if rem == 0 else 0
        if n - idx < left or idx == n:
            return 0                        # not enough coins left — pruning

        skip = solve(idx + 1, left, rem)
        pick = solve(idx + 1, left - 1, (rem + idx) % m)
        return (skip + pick) % MOD

    return solve(0, k, 0)

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param n number of coins (0..n-1)
    /// @param k coins to pick
    /// @param m divisor
    /// @return  ways to pick k coins with sum divisible by m
    pub fn count_ways(n: i32, k: i32, m: i32) -> i32 {
        const MOD: i64 = 1_000_000_007;
        let mut memo: HashMap<(i32, i32, i32), i64> = HashMap::new();

        fn solve(idx: i32, left: i32, rem: i32, n: i32, m: i32,
                 memo: &mut HashMap<(i32, i32, i32), i64>) -> i64 {
            if left == 0 { return if rem == 0 { 1 } else { 0 }; }
            if n - idx < left || idx == n { return 0; }      // pruning

            if let Some(&v) = memo.get(&(idx, left, rem)) { return v; }
            let skip = solve(idx + 1, left, rem, n, m, memo);
            let pick = solve(idx + 1, left - 1, (rem + idx) % m, n, m, memo);
            let v = (skip + pick) % MOD;
            memo.insert((idx, left, rem), v);
            v
        }

        solve(0, k, 0, n, m, &mut memo) as i32
    }
}
}

Dry run

Input: n = 4, k = 2, m = 3 — coins {0,1,2,3}, pick 2 with sum % 3 == 0.

enumerate (idx strictly increasing): pairs {0,3} -> 0+3=3 ✓, {1,2} -> 3 ✓.
All other pairs: 0+1=1, 0+2=2, 1+3=4≡1, 2+3=5≡2 -> fail.  Answer: 2.

DP path (abridged): solve(0,2,0)
  skip -> solve(1,2,0): eventually counts pairs among {1,2,3}: {1,2} ✓ -> 1
  pick -> solve(1,1,0%3=0): counts pairs starting with coin 0:
            pick coin 1 -> solve(2,0,1): rem 1 != 0 -> 0
            pick coin 2 -> solve(3,0,2): 0
            pick coin 3 -> solve(4,0,3%3=0): 1  -> the {0,3} pair ✓
  total = 1 + 1 = 2 ✓

The remainder carry in action: picking coin 3 adds 3 % 3 = 0, so the state (4, 0, 0) closes the {0,3} choice — the raw sum never appears, only its residue. The pruning (n - idx) < left kills branches like “pick 2 coins from only 1 remaining” instantly.

Complexity

Time. States n × k × m, O(1) per state:

$$ T(n, k, m) = O(n \cdot k \cdot m) $$

Space. The memo:

$$ S(n, k, m) = O(n \cdot k \cdot m) $$

Variants & follow-ups

• Target Sum (array/dp/TargetSum.kt) — the same (index, remainder-carry) counting, with a signed target instead of a modulo.
• Partition Equal Subset Sum (2.6) — divisibility reachability without the pick-count axis.
• Interview follow-up: “Why does rem make the state small?” Only sum % m determines divisibility, and it composes under addition — so the remainder is a lossless summary of the sum, bounded by m (≤ 30 here). Replace the remainder with the raw sum and the state space explodes to $n \cdot k \cdot (n \cdot m)$.

2.15 Maximal Square

Source: src/main/kotlin/array/dp/MaximalSquare.kt Pattern: 2-D DP, min-of-three · Core page

The Problem

Given a binary matrix of '0'/'1', return the area of the largest square made of '1's.

• Constraints: $m, n \le 300$; characters '0' or '1'.

Examples

Input:  matrix = [["1","0","1","0","0"],
                  ["1","0","1","1","1"],
                  ["1","1","1","1","1"],
                  ["1","0","0","1","0"]]
Output: 4   (the 2x2 block of 1s)

Input:  matrix = [["0","1"],["1","0"]]   -> Output: 1

Intuition — dp[i][j] = the largest square ending at (i,j)

Define dp[i][j] = side length of the largest all-1 square whose bottom-right corner is (i, j). The recurrence is the 2.7-style local-state idea:

$$ dp[i][j] = 1 + \min(dp[i-1][j],; dp[i][j-1],; dp[i-1][j-1]) $$

Why the min-of-three? A square ending at (i,j) of side s requires squares of side s-1 ending at the left, above, and diagonally-above-left cells — all three must hold '1'-blocks of that size. The min is the limiting factor: the largest square you can extend is one more than the smallest of the three neighbors. If any is 0, dp[i][j] = 1 (just the cell itself).

Why bottom-right anchoring? The three neighbors (i-1,j), (i,j-1), (i-1,j-1) are all “earlier” in row-major order — so a single pass computes the whole table, and the answer is the max over all dp values. This is the same “local definition, global max” shape as 2.1.

Area vs side: the repo tracks maxSize (side) and returns maxSize * maxSize — the problem asks for area. The 1x1 base case (i == 0 || j == 0 → dp = 1) is the boundary seeding.

Approach 1 — Brute force per cell (O(m^2 n^2))

For each (i,j), try growing a square outward: correct, quartic on the worst case.

Approach 2 — Min-of-three DP (the repo’s version, optimal)

class MaximalSquare {
    /**
     * @param matrix binary matrix of '0'/'1'
     * @return       area of the largest all-1 square
     */
    fun maximalSquare(matrix: Array<CharArray>): Int {
        if (matrix.isEmpty() || matrix[0].isEmpty()) return 0
        val m = matrix.size
        val n = matrix[0].size
        val dp = Array(m) { IntArray(n) }
        var maxSize = 0

        for (i in 0 until m) {
            for (j in 0 until n) {
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1                     // boundary cell
                    } else {
                        dp[i][j] = minOf(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1
                    }
                    maxSize = maxOf(maxSize, dp[i][j])
                }
            }
        }
        return maxSize * maxSize                         // area
    }
}

public class MaximalSquare {
    /**
     * @param matrix binary matrix of '0'/'1'
     * @return       area of the largest all-1 square
     */
    public int maximalSquare(char[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[][] dp = new int[m][n];
        int maxSize = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) dp[i][j] = 1;                       // boundary
                    else dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
                    maxSize = Math.max(maxSize, dp[i][j]);
                }
            }
        }
        return maxSize * maxSize;                        // area
    }
}

#include <vector>

class MaximalSquare {
public:
    /**
     * @param matrix binary matrix of '0'/'1'
     * @return       area of the largest all-1 square
     */
    int maximalSquare(std::vector<std::vector<char>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        std::vector<std::vector<int>> dp(m, std::vector<int>(n, 0));
        int maxSize = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) dp[i][j] = 1;                       // boundary
                    else dp[i][j] = std::min({dp[i-1][j], dp[i][j-1], dp[i-1][j-1]}) + 1;
                    maxSize = std::max(maxSize, dp[i][j]);
                }
            }
        }
        return maxSize * maxSize;                        // area
    }
};

def maximal_square(matrix: list[list[str]]) -> int:
    """
    @param matrix: binary matrix of '0'/'1'
    @return:       area of the largest all-1 square
    """
    m, n = len(matrix), len(matrix[0])
    dp = [[0] * n for _ in range(m)]
    max_size = 0

    for i in range(m):
        for j in range(n):
            if matrix[i][j] == "1":
                if i == 0 or j == 0:
                    dp[i][j] = 1                     # boundary cell
                else:
                    dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
                max_size = max(max_size, dp[i][j])
    return max_size * max_size                       # area

#![allow(unused)]
fn main() {
impl Solution {
    /// @param matrix binary matrix of '0'/'1'
    /// @return       area of the largest all-1 square
    pub fn maximal_square(matrix: Vec<Vec<char>>) -> i32 {
        let (m, n) = (matrix.len(), matrix[0].len());
        let mut dp = vec![vec![0i32; n]; m];
        let mut max_size = 0;

        for i in 0..m {
            for j in 0..n {
                if matrix[i][j] == '1' {
                    dp[i][j] = if i == 0 || j == 0 { 1 }                     // boundary
                               else { dp[i-1][j].min(dp[i][j-1]).min(dp[i-1][j-1]) + 1 };
                    max_size = max_size.max(dp[i][j]);
                }
            }
        }
        max_size * max_size                          // area
    }
}
}

2. MaximalRectangle.kt — the histogram-stack upgrade

The classic “largest rectangle in a binary matrix” via per-row histograms + the 8.5 stack:

class MaximalRectangle {
    fun largestRectangleArea(heights: IntArray): Int {
        val stack = Stack<Int>()
        var (maxArea, i) = listOf(0, 0)

        while (i <= heights.size) {
            val currentHeight = if (i == heights.size) 0 else heights[i]   // sentinel 0 flushes

            when {
                stack.isEmpty() || heights[stack.last()] <= currentHeight -> stack.add(i++)
                else -> {
                    val height = heights[stack.pop()]
                    val width = if (stack.isEmpty()) i else i - stack.peek() - 1
                    maxArea = maxOf(maxArea, height * width)
                }
            }
        }
        return maxArea
    }
    // ... plus the per-row histogram accumulation: heights[j] = if (matrix[i][j] == '1') heights[j] + 1 else 0
}

What’s cool: the i == heights.size ? 0 sentinel flushes the stack without a post-loop; the when is the monotonic-stack three-way decision (8.5 compressed); and the row-major histogram update turns the matrix problem into repeated 1-D problems.

Dry run

Input: matrix = [["1","1"],["1","1"]].

i=0, j=0: '1', boundary -> dp[0][0]=1.  maxSize=1
i=0, j=1: '1', boundary -> dp[0][1]=1.  maxSize=1
i=1, j=0: '1', boundary -> dp[1][0]=1.  maxSize=1
i=1, j=1: '1' -> dp[1][1] = min(1,1,1) + 1 = 2.  maxSize=2

Output: 2*2 = 4 ✓

The min-of-three at (1,1): all three neighbors report side-1 squares, so the cell extends them to side 2. If any neighbor were 0 (say dp[0][1] = 0), the min would be 0 and the cell could only start a fresh side-1 square — that’s the “all three must support it” rule in one expression.

Complexity

Time. One pass over the grid:

$$ T(m, n) = O(m \cdot n) $$

Space. The dp table (two rows suffice — the rolling-row variant):

$$ S(m, n) = O(m \cdot n) $$

Variants & follow-ups

• Maximal Rectangle (grid/histogram/MaximalRectangle.kt) — the rectangle version: per-row histogram + 8.5’s monotonic stack.
• Largest Square Area In Matrix (google/LargestSquareAreaInMatrix.kt) — the same DP under another name.
• Interview follow-up: “Why min of the three neighbors and not max?” A side-s square at (i,j) needs side-(s-1) squares at all three neighbors. The weakest neighbor is the constraint — min selects it. Using max would count squares that don’t fully tile the cell’s neighborhood.

2.16 Coin Change

Source: src/main/kotlin/array/dp/CoinChange.kt (+ CoinChangeBottomUp.kt, CoinChange_II.kt, CoinChangeBFS.kt — four repo implementations) Pattern: unbounded-knapsack minimization · Core page

The Problem

Given coins (denominations, unlimited supply) and an amount, return the fewest coins that make that amount, or -1.

• Constraints: $1 \le$ coins ≤ 12; amount ≤ 10⁴; coin values ≤ 2³¹.

Examples

Input:  coins = [1,2,5], amount = 11   -> Output: 3   (5 + 5 + 1)
Input:  coins = [2], amount = 3        -> Output: -1  (impossible)

Intuition — dp[a] = fewest coins for amount a; every coin is one more step

The classic unbounded-knapsack minimization. Define dp[a] = minimum coins to make exactly a. The last coin chosen is some c ≤ a, so:

$$ dp[a] = 1 + \min_{c \in coins,; c \le a} dp[a - c] $$

Top-down (the repo’s CoinChange.kt): coinChange(amount) recurses on amount - coin; the dp array is the memo. Bottom-up (CoinChangeBottomUp.kt / coinChangeCleanAf): fill dp[1..amount] in order — every subproblem’s answer is already computed because a - c < a. Both are the 2.4 unbounded shape; the difference is max-value → min-count.

The amount + 1 sentinel — dp initialized to amount + 1 (an impossible count) makes “can’t reach” self-evident: if dp[amount] is still the sentinel, return -1. No separate visited bookkeeping.

The BFS variant (CoinChangeBFS.kt) — each “amount” is a node, each coin an edge a → a - c; the first time 0 is reached gives the fewest coins. Same complexity, a different mental model.

Approach 1 — Greedy (fails!)

Take the largest coin first: [1,3,4], amount = 6 → greedy picks 4+1+1 (3 coins); optimal is 3+3 (2). Coin systems aren’t canonical — this is the 11.0 greedy-fails red flag.

Approach 2 — Bottom-up DP (the repo’s versions, optimal)

class CoinChange {
    /**
     * @param coins  denominations (unlimited supply)
     * @param amount target amount
     * @return       fewest coins, or -1 if impossible
     */
    fun coinChange(coins: IntArray, amount: Int): Int {
        val maxVal = amount + 1                          // sentinel: impossible
        val dp = IntArray(amount + 1) { maxVal }
        dp[0] = 0

        for (i in 1..amount) {
            for (coin in coins) {
                if (coin <= i) {
                    dp[i] = minOf(dp[i], dp[i - coin] + 1)
                }
            }
        }
        return dp[amount].takeIf { it <= amount } ?: -1
    }
}

public class CoinChange {
    /**
     * @param coins  denominations (unlimited supply)
     * @param amount target amount
     * @return       fewest coins, or -1 if impossible
     */
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, amount + 1);                     // sentinel: impossible
        dp[0] = 0;

        for (int i = 1; i <= amount; i++) {
            for (int c : coins) {
                if (c <= i) dp[i] = Math.min(dp[i], dp[i - c] + 1);
            }
        }
        return dp[amount] <= amount ? dp[amount] : -1;
    }
}

#include <vector>
#include <algorithm>

class CoinChange {
public:
    /**
     * @param coins  denominations (unlimited supply)
     * @param amount target amount
     * @return       fewest coins, or -1 if impossible
     */
    int coinChange(std::vector<int>& coins, int amount) {
        std::vector<int> dp(amount + 1, amount + 1);     // sentinel: impossible
        dp[0] = 0;

        for (int i = 1; i <= amount; i++) {
            for (int c : coins) {
                if (c <= i) dp[i] = std::min(dp[i], dp[i - c] + 1);
            }
        }
        return dp[amount] <= amount ? dp[amount] : -1;
    }
};

def coin_change(coins: list[int], amount: int) -> int:
    """
    @param coins:  denominations (unlimited supply)
    @param amount: target amount
    @return:       fewest coins, or -1 if impossible
    """
    dp = [amount + 1] * (amount + 1)     # sentinel: impossible
    dp[0] = 0

    for i in range(1, amount + 1):
        for c in coins:
            if c <= i:
                dp[i] = min(dp[i], dp[i - c] + 1)

    return dp[amount] if dp[amount] <= amount else -1

#![allow(unused)]
fn main() {
impl Solution {
    /// @param coins  denominations (unlimited supply)
    /// @param amount target amount
    /// @return       fewest coins, or -1 if impossible
    pub fn coin_change(coins: Vec<i32>, amount: i32) -> i32 {
        let amount = amount as usize;
        let mut dp = vec![amount + 1; amount + 1];   // sentinel: impossible
        dp[0] = 0;

        for i in 1..=amount {
            for &c in &coins {
                if (c as usize) <= i {
                    dp[i] = dp[i].min(dp[i - c as usize] + 1);
                }
            }
        }
        if dp[amount] <= amount { dp[amount] as i32 } else { -1 }
    }
}
}

Sources: src/main/kotlin/array/dp/ — CoinChange.kt, CoinChangeBottomUp.kt, CoinChangeBFS.kt, CoinChange_II.kt, CoinChange_II_BottomUp.kt Pattern: variant gallery — one problem, four engines (2.16 covers the bottom-up winner)

The family map

The BFS surprise: CoinChangeBFS.kt

The coolest of the four: “fewest coins to reach amount” is exactly “shortest path from 0 to amount in a graph where each coin is an edge x → x + coin”. BFS finds it in O(amount · coins):

fun coinChangeBFS(coins: IntArray, amount: Int): Int {
    if (amount == 0) return 0

    val queue = ArrayDeque<Int>().apply { add(0) }
    val visited = mutableSetOf(0)
    var steps = 0

    while (queue.isNotEmpty()) {
        steps++
        repeat(queue.size) {                  // one level = one coin
            val current = queue.removeFirst()
            for (coin in coins) {
                val next = current + coin
                if (next == amount) return steps
                if (next < amount && visited.add(next)) {
                    queue.add(next)
                }
            }
        }
    }
    return -1
}

Why it’s correct: every path from 0 to amount uses k edges = k coins, and BFS finds the minimum hop count. Why visited? Amounts are re-reachable many ways (0+1+1 vs 0+2); the first visit is the fewest coins, so revisits are pruned — same as 6.14’s fresh == INF guard. The steps counter with repeat(queue.size) is the 5.2 level fence.

When to reach for it in an interview: when the problem is phrased as reachability (“can you make the amount? what’s the minimum number of coins?”) — the graph framing is a different intuition that some interviewers love, and it pairs beautifully with the DP as “two views of the same recurrence”.

The counting twin: CoinChange_II.kt

“Number of ways” flips the recurrence from min to sum, and the loop order matters — coins outer, amounts inner makes each combination counted once:

// CoinChange_II.kt (bottom-up counting)
fun change(amount: Int, coins: IntArray): Int {
    val dp = IntArray(amount + 1)
    dp[0] = 1                                    // one way to make 0: take nothing

    for (coin in coins) {                        // coin loop OUTSIDE
        for (a in coin..amount) {
            dp[a] += dp[a - coin]                // order matters: combinations, not permutations
        }
    }
    return dp[amount]
}

The coin-outer loop is the classic “count combinations vs permutations” distinction (2.6’s ascending-vs-descending discussion is this exact subtlety). dp[0] = 1 seeds the empty combination.

The top-down in the same file: CoinChange.kt

class CoinChange {
    fun coinChange(coins: IntArray, amount: Int): Int {
        val dp = IntArray(amount + 1) { -1 }
        return coinChange(coins, amount, dp).let { if (it != Int.MAX_VALUE) it else -1 }
    }

    private fun coinChange(coins: IntArray, amount: Int, dp: IntArray): Int {
        return when {
            amount == 0 -> 0
            dp[amount] != -1 -> dp[amount]
            else -> {
                var minCoins = Int.MAX_VALUE
                for (coin in coins) {
                    if (coin <= amount) {
                        val result = coinChange(coins, amount - coin, dp)
                        if (result != Int.MAX_VALUE) {
                            minCoins = minOf(minCoins, 1 + result)
                        }
                    }
                }
                minCoins
            }
        }.also { dp[amount] = it }
    }
}

The Int.MAX_VALUE sentinel marks “unreachable”; the .also { dp[amount] = it } memoizes on every return path (including the base cases — harmless). The -1 sentinel in the public wrapper distinguishes “impossible” from “0 coins”.

Dry run (BFS)

Input: coins = [1,2,5], amount = 11.

queue=[0], visited={0}, steps=0
steps=1: 0 -> 1, 2, 5.  queue=[1,2,5]
steps=2: 1 -> 2(seen),3,6.  2 -> 3(seen),4,7.  5 -> 6(seen),7(seen),10.  queue=[3,6,4,7,10]
steps=3: 3 -> 4(seen),5(seen),8.  6 -> 7(seen),8(seen),11 == amount -> return 3 ✓

BFS finds 11 at depth 3 (5+5+1) — the visited set keeps the frontier small (amounts reached cheaply are never re-expanded). The DP and BFS agree: fewest coins = 3.

Dry run

Input: coins = [1,2,5], amount = 11.

dp[0]=0
dp[1] = 1 + dp[0] = 1.   dp[2] = min(1+dp[1], 1+dp[0]) = min(2,1) = 1.
dp[3] = min(1+dp[2], 1+dp[1]) = 2.   dp[4] = min(1+dp[3], 1+dp[2]) = 2.
dp[5] = min(1+dp[4], 1+dp[3], 1+dp[0]) = min(3,3,1) = 1.   (one 5-cent coin!)
dp[6] = min(1+dp[5], 1+dp[4], 1+dp[1]) = 2.
dp[7] = 2.  dp[8] = min(1+dp[7],1+dp[6],1+dp[3]) = 3.
dp[9] = 3.  dp[10] = min(1+dp[9],1+dp[8],1+dp[5]) = 2.
dp[11] = min(1+dp[10],1+dp[9],1+dp[6]) = min(3,4,3) = 3.

Output: 3 ✓   (5 + 5 + 1)

The min over coins is the whole algorithm: each dp[i] re-uses the best answer for i - c, and the sentinel 12 never propagates into reachable cells. coins = [2], amount = 3 → dp[3] stays the sentinel → -1 ✓.

Complexity

Time. Amount × coins:

$$ T(A, C) = O(A \cdot C) $$

Space. The dp array:

$$ S(A) = O(A) $$

Variants & follow-ups

• Coin Change II (array/dp/CoinChange_II.kt, also CoinChange_II_BottomUp.kt) — count the ways instead of the minimum: dp[c] += dp[c - coin] with the coin loop outside (order matters — see the 2.6 ascending-vs-descending discussion).
• Minimum Number Of Refueling Stops (11.7) — the greedy twin: reachability with a max-heap instead of a table.
• Interview follow-up: “Why does the coin loop need the coin <= i guard?” dp[i - coin] would index below 0 for a coin larger than the current amount — the guard is the bounds check that keeps the recurrence valid. (And why greedy fails: [1,3,4], 6 → 4+1+1 vs 3+3, because non-canonical systems break the “largest-first” assumption.)

2.17 House Robber

Source: src/main/kotlin/array/dp/HouseRobber.kt (+ HouseRobber_II.kt, MaximumSumOfNonAdjacentElements.kt — the same problem under two names) Pattern: include/exclude DP with two running vars · Core page

The Problem

Given nums[i] (money in house i), rob the maximum amount without robbing adjacent houses.

• Constraints: $1 \le n \le 100$; values fit in Int.

Examples

Input:  nums = [2,7,9,3,1]   -> Output: 12   (rob houses 0, 2, 4)
Input:  nums = [2,1,1,2]     -> Output: 4    (rob 0 and 3)

Intuition — at each house, “take it” vs “skip it”; only the last two answers matter

The decision at house i is binary: rob it (then house i-1 is off-limits) or skip it. The classic recurrence:

$$ dp[i] = \max(dp[i-1],; nums[i] + dp[i-2]) $$

Why do only two previous answers matter? dp[i] depends only on dp[i-1] and dp[i-2] — the repo’s rob_iterative carries them as two variables (include, exclude) with a temp swap, reaching $O(1)$ space. This is the “rolling two” pattern from 2.16’s table compressed to scalars.

The repo’s top-down (rob(dp, nums, i)) reads: maxOf(nums[i] + rob(i+2), rob(i+1)) — the same recurrence written as a memoized DFS. Both are the 12.0 include/exclude shape without the undo (no constraint to respect besides adjacency).

The i >= nums.size -> 0 base case is the chain’s end: beyond the last house, nothing to rob. dp indexed by house position (not amount) because the order is the constraint — compare 2.16 where amount was the axis.

Approach 1 — Memoized recursion (the repo’s style)

rob(i) = max(rob(i+1), nums[i] + rob(i+2)) with an IntArray memo: correct, $O(n)$ space.

Approach 2 — Two rolling variables (the repo’s rob_iterative, optimal)

class HouseRobber {
    /**
     * @param nums money per house
     * @return     max money without robbing adjacent houses
     */
    fun rob(nums: IntArray): Int {
        if (nums.isEmpty()) return 0

        var include = 0       // best ending with robbing the current house
        var exclude = 0       // best ending with skipping it

        for (num in nums) {
            val temp = include
            include = num + exclude      // rob this house: must have skipped the last
            exclude = maxOf(temp, exclude)   // skip this house: keep the better of the two
        }
        return maxOf(include, exclude)
    }
}

public class HouseRobber {
    /**
     * @param nums money per house
     * @return     max money without robbing adjacent houses
     */
    public int rob(int[] nums) {
        int include = 0, exclude = 0;
        for (int num : nums) {
            int temp = include;
            include = num + exclude;                 // rob this: skip the previous
            exclude = Math.max(temp, exclude);       // skip this: keep the best so far
        }
        return Math.max(include, exclude);
    }
}

#include <vector>
#include <algorithm>

class HouseRobber {
public:
    /**
     * @param nums money per house
     * @return     max money without robbing adjacent houses
     */
    int rob(std::vector<int>& nums) {
        int include = 0, exclude = 0;
        for (int num : nums) {
            int temp = include;
            include = num + exclude;                 // rob this: skip the previous
            exclude = std::max(temp, exclude);       // skip this: keep the best so far
        }
        return std::max(include, exclude);
    }
};

def rob(nums: list[int]) -> int:
    """
    @param nums: money per house
    @return:     max money without robbing adjacent houses
    """
    include = exclude = 0
    for num in nums:
        temp = include
        include = num + exclude          # rob this: skip the previous
        exclude = max(temp, exclude)     # skip this: keep the best so far
    return max(include, exclude)

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums money per house
    /// @return     max money without robbing adjacent houses
    pub fn rob(nums: Vec<i32>) -> i32 {
        let (mut include, mut exclude) = (0, 0);
        for num in nums {
            let temp = include;
            include = num + exclude;             // rob this: skip the previous
            exclude = temp.max(exclude);         // skip this: keep the best so far
        }
        include.max(exclude)
    }
}
}

Reading the code — what’s actually happening

var include = 0       // best ending with robbing the current house
var exclude = 0       // best ending with skipping it
for (num in nums) {
    val temp = include
    include = num + exclude          // rob this house: must have skipped the last
    exclude = maxOf(temp, exclude)   // skip this house: keep the better of the two
}
return maxOf(include, exclude)

Two variables act as a tiny state machine, and the order of the three lines is the entire logic. Walk through one house at a time:

• include means “the best total where the last house was robbed”. To rob house i, house i-1 must NOT have been robbed — so the new include is num + exclude (this house’s money plus the best total ending with a skip before it). We never add to the old include, because robbing two adjacent houses is illegal.
• exclude means “the best total where the last house was skipped”. Skipping house i lets us keep whichever was better before: maxOf(temp, exclude) — temp is the old include (we could have robbed the previous house and now skip this one), exclude is the old skip. Taking the max is the DP’s “best so far”.
• temp preserves the old include because the next line overwrites it. Without the save, exclude would compare against the new include — double-counting this house. This is the classic rolling-variable shuffle: three values, two slots, one temp.
• After the loop, the answer is max(include, exclude) — the best ending with a rob vs. the best ending with a skip; the better of the two is the global optimum.

Trace [2,7,9,3,1]: after house 2 (value 2): include 2, exclude 0. House 7: include 7+0=7, exclude max(2,0)=2. House 9: include 9+2=11, exclude max(7,2)=7. House 3: include 3+7=10, exclude 11. House 1: include 1+11=12, exclude 11. Answer max(12,11)=12 ✓ — houses 0, 2, 4.

Dry run

Input: nums = [2,7,9,3,1].

include=0, exclude=0
num=2: temp=0.  include=2+0=2.  exclude=max(0,0)=0.
num=7: temp=2.  include=7+0=7.  exclude=max(2,0)=2.
num=9: temp=7.  include=9+2=11. exclude=max(7,2)=7.
num=3: temp=11. include=3+7=10. exclude=max(11,7)=11.
num=1: temp=10. include=1+11=12. exclude=max(10,11)=11.

Output: max(12, 11) = 12 ✓   (houses 0, 2, 4 = 2+9+1)

The swap is the state machine: include (rob this house → must have skipped the last) always rebuilds from exclude, and exclude (skip this house → keep the running best) absorbs the old include via temp. Two scalars carry the whole recurrence dp[i] = max(dp[i-1], nums[i] + dp[i-2]).

Complexity

Time. One pass:

$$ T(n) = O(n) $$

Space. Two variables:

$$ S(n) = O(1) $$

Variants & follow-ups

• House Robber II (array/dp/HouseRobber_II.kt) — the circular street: run the linear DP twice (skip house 0, skip house n-1) and take the max. Same two-variable core.
• House Robber III (graph/HouseRobber3.kt) — the tree version: post-order with (rob, skip) pairs per node (see 5.4’s DFS-returning-state shape).
• House Robber IV (1.10) — the binary-search twist: minimize the capability with a greedy feasibility check.
• Interview follow-up: “Why can’t you just take every other house?” The optimum isn’t necessarily an alternating pattern ([2,1,1,2] → take 0 and 3 = 4, but alternating from 0 gives 2+1=3). The DP’s max-at-each-step is what lets the pattern break and rejoin.

2.18 Maximum Subarray (Kadane’s Algorithm)

Source: src/main/kotlin/array/dp/KadensAlgorithm.kt (+ array/dp/MaximumSumSubArray.kt) Pattern: running best-ending-here · Core page

The Problem

Given nums (may be negative), find the maximum sum of any contiguous subarray.

• Constraints: $1 \le n \le 10^5$; values fit in Int.

Examples

Input:  nums = [-2,1,-3,4,-1,2,1,-5,4]   -> Output: 6   (the subarray [4,-1,2,1])
Input:  nums = [1]                       -> Output: 1

Intuition — at each index, the best subarray ending here is either “this element alone” or “this element + the best ending before”

The recurrence that makes Kadane famous:

$$ \text{bestEnding}[i] = \max(nums[i],; \text{bestEnding}[i-1] + nums[i]) $$

Why max(nums[i], ...)? If the running sum went negative (or any sum below the bare element), restarting at nums[i] beats extending — negative prefixes are always discarded. This is the “carry or restart” decision, and the repo’s dp[0]/dp[1] two-slot array is just bestEnding and the global best:

dp[0] = max(nums[i], dp[0] + nums[i])   # best subarray ENDING at i
dp[1] = max(dp[1], dp[0])               # best subarray ANYWHERE up to i

Why is this DP (not greedy)? It has the optimal-substructure flavor: the global answer is the max over all bestEnding[i] — the 2.1 “local definition, global max” idiom in its purest 1-D form. The O(1) space is the 2.17 rolling-variable compression.

All-negative arrays are handled by the max(nums[i], ...) restart: the answer is the least negative element — the algorithm never returns 0 for [-5,-2] (it returns -2).

Approach 1 — All subarrays (O(n^2))

Double loop over every window: correct, quadratic — the baseline Kadane kills.

Approach 2 — Kadane’s one pass (the repo’s version, optimal)

class KadensAlgorithm {
    /**
     * @param nums input array (may be negative)
     * @return     max sum of a contiguous subarray
     */
    fun maxSubArray(nums: IntArray): Int {
        if (nums.isEmpty()) return 0

        // dp[0]: max sum ending at the current index
        // dp[1]: overall max sum found so far
        val dp = IntArray(2)
        dp[0] = nums[0]
        dp[1] = nums[0]

        for (i in 1 until nums.size) {
            dp[0] = maxOf(nums[i], dp[0] + nums[i])   // carry or restart
            dp[1] = maxOf(dp[1], dp[0])               // update the global best
        }
        return dp[1]
    }
}

public class MaximumSubarray {
    /**
     * @param nums input array (may be negative)
     * @return     max sum of a contiguous subarray
     */
    public int maxSubArray(int[] nums) {
        int bestEnding = nums[0], best = nums[0];

        for (int i = 1; i < nums.length; i++) {
            bestEnding = Math.max(nums[i], bestEnding + nums[i]);   // carry or restart
            best = Math.max(best, bestEnding);
        }
        return best;
    }
}

#include <vector>
#include <algorithm>

class MaximumSubarray {
public:
    /**
     * @param nums input array (may be negative)
     * @return     max sum of a contiguous subarray
     */
    int maxSubArray(std::vector<int>& nums) {
        int bestEnding = nums[0], best = nums[0];

        for (int i = 1; i < (int)nums.size(); i++) {
            bestEnding = std::max(nums[i], bestEnding + nums[i]);   // carry or restart
            best = std::max(best, bestEnding);
        }
        return best;
    }
};

def max_sub_array(nums: list[int]) -> int:
    """
    @param nums: input array (may be negative)
    @return:     max sum of a contiguous subarray
    """
    best_ending = best = nums[0]

    for num in nums[1:]:
        best_ending = max(num, best_ending + num)   # carry or restart
        best = max(best, best_ending)
    return best

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums input array (may be negative)
    /// @return     max sum of a contiguous subarray
    pub fn max_sub_array(nums: Vec<i32>) -> i32 {
        let mut best_ending = nums[0];
        let mut best = nums[0];

        for &num in &nums[1..] {
            best_ending = num.max(best_ending + num);   // carry or restart
            best = best.max(best_ending);
        }
        best
    }
}
}

Reading the code — what’s actually happening

val dp = IntArray(2)
dp[0] = nums[0]
dp[1] = nums[0]
for (i in 1 until nums.size) {
    dp[0] = maxOf(nums[i], dp[0] + nums[i])   // carry or restart
    dp[1] = maxOf(dp[1], dp[0])               // update the global best
}
return dp[1]

The two-slot array holds two very different things, and keeping them straight is the whole trick:

• dp[0] = best subarray sum ending exactly at the current index. This is the “carry or restart” decision: either extend the previous best-ending subarray (dp[0] + nums[i]) or abandon it and start fresh at nums[i] alone. The max picks whichever is larger. Why is restart ever right? If the carried sum is negative, adding it to nums[i] only drags the total down — a negative prefix can never help a later subarray, so it’s discarded. (That’s also why all-negative arrays work: every step restarts, and the answer is the least-negative element, never 0.)
• dp[1] = best subarray sum anywhere up to the current index. This is the global champion: the max of every dp[0] seen so far. It only ever increases — it’s a running maximum over the local answers.
• Why one pass is enough: any maximum subarray must end somewhere; its value was, at that moment, a dp[0] candidate. So scanning all endings and keeping the max over them captures every possible subarray — no window enumeration needed. That’s the optimal-substructure property: the global answer is the max of the local definitions.

Trace [-2,1,-3,4,-1,2,1,-5,4]: endings go -2, 1, -2, 4, 3, 5, 6, 1, 5 — the global best climbs 1 → 4 → 5 → 6 and stays 6 through the trailing -5,4. Answer 6 ✓ (the subarray [4,-1,2,1]).

Dry run

Input: nums = [-2,1,-3,4,-1,2,1,-5,4].

bestEnding=best=-2
i=1 (1):  bestEnding = max(1, -2+1) = 1.   best = max(-2, 1) = 1
i=2 (-3): bestEnding = max(-3, 1-3) = -2.  best = 1
i=3 (4):  bestEnding = max(4, -2+4) = 4.   best = 4
i=4 (-1): bestEnding = max(-1, 4-1) = 3.   best = 4
i=5 (2):  bestEnding = max(2, 3+2) = 5.    best = 5
i=6 (1):  bestEnding = max(1, 5+1) = 6.    best = 6
i=7 (-5): bestEnding = max(-5, 6-5) = 1.   best = 6
i=8 (4):  bestEnding = max(4, 1+4) = 5.    best = 6

Output: 6 ✓   (the subarray [4,-1,2,1])

The “carry or restart” moments: at i=2 the carry goes negative (-2) — the i=3 restart at 4 discards it, exactly as Kadane intends. The global best only ever increases; the trailing -5,4 can’t beat 6.

Complexity

Time. One pass:

$$ T(n) = O(n) $$

Space. Two variables:

$$ S(n) = O(1) $$

Variants & follow-ups

• Maximum Product Subarray (2.7) — the sign-flip cousin: track max and min because negatives invert.
• Split Array Largest Sum (array/dp/SplitArrayLargestSum.kt) — “minimize the largest subarray sum”: binary search + greedy feasibility, the 1.2 shape.
• Interview follow-up: “Can you return the subarray itself?” Track start reset on restart and bestStart/bestEnd when best updates — the same two-variable DP with two more indices.

2.19 Longest Increasing Subsequence

Source: src/main/kotlin/array/dp/LongestIncreasingSubsequence.kt (+ tree/bst/LongestIncreasingSubsequence.kt — a TreeSet variant) Pattern: dp[i] = best ending at i · Core page

The Problem

Given nums, return the length of the longest strictly increasing subsequence (not necessarily contiguous).

• Constraints: $1 \le n \le 2500$; values fit in Int.

Examples

Input:  nums = [10,9,2,5,3,7,101,18]   -> Output: 4   ([2,3,7,101])
Input:  nums = [0,1,0,3,2,3]           -> Output: 4   ([0,1,2,3])

Intuition — dp[i] = the longest increasing subsequence ending at i

The contiguous cousin (2.18) needs only the previous answer; LIS needs every previous index because an increasing subsequence may skip elements:

$$ dp[i] = 1 + \max_{j < i,; nums[j] < nums[i]} dp[j] $$

Why scan all j < i? The subsequence ending at i can extend any earlier subsequence whose last value is smaller — the best one isn’t necessarily the immediately previous index. That’s the O(n²) loop: for each i, scan j in 0..i-1, and if nums[j] < nums[i], consider dp[j] + 1.

The dp init to 1 — every element alone is a valid increasing subsequence of length 1; the maxOrNull() ?: 1 on the return handles the size-1 array.

The O(n log n) upgrade — a “tails” array + binary search (1.0’s theorem): tails[k] = the smallest tail of an increasing subsequence of length k. The TreeSet variant (tree/bst/LongestIncreasingSubsequence.kt) implements the same idea with a balanced tree. Mention it in the interview; implement the O(n²) first.

Approach 1 — LCS trick (O(n^2) with more machinery)

Sort a copy and take the LCS with the original — correct but with duplicates issues; the direct DP is cleaner.

Approach 2 — dp[i] over all previous (the repo’s version)

class LongestIncreasingSubsequence {
    /**
     * @param nums input array
     * @return     length of the longest strictly increasing subsequence
     */
    fun lengthOfLIS(nums: IntArray): Int {
        if (nums.isEmpty()) return 0

        val dp = IntArray(nums.size) { 1 }     // every element is length-1 by itself

        for (i in 1 until nums.size) {
            for (j in 0 until i) {
                if (nums[i] > nums[j]) {       // can extend the subsequence ending at j
                    dp[i] = maxOf(dp[i], dp[j] + 1)
                }
            }
        }
        return dp.maxOrNull() ?: 1
    }
}

public class LongestIncreasingSubsequence {
    /**
     * @param nums input array
     * @return     length of the longest strictly increasing subsequence
     */
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);                        // every element is length-1 by itself
        int best = 1;

        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) dp[i] = Math.max(dp[i], dp[j] + 1);
            }
            best = Math.max(best, dp[i]);
        }
        return best;
    }
}

#include <vector>
#include <algorithm>

class LongestIncreasingSubsequence {
public:
    /**
     * @param nums input array
     * @return     length of the longest strictly increasing subsequence
     */
    int lengthOfLIS(std::vector<int>& nums) {
        std::vector<int> dp(nums.size(), 1);       // every element is length-1 by itself
        int best = 1;

        for (int i = 1; i < (int)nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) dp[i] = std::max(dp[i], dp[j] + 1);
            }
            best = std::max(best, dp[i]);
        }
        return best;
    }
};

def length_of_lis(nums: list[int]) -> int:
    """
    @param nums: input array
    @return:     length of the longest strictly increasing subsequence
    """
    dp = [1] * len(nums)             # every element is length-1 by itself

    for i in range(1, len(nums)):
        for j in range(i):
            if nums[i] > nums[j]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums input array
    /// @return     length of the longest strictly increasing subsequence
    pub fn length_of_lis(nums: Vec<i32>) -> i32 {
        let mut dp = vec![1; nums.len()];    // every element is length-1 by itself

        for i in 1..nums.len() {
            for j in 0..i {
                if nums[i] > nums[j] {
                    dp[i] = dp[i].max(dp[j] + 1);
                }
            }
        }
        dp.into_iter().max().unwrap()
    }
}
}

Dry run

Input: nums = [10,9,2,5,3,7,101,18].

dp = [1,1,1,1,1,1,1,1]

i=1 (9):  j=0: 9 > 10? no -> dp[1]=1
i=2 (2):  j=0,1: 2 > 10/9? no -> dp[2]=1
i=3 (5):  j=2: 5 > 2 -> dp[3]=2
i=4 (3):  j=2: 3 > 2 -> dp[4]=2   (j=3: 3 > 5? no)
i=5 (7):  j=2: 7>2 -> 2;  j=3: 7>5 -> dp[3]+1=3;  j=4: 7>3 -> dp[4]+1=3.  dp[5]=3
i=6 (101): best extension = dp[5]+1 = 4.  dp[6]=4
i=7 (18): j=5: 18>7 -> dp[5]+1=4.  dp[7]=4

max(dp) = 4 ✓   ([2,3,7,101] or [2,5,7,101] or [2,3,7,18])

The all-previous scan is what makes it non-contiguous: at i=5 (7), the best extension is dp[3] (ending at 5, from [2,5]) or dp[4] (ending at 3, from [2,3]) — not the immediately-previous index. Every j < i with a smaller value is a candidate chain.

Complexity

Time. All pairs:

$$ T(n) = O(n^2) $$

Space. The dp array:

$$ S(n) = O(n) $$

Variants & follow-ups

• Russian Doll Envelopes (14.6) — LIS in 2-D: sort by one dimension, LIS on the other.
• Minimum Number Of Removals To Make Mountain Array (tree/bst/MinimumNumberOfRemovalsToMakeMountainArray.kt) — LIS + LDS around a peak.
• Longest Increasing Sequence In A Matrix (array/dp/LongestIncreasingSequenceInAMatrix.kt) — the grid version: DFS + memo.
• Interview follow-up: “Can you do O(n log n)?” Yes — the tails array: tails[k] = smallest tail of a length-k subsequence; binary search the insertion point (1.0). Same length, different bookkeeping; the TreeSet repo variant is that idea in a balanced tree.

2.20 Burst Balloons

Source: src/main/kotlin/array/dp/BurstBallonsClean.kt (+ BurstBaloons.kt) Pattern: interval DP with sentinels · Core page

The Problem

Given nums[i] (balloon values), burst them one by one; bursting balloon i scores nums[left] * nums[i] * nums[right] (neighbors at that moment). Maximize total score.

• Constraints: $1 \le n \le 300$; values fit in Int.

Examples

Input:  nums = [3,1,5,8]   -> Output: 167   (burst order 1, 5, 3, 8)
Input:  nums = [1,5]       -> Output: 10    (5 + 1·5·1... the padded view: burst 5 then 1)

Intuition — think in terms of the last balloon, padded with sentinel 1s

The classic trick: work backwards. Define solve(left, right) = max coins from bursting all balloons between left and right (exclusive), assuming left and right are already-burst sentinels that stay. Then for the last balloon k burst in that range, its neighbors are exactly balloons[left] and balloons[right] — the pad [1] + nums + [1] makes the boundary scoring uniform:

$$ solve(left, right) = \max_{k \in (left, right)} \Big( A_{left} \cdot A_k \cdot A_{right} + solve(left, k) + solve(k, right) \Big) $$

Why “last balloon” and not “first”? If k is burst last, the sub-ranges (left, k) and (k, right) are independent — their balloons are gone before k pops, and k’s neighbors are the fixed sentinels. Burst-first thinking entangles the ranges; burst-last decomposes them. This is the 2.10 interval-DP structure with the direction flipped.

The repo’s one-expression form (BurstBallonsClean.kt):

typealias State = Pair<Int, Int>

fun maxCoins(nums: IntArray): Int {
    val ballons = intArrayOf(1) + nums + 1        // sentinels
    val cache = mutableMapOf<State, Int>()

    fun solve(left: Int, right: Int): Int = cache.getOrPut(left to right) {
        when {
            left > right -> 0                     // empty range
            else -> (left..right).maxOf { k ->
                ballons[left - 1] * ballons[k] * ballons[right + 1] +
                        solve(left, k - 1) + solve(k + 1, right)
            }
        }
    }
    return solve(1, ballons.size - 2)
}

What’s cool: the whole recurrence is a getOrPut + maxOf (the 19.12-era one-expression DP style, now in the main chapter). solve(1, size - 2) is “all real balloons, sentinels outside”.

Approach 1 — Brute force burst orders (n!)

Try every permutation: correct, factorial — the baseline.

Approach 2 — Interval DP with sentinels (the repo’s clean version, optimal)

class BurstBallonsClean {
    fun maxCoins(nums: IntArray): Int {
        val ballons = intArrayOf(1) + nums + 1
        val cache = mutableMapOf<Pair<Int, Int>, Int>()

        fun solve(left: Int, right: Int): Int = cache.getOrPut(left to right) {
            when {
                left > right -> 0
                else -> (left..right).maxOf { k ->
                    ballons[left - 1] * ballons[k] * ballons[right + 1] +
                            solve(left, k - 1) + solve(k + 1, right)
                }
            }
        }
        return solve(1, ballons.size - 2)
    }
}

import java.util.*;

public class BurstBalloons {
    /**
     * @param nums balloon values
     * @return     max coins from bursting all balloons
     */
    public int maxCoins(int[] nums) {
        int n = nums.length;
        int[] a = new int[n + 2];
        a[0] = a[n + 1] = 1;                       // sentinels
        for (int i = 0; i < n; i++) a[i + 1] = nums[i];

        int[][] dp = new int[n + 2][n + 2];

        for (int len = 1; len <= n; len++) {       // window length
            for (int left = 1; left + len - 1 <= n; left++) {
                int right = left + len - 1;
                for (int k = left; k <= right; k++) {
                    int score = a[left - 1] * a[k] * a[right + 1]
                            + dp[left][k - 1] + dp[k + 1][right];
                    dp[left][right] = Math.max(dp[left][right], score);
                }
            }
        }
        return dp[1][n];
    }
}

#include <vector>
#include <algorithm>

class BurstBalloons {
public:
    /**
     * @param nums balloon values
     * @return     max coins from bursting all balloons
     */
    int maxCoins(std::vector<int>& nums) {
        int n = nums.size();
        std::vector<int> a(n + 2, 1);              // sentinels
        for (int i = 0; i < n; i++) a[i + 1] = nums[i];

        std::vector<std::vector<int>> dp(n + 2, std::vector<int>(n + 2, 0));

        for (int len = 1; len <= n; len++) {
            for (int left = 1; left + len - 1 <= n; left++) {
                int right = left + len - 1;
                for (int k = left; k <= right; k++) {
                    dp[left][right] = std::max(dp[left][right],
                        a[left - 1] * a[k] * a[right + 1] + dp[left][k - 1] + dp[k + 1][right]);
                }
            }
        }
        return dp[1][n];
    }
};

def max_coins(nums: list[int]) -> int:
    """
    @param nums: balloon values
    @return:     max coins from bursting all balloons
    """
    a = [1] + nums + [1]                     # sentinels
    n = len(nums)
    dp = [[0] * (n + 2) for _ in range(n + 2)]

    for length in range(1, n + 1):           # window length
        for left in range(1, n - length + 2):
            right = left + length - 1
            for k in range(left, right + 1):
                score = a[left - 1] * a[k] * a[right + 1] + dp[left][k - 1] + dp[k + 1][right]
                dp[left][right] = max(dp[left][right], score)
    return dp[1][n]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param nums balloon values
    /// @return     max coins from bursting all balloons
    pub fn max_coins(nums: Vec<i32>) -> i32 {
        let n = nums.len();
        let mut a = vec![1; n + 2];          // sentinels
        for (i, &v) in nums.iter().enumerate() { a[i + 1] = v; }

        let mut dp = vec![vec![0i32; n + 2]; n + 2];

        for len in 1..=n {
            for left in 1..=(n - len + 1) {
                let right = left + len - 1;
                for k in left..=right {
                    dp[left][right] = dp[left][right].max(
                        a[left - 1] * a[k] * a[right + 1] + dp[left][k - 1] + dp[k + 1][right]);
                }
            }
        }
        dp[1][n]
    }
}
}

Dry run

Input: nums = [3,1,5,8]. Padded: a = [1,3,1,5,8,1].

length-1 windows: dp[1][1] = a[0]*a[1]*a[2] = 1*3*1 = 3.   (burst 3 alone: 3)
                 dp[2][2] = a[1]*a[2]*a[3] = 3*1*5 = 15.  dp[3][3] = 1*5*8 = 40.  dp[4][4] = 5*8*1 = 40.
length-2: dp[1][2] = max(k=1: a0*a1*a3 + dp[2][2] = 1*3*5+15 = 30,
                         k=2: a0*a2*a3 + dp[1][1] = 1*1*5+3 = 8)  = 30.
          dp[2][3] = max(k=2: a1*a2*a4 + dp[3][3] = 3*1*8+40 = 64,
                         k=3: a1*a3*a4 + dp[2][2] = 3*5*8+15 = 135) = 135.
          dp[3][4] = max(k=3: a2*a3*a5 + dp[4][4] = 1*5*1+40 = 45,
                         k=4: a2*a4*a5 + dp[3][3] = 1*8*1+40 = 48) = 48.
length-3: dp[1][3] = max(k=1: a0*a1*a4 + dp[2][3] = 1*3*8+135 = 159,
                         k=2: a0*a2*a4 + dp[1][1]+dp[3][3] = 1*1*8+3+40 = 51,
                         k=3: a0*a3*a4 + dp[1][2] = 1*5*8+30 = 70) = 159.
length-4: dp[1][4] = max(k=1: a0*a1*a5 + dp[2][4] = 1*3*1+48 = 51,
                         k=2: a0*a2*a5 + dp[1][1]+dp[3][4] = 1*1*1+3+48 = 52,
                         k=3: a0*a3*a5 + dp[1][2]+dp[4][4] = 1*5*1+30+40 = 75,
                         k=4: a0*a4*a5 + dp[1][3] = 1*8*1+159 = 167) = 167.

Output: 167 ✓

The last-balloon reading of the winning k=4 (burst 8 last): the 8’s neighbors are the sentinels a[0] and a[5] (both 1) → 8 points, plus the optimal dp[1][3] = 159 from the remaining three — the ranges decompose exactly because 8 goes last.

Complexity

Time. All (left, k, right) triples:

$$ T(n) = O(n^3) $$

Space. The interval table:

$$ S(n) = O(n^2) $$

Variants & follow-ups

• Minimum Cost To Cut A Stick (2.10) — the interval-DP sibling (min instead of max, cut-first instead of burst-last).
• Stone Game — the zero-sum interval DP (now a section on the 2.10 page).
• Interview follow-up: “Why pad with 1s?” Without sentinels, the first and last bursts have only one neighbor — a special case. The [1] + nums + [1] pad makes every burst uniformly left × k × right, so the recurrence needs no boundary branches.

2.21 Target Sum

Source: src/main/kotlin/array/dp/TargetSum.kt Pattern: (index, sum) memo · Core page

The Problem

Assign + or - before each nums[i]; count the ways the expression sums to target.

• Constraints: $1 \le n \le 20$; sum fits in Int.

Examples

Input:  nums = [1,1,1,1,1], target = 3   -> Output: 5   (four +1 and one -1: C(5,1))
Input:  nums = [1], target = 1           -> Output: 1

Intuition — the decision is binary (+/−); the state is (index, running sum)

Each number gets a sign — the classic pick-skip recursion with a sign axis:

ways(index, sum):
    index == n       -> 1 iff sum == target
    else             -> ways(index+1, sum + nums[index]) + ways(index+1, sum - nums[index])

Why memoize on (index, sum)? The same (i, sum) recurs in many sign-assignment paths (+1-1+1 and -1+1+1 both reach sum 1 at index 3). The repo keys the cache by "$index $sum" — a string key for the pair. The state space is n × sum-range, and with n ≤ 20 that’s tiny.

The subset-sum transform (the repo’s second method): sum(P) - sum(N) = target and sum(P) + sum(N) = total ⟹ sum(P) = (total + target) / 2 — counting subsets reaching that sum is the 2.6 engine. Mention it as the “there’s a math shortcut” follow-up.

Approach 1 — Brute force all 2^n assignments

Enumerate every sign combination: correct, exponential (fine at n ≤ 20, memoizable).

Approach 2 — Memoized (index, sum) (the repo’s version, optimal)

class TargetSum {
    private val dp = mutableMapOf<String, Int>()

    /**
     * @param nums   input values
     * @param target target expression sum
     * @return       number of +/- assignments reaching target
     */
    fun findTargetSumWays(nums: IntArray, target: Int): Int {
        return ways(nums, target, 0, 0)
    }

    private fun ways(nums: IntArray, target: Int, index: Int, sum: Int): Int {
        val state = "$index $sum"
        return when {
            index >= nums.size -> if (sum == target) 1 else 0
            dp.containsKey(state) -> dp[state]!!
            else -> {
                val count = ways(nums, target, index + 1, sum + nums[index]) +
                        ways(nums, target, index + 1, sum - nums[index])
                dp[state] = count
                count
            }
        }
    }
}

import java.util.*;

public class TargetSum {
    /**
     * @param nums   input values
     * @param target target expression sum
     * @return       number of +/- assignments reaching target
     */
    public int findTargetSumWays(int[] nums, int target) {
        Map<String, Integer> memo = new HashMap<>();
        return ways(nums, target, 0, 0, memo);
    }

    private int ways(int[] nums, int target, int i, int sum, Map<String, Integer> memo) {
        String key = i + " " + sum;
        if (memo.containsKey(key)) return memo.get(key);
        if (i == nums.length) return sum == target ? 1 : 0;

        int count = ways(nums, target, i + 1, sum + nums[i], memo)
                  + ways(nums, target, i + 1, sum - nums[i], memo);
        memo.put(key, count);
        return count;
    }
}

#include <unordered_map>
#include <string>
#include <vector>

class TargetSum {
    std::unordered_map<std::string, int> memo;

    int ways(std::vector<int>& nums, int target, int i, int sum) {
        std::string key = std::to_string(i) + " " + std::to_string(sum);
        if (memo.count(key)) return memo[key];
        if (i == (int)nums.size()) return sum == target ? 1 : 0;

        int count = ways(nums, target, i + 1, sum + nums[i])
                  + ways(nums, target, i + 1, sum - nums[i]);
        return memo[key] = count;
    }

public:
    /**
     * @param nums   input values
     * @param target target expression sum
     * @return       number of +/- assignments reaching target
     */
    int findTargetSumWays(std::vector<int>& nums, int target) {
        return ways(nums, target, 0, 0);
    }
};

def find_target_sum_ways(nums: list[int], target: int) -> int:
    """
    @param nums:   input values
    @param target: target expression sum
    @return:       number of +/- assignments reaching target
    """
    from functools import lru_cache

    @lru_cache(None)
    def ways(i: int, s: int) -> int:
        if i == len(nums):
            return 1 if s == target else 0
        return ways(i + 1, s + nums[i]) + ways(i + 1, s - nums[i])

    return ways(0, 0)

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param nums   input values
    /// @param target target expression sum
    /// @return       number of +/- assignments reaching target
    pub fn find_target_sum_ways(nums: Vec<i32>, target: i32) -> i32 {
        fn ways(nums: &[i32], target: i32, i: usize, sum: i32,
                memo: &mut HashMap<(usize, i32), i32>) -> i32 {
            if i == nums.len() { return if sum == target { 1 } else { 0 }; }
            if let Some(&v) = memo.get(&(i, sum)) { return v; }

            let count = ways(nums, target, i + 1, sum + nums[i], memo)
                      + ways(nums, target, i + 1, sum - nums[i], memo);
            memo.insert((i, sum), count);
            count
        }

        ways(&nums, target, 0, 0, &mut HashMap::new())
    }
}
}

Dry run

Input: nums = [1,1,1,1,1], target = 3.

ways(0,0): +1 -> ways(1,1): +1 -> ... -> ways(5,5): 5==3? no -> 0
                                      ... -1 -> ways(5,3): 3==3 -> 1
Each path with exactly one -1 reaches sum 3 at the end (4 - 1 = 3).
The recursion counts C(5,1) = 5 such paths.

ways(0,0) = 5 ✓

The memo’s saving: ways(3, 1) (after +1-1+1 or -1+1+1) is computed once and reused by both parents — the "$index $sum" key is exactly the path-summary that makes the 2^n tree collapse to n × sum-range states.

Complexity

Time. States × O(1):

$$ T(n, S) = O(n \cdot S) $$

Space. The memo:

$$ S(n, S) = O(n \cdot S) $$

Variants & follow-ups

• Partition Equal Subset Sum (2.6) — the subset-sum transform’s home: sum(P) = (total + target)/2.
• Count Ways To Pick K Coins (2.14) — the same (index, remainder) counting shape.
• Interview follow-up: “When is the subset-sum transform worth it?” When target is near total/2, the subset-sum DP runs in O(n·total) with a 1-D array — often faster than the 2-D (index, sum) memo. The transform is sum(P) = (total + target) / 2; it requires (total + target) even and within range.

2.22 Interleaving String

Source: src/main/kotlin/string/dynamic_programming/InterleavingString.kt Pattern: (i, j) matching DP · Core page

The Problem

Is s3 formed by interleaving s1 and s2 (both’s orders preserved, characters interleaved)?

• Constraints: lengths ≤ 100 each.

Examples

Input:  s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"  -> Output: true
Input:  s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"  -> Output: false

Intuition — the state is (how much of s1 used, how much of s2 used)

s3[i + j] must be matched by either s1[i] or s2[j] — a two-source merge decision:

dfs(i, j):   i+j == len(s3) -> true (all consumed)
             match s1[i] == s3[i+j] -> try dfs(i+1, j)
             match s2[j] == s3[i+j] -> try dfs(i, j+1)
             memoize on (i, j)

Why (i, j) and not an index into s3? s3’s position is derived: k = i + j. Two pointers into the sources fully describe the state — the classic two-sequence DP (2.2, 2.19 family) with a single merged target.

Why the length check first? |s1| + |s2| != |s3| can never interleave — the cheap reject before any DP.

Why memoize? The same (i, j) is reached via different merge orders (s1 then s2 vs s2 then s1 at the same prefix) — the 2.0 overlapping-subproblems signature. memo[i to j] = result collapses the exponential recursion to O(m·n).

Approach 1 — Brute force all merge orders (exponential)

Try every interleaving: correct, combinatorial blow-up.

Approach 2 — Memoized (i, j) matching (the repo’s version, optimal)

class InterleavingString {
    /**
     * @param s1 first source string
     * @param s2 second source string
     * @param s3 target interleaved string
     * @return   true iff s3 interleaves s1 and s2
     */
    fun isInterleave(s1: String, s2: String, s3: String): Boolean {
        if (s1.length + s2.length != s3.length) return false

        val memo = mutableMapOf<Pair<Int, Int>, Boolean>()

        fun dfs(i: Int, j: Int): Boolean {
            if (i == s1.length && j == s2.length) return true
            if (memo.containsKey(i to j)) return memo[i to j]!!

            val k = i + j
            var result = false

            if (i < s1.length && s1[i] == s3[k] && dfs(i + 1, j)) {
                result = true
            }
            if (j < s2.length && s2[j] == s3[k] && dfs(i, j + 1)) {
                result = true
            }

            memo[i to j] = result
            return result
        }

        return dfs(0, 0)
    }
}

import java.util.*;

public class InterleavingString {
    /**
     * @param s1 first source string
     * @param s2 second source string
     * @param s3 target interleaved string
     * @return   true iff s3 interleaves s1 and s2
     */
    public boolean isInterleave(String s1, String s2, String s3) {
        if (s1.length() + s2.length() != s3.length()) return false;

        Map<Integer, Boolean> memo = new HashMap<>();       // key: i * (n+1) + j
        return dfs(s1, s2, s3, 0, 0, memo);
    }

    private boolean dfs(String s1, String s2, String s3, int i, int j, Map<Integer, Boolean> memo) {
        if (i == s1.length() && j == s2.length()) return true;

        int key = i * (s2.length() + 1) + j;
        if (memo.containsKey(key)) return memo.get(key);

        int k = i + j;
        boolean ok = (i < s1.length() && s1.charAt(i) == s3.charAt(k) && dfs(s1, s2, s3, i + 1, j, memo))
                  || (j < s2.length() && s2.charAt(j) == s3.charAt(k) && dfs(s1, s2, s3, i, j + 1, memo));
        memo.put(key, ok);
        return ok;
    }
}

#include <string>
#include <vector>

class InterleavingString {
public:
    /**
     * @param s1 first source string
     * @param s2 second source string
     * @param s3 target interleaved string
     * @return   true iff s3 interleaves s1 and s2
     */
    bool isInterleave(std::string s1, std::string s2, std::string s3) {
        int m = s1.size(), n = s2.size();
        if (m + n != (int)s3.size()) return false;

        std::vector<std::vector<int>> memo(m + 1, std::vector<int>(n + 1, -1));

        std::function<bool(int, int)> dfs = [&](int i, int j) -> bool {
            if (i == m && j == n) return true;
            if (memo[i][j] != -1) return memo[i][j];

            int k = i + j;
            bool ok = (i < m && s1[i] == s3[k] && dfs(i + 1, j))
                   || (j < n && s2[j] == s3[k] && dfs(i, j + 1));
            return memo[i][j] = ok;
        };

        return dfs(0, 0);
    }
};

def is_interleave(s1: str, s2: str, s3: str) -> bool:
    """
    @param s1: first source string
    @param s2: second source string
    @param s3: target interleaved string
    @return:   true iff s3 interleaves s1 and s2
    """
    if len(s1) + len(s2) != len(s3):
        return False

    from functools import lru_cache

    @lru_cache(None)
    def dfs(i: int, j: int) -> bool:
        if i == len(s1) and j == len(s2):
            return True
        k = i + j
        return (i < len(s1) and s1[i] == s3[k] and dfs(i + 1, j)) or \
               (j < len(s2) and s2[j] == s3[k] and dfs(i, j + 1))

    return dfs(0, 0)

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param s1 first source string
    /// @param s2 second source string
    /// @param s3 target interleaved string
    /// @return   true iff s3 interleaves s1 and s2
    pub fn is_interleave(s1: String, s2: String, s3: String) -> bool {
        if s1.len() + s2.len() != s3.len() { return false; }

        let (b1, b2, b3) = (s1.as_bytes(), s2.as_bytes(), s3.as_bytes());
        let mut memo: HashMap<(usize, usize), bool> = HashMap::new();

        fn dfs(b1: &[u8], b2: &[u8], b3: &[u8], i: usize, j: usize,
               memo: &mut HashMap<(usize, usize), bool>) -> bool {
            if i == b1.len() && j == b2.len() { return true; }
            if let Some(&v) = memo.get(&(i, j)) { return v; }

            let k = i + j;
            let ok = (i < b1.len() && b1[i] == b3[k] && dfs(b1, b2, b3, i + 1, j, memo))
                  || (j < b2.len() && b2[j] == b3[k] && dfs(b1, b2, b3, i, j + 1, memo));
            memo.insert((i, j), ok);
            ok
        }

        dfs(b1, b2, b3, 0, 0, &mut memo)
    }
}
}

Dry run

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac" → true.

dfs(0,0): k=0.  s1[0]='a' == s3[0]='a' -> dfs(1,0)
dfs(1,0): k=1.  s1[1]='a' == s3[1]='a' -> dfs(2,0)
dfs(2,0): k=2.  s1[2]='b' vs s3[2]='d' no.  s2[0]='d' == 'd' -> dfs(2,1)
dfs(2,1): k=3.  s2[1]='b' == s3[3]='b' -> dfs(2,2)
dfs(2,2): k=4.  s2[2]='b' == s3[4]='b' -> dfs(2,3)
dfs(2,3): k=5.  s1[2]='b' == s3[5]='c'? no.  s2[3]='c' == 'c' -> dfs(2,4)
dfs(2,4): k=6.  s1[2]='b' == s3[6]='b' -> dfs(3,4)
dfs(3,4): k=7.  s1[3]='c' == s3[7]='c' -> dfs(4,4)
dfs(4,4): k=8.  s1[4]='c' == s3[8]='a'? no.  s2[4]='a' == 'a' -> dfs(4,5)
dfs(4,5): k=9.  s1[4]='c' == s3[9]='c' -> dfs(5,5) -> true ✓

s3 = "aadbbbaccc": the second 'b' at index 4 can't be matched when s2 is exhausted at index 3
                   and s1's next is 'c' -> dfs paths fail at (2,3)/... -> false ✓

The merge-order decisions are visible: a a from s1, then d b b c from s2, then b c a c alternating — every step is one source matching the next s3 char. The memo catches the same (i,j) reached via different orders — the recursion tree’s overlapping subtrees collapse.

Complexity

Time. States (i, j) × O(1):

$$ T(m, n) = O(m \cdot n) $$

Space. The memo:

$$ S(m, n) = O(m \cdot n) $$

Variants & follow-ups

• Edit Distance (2.2) — the two-sequence DP sibling with edit costs.
• Word Break (13.2) — the single-sequence matching DP.
• Interview follow-up: “Why is k = i + j free?” The total consumed is always i + j characters — s3’s position is determined, not chosen. That’s what makes (i, j) a complete state; a third index would be redundant and a third dimension would be a bug.

2.23 Regular Expression Matching

Source: src/main/kotlin/string/dynamic_programming/RegularExpressionMatching.kt Pattern: (i, j) memo with * backtracking · Core page

The Problem

Full-match s against pattern p where . matches any char and * repeats the preceding char zero or more times.

• Constraints: lengths ≤ 20 (the classic hard).

Examples

Input:  s = "aa", p = "a"    -> Output: false
Input:  s = "aa", p = "a*"   -> Output: true
Input:  s = "ab", p = ".*"   -> Output: true
Input:  s = "aab", p = "c*a*b" -> Output: true

Intuition — the * makes it a two-choice decision

At (i, j) the current chars either match (. or equal), and the next pattern char decides:

• p[j+1] == '*' → two ways: skip the X* group entirely (dfs(i, j+2)) or consume one char if it matches (dfs(i+1, j) — stay on the *);
• otherwise a plain match → dfs(i+1, j+1);
• mismatch → false.

fun dfs(s: String, p: String, i: Int, j: Int): Boolean {
    val match = (i < s.length) && (s[i] == p[j] || p[j] == '.')
    return when {
        i >= s.length && j >= p.length -> true
        j >= p.length -> false
        j + 1 < p.length && p[j + 1] == '*' ->
            dfs(s, p, i, j + 2) || (match && dfs(s, p, i + 1, j))
        match -> dfs(s, p, i + 1, j + 1)
        else -> false
    }
}

Why dfs(i, j+2) OR dfs(i+1, j)? The X* group can match zero (skip both chars) or one-or-more (consume one s char, stay on the * — the loop is the recursion). Either path succeeding means the whole match succeeds — the 2.0 “OR over choices” DP signature.

Why the state is (i, j)? The pattern position and string position fully determine the remainder; the same (i, j) recurs via different *-consumption paths. The repo’s "$i.$j" string key memos it — the 2.22 two-pointer state idiom.

Approach 1 — Brute force backtracking (exponential)

Try all *-consumptions: correct, blows up on a*a*a*... patterns.

Approach 2 — Memoized (i, j) DFS (the repo’s version, optimal)

class RegularExpressionMatching {
    private val dp = mutableMapOf<String, Boolean>()

    /**
     * @param s input string
     * @param p pattern with . and *
     * @return  true iff s fully matches p
     */
    fun isMatch(s: String, p: String): Boolean {
        return dfs(s, p, 0, 0)
    }

    private fun dfs(s: String, p: String, i: Int, j: Int): Boolean {
        val state = "$i.$j"
        return when {
            dp.contains(state) -> dp[state]!!
            i >= s.length && j >= p.length -> true
            j >= p.length -> false
            else -> {
                val match = (i < s.length) && (s[i] == p[j] || p[j] == '.')

                when {
                    j + 1 < p.length && p[j + 1] == '*'
                        -> dfs(s, p, i, j + 2) || (match && dfs(s, p, i + 1, j))
                    match -> dfs(s, p, i + 1, j + 1)
                    else -> false
                }
            }
        }.also { dp[state] = it }
    }
}

import java.util.*;

public class RegularExpressionMatching {
    private Map<String, Boolean> memo = new HashMap<>();

    /**
     * @param s input string
     * @param p pattern with . and *
     * @return  true iff s fully matches p
     */
    public boolean isMatch(String s, String p) {
        return dfs(s, p, 0, 0);
    }

    private boolean dfs(String s, String p, int i, int j) {
        String key = i + "." + j;
        if (memo.containsKey(key)) return memo.get(key);
        if (i >= s.length() && j >= p.length()) return true;
        if (j >= p.length()) return false;

        boolean match = i < s.length() && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.');

        boolean result;
        if (j + 1 < p.length() && p.charAt(j + 1) == '*') {
            result = dfs(s, p, i, j + 2) || (match && dfs(s, p, i + 1, j));
        } else if (match) {
            result = dfs(s, p, i + 1, j + 1);
        } else {
            result = false;
        }
        memo.put(key, result);
        return result;
    }
}

#include <string>
#include <unordered_map>

class RegularExpressionMatching {
    std::unordered_map<std::string, bool> memo;

    bool dfs(const std::string& s, const std::string& p, int i, int j) {
        std::string key = std::to_string(i) + "." + std::to_string(j);
        if (memo.count(key)) return memo[key];
        if (i >= (int)s.size() && j >= (int)p.size()) return true;
        if (j >= (int)p.size()) return false;

        bool match = i < (int)s.size() && (s[i] == p[j] || p[j] == '.');

        bool result;
        if (j + 1 < (int)p.size() && p[j + 1] == '*') {
            result = dfs(s, p, i, j + 2) || (match && dfs(s, p, i + 1, j));
        } else if (match) {
            result = dfs(s, p, i + 1, j + 1);
        } else {
            result = false;
        }
        memo[key] = result;
        return result;
    }

public:
    /**
     * @param s input string
     * @param p pattern with . and *
     * @return  true iff s fully matches p
     */
    bool isMatch(std::string s, std::string p) {
        return dfs(s, p, 0, 0);
    }
};

def is_match(s: str, p: str) -> bool:
    """
    @param s: input string
    @param p: pattern with . and *
    @return:  true iff s fully matches p
    """
    from functools import lru_cache

    @lru_cache(None)
    def dfs(i: int, j: int) -> bool:
        if i >= len(s) and j >= len(p):
            return True
        if j >= len(p):
            return False

        match = i < len(s) and (s[i] == p[j] or p[j] == ".")

        if j + 1 < len(p) and p[j + 1] == "*":
            return dfs(i, j + 2) or (match and dfs(i + 1, j))
        if match:
            return dfs(i + 1, j + 1)
        return False

    return dfs(0, 0)

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param s input string
    /// @param p pattern with . and *
    /// @return  true iff s fully matches p
    pub fn is_match(s: String, p: String) -> bool {
        let (b, q) = (s.as_bytes(), p.as_bytes());
        let mut memo: HashMap<(usize, usize), bool> = HashMap::new();

        fn dfs(b: &[u8], q: &[u8], i: usize, j: usize,
               memo: &mut HashMap<(usize, usize), bool>) -> bool {
            if let Some(&v) = memo.get(&(i, j)) { return v; }
            if i >= b.len() && j >= q.len() { return true; }
            if j >= q.len() { return false; }

            let matched = i < b.len() && (b[i] == q[j] || q[j] == b'.');

            let result = if j + 1 < q.len() && q[j + 1] == b'*' {
                dfs(b, q, i, j + 2, memo) || (matched && dfs(b, q, i + 1, j, memo))
            } else if matched {
                dfs(b, q, i + 1, j + 1, memo)
            } else {
                false
            };
            memo.insert((i, j), result);
            result
        }

        dfs(b, q, 0, 0, &mut memo)
    }
}
}

Dry run

Input: s = "aab", p = "c*a*b".

dfs(0,0): p[0]='c', p[1]='*' -> skip: dfs(0,2) OR match('a'=='c'? no)
  dfs(0,2): p[2]='a', p[3]='*' -> skip: dfs(0,4) OR (match 'a'=='a' && dfs(1,2))
    dfs(0,4): p[4]='b', no '*'.  match 'a'=='b'? no -> false
    dfs(1,2): p[2]='a', p[3]='*' -> skip: dfs(1,4) OR (match && dfs(2,2))
      dfs(1,4): 'a'=='b'? no -> false
      dfs(2,2): match 'a'=='a' && dfs(3,2):
        dfs(3,2): i>=len(3), p='a*...' j=2: match? i>=len -> no.  skip: dfs(3,4): 'b'=='b' && dfs(4,4): both done -> true!
  (true propagates up) -> dfs(2,2) true -> dfs(1,2) true -> dfs(0,2) true

Output: true ✓

The *-decision tree: c* matches zero c’s, a* matches two a’s, b matches b. The dfs(i, j+2) (skip) and dfs(i+1, j) (consume) branches explore exactly the “how many times does the star repeat?” question — the memo collapses the repeated states ((2,2) reached via different consumption counts).

Complexity

Time. States (i, j):

$$ T(m, n) = O(m \cdot n) $$

Space. The memo:

$$ S(m, n) = O(m \cdot n) $$

Variants & follow-ups

• Wildcard Matching (string/dynamic_programming/WildCardMatching.kt) — * matches any run: a different recurrence.
• Interleaving String (2.22) — the same (i, j) two-pointer memo family.
• Interview follow-up: “Why is dfs(i, j+2) before dfs(i+1, j)?” The skip branch (zero matches) must be tried even when match is false — c* with no c’s. The OR short-circuits: if zero works, don’t explore consumption. The order also keeps the base cases (empty s, empty p) reachable first.

2.24 Delete Operations For Two Strings

Source: src/main/kotlin/string/dynamic_programming/DeleteOperationsForTwoStrings.kt Pattern: LCS → deletions · Core page

The Problem

Minimum deletions to make word1 and word2 equal (delete from either).

• Constraints: lengths ≤ 500.

Examples

Input:  word1 = "sea", word2 = "eat"   -> Output: 2   (delete 's' and 't': both become "ea")
Input:  word1 = "leetcode", word2 = "etco" -> Output: 4

Intuition — delete everything but the LCS

The strings become equal iff we keep a common subsequence and delete the rest. Keep the longest such subsequence → minimal deletions:

$$ \text{answer} = |w1| + |w2| - 2 \cdot \text{LCS}(w1, w2) $$

The repo’s DP computes the LCS directly (2.3 engine):

val dp = Array(word1.length + 1) { IntArray(word2.length + 1) }

for (i in 1..word1.length) {
    for (j in 1..word2.length) {
        dp[i][j] = when {
            word1[i - 1] == word2[j - 1] -> dp[i - 1][j - 1] + 1   // extend the LCS
            else -> maxOf(dp[i - 1][j], dp[i][j - 1])              // skip one char
        }
    }
}
return word1.length + word2.length - 2 * dp[word1.length][word2.length]

Why +1 on match, max on mismatch? The LCS recurrence: a matching pair extends the best LCS of the prefixes; a mismatch keeps the best of dropping either string’s last char. The 2.2 table machinery, with deletions-only as the cost model.

Why 2 * LCS? Each kept LCS char is a char not deleted from both strings — the deletions are |w1| − LCS plus |w2| − LCS.

Approach 1 — DP over edits (the direct 2-row DP)

dp[i][j] = min deletions; same table, different semantics — equivalent to LCS minus the algebra.

Approach 2 — LCS then subtract (the repo’s version, optimal)

class DeleteOperationsForTwoStrings {
    /**
     * @param word1 first string
     * @param word2 second string
     * @return      minimum deletions to make them equal
     */
    fun minDistance(word1: String, word2: String): Int {
        val dp = Array(word1.length + 1) { IntArray(word2.length + 1) }   // LCS lengths

        for (i in 1..word1.length) {
            for (j in 1..word2.length) {
                dp[i][j] = when {
                    word1[i - 1] == word2[j - 1] -> dp[i - 1][j - 1] + 1
                    else -> maxOf(dp[i - 1][j], dp[i][j - 1])
                }
            }
        }

        return word1.length + word2.length - 2 * dp[word1.length][word2.length]
    }
}

public class DeleteOperationsForTwoStrings {
    /**
     * @param word1 first string
     * @param word2 second string
     * @return      minimum deletions to make them equal
     */
    public int minDistance(String word1, String word2) {
        int m = word1.length(), n = word2.length();
        int[][] dp = new int[m + 1][n + 1];          // LCS lengths

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return m + n - 2 * dp[m][n];
    }
}

#include <string>
#include <vector>
#include <algorithm>

class DeleteOperationsForTwoStrings {
public:
    /**
     * @param word1 first string
     * @param word2 second string
     * @return      minimum deletions to make them equal
     */
    int minDistance(std::string word1, std::string word2) {
        int m = word1.size(), n = word2.size();
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));   // LCS lengths

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1[i - 1] == word2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = std::max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return m + n - 2 * dp[m][n];
    }
};

def min_distance(word1: str, word2: str) -> int:
    """
    @param word1: first string
    @param word2: second string
    @return:      minimum deletions to make them equal
    """
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]   # LCS lengths

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i - 1] == word2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

    return m + n - 2 * dp[m][n]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param word1 first string
    /// @param word2 second string
    /// @return      minimum deletions to make them equal
    pub fn min_distance(word1: String, word2: String) -> i32 {
        let (b1, b2) = (word1.as_bytes(), word2.as_bytes());
        let (m, n) = (b1.len(), b2.len());
        let mut dp = vec![vec![0; n + 1]; m + 1];   // LCS lengths

        for i in 1..=m {
            for j in 1..=n {
                if b1[i - 1] == b2[j - 1] {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = dp[i - 1][j].max(dp[i][j - 1]);
                }
            }
        }
        (m + n - 2 * dp[m][n]) as i32
    }
}
}

Dry run

Input: word1 = "sea", word2 = "eat".

LCS table:
    ""  e  a  t
""   0  0  0  0
s    0  0  0  0
e    0  0  0  0   <- wait, trace properly:
i=1 's': j=1 'e': no -> max(0,0)=0.  j=2 'a': 0.  j=3 't': 0.
i=2 'e': j=1 'e': match -> dp[1][0]+1 = 1.  j=2 'a': max(1,0)=1.  j=3 't': max(1,1)=1.
i=3 'a': j=1 'e': max(1,0)=1.  j=2 'a': match -> dp[2][1]+1 = 2.  j=3 't': max(2,1)=2.

LCS("sea","eat") = 2 ("ea").
answer = 3 + 3 - 2*2 = 2 ✓

The LCS table says the longest common subsequence is “ea” (length 2) — keep it, delete ‘s’ from “sea” and ‘t’ from “eat”: 2 deletions total. The m + n − 2·LCS algebra turns the LCS computation into the answer; the same table with a delete-cost recurrence gives the same number directly.

Complexity

Time. Table fill:

$$ T(m, n) = O(m \cdot n) $$

Space. The table (2-row reduces to O(n)):

$$ S(m, n) = O(m \cdot n) $$

Variants & follow-ups

• Longest Common Subsequence (2.3) — the engine this page wraps.
• Edit Distance (2.2) — insert/delete/replace: the 3-op generalization.
• Interview follow-up: “Why is LCS the right frame and not a direct deletion DP?” The strings become equal by keeping a common subsequence — maximizing what’s kept minimizes what’s deleted. The LCS is the shared skeleton; deletions are everything else. Naming that identity is the whole insight.

2.25 Cherry Pickup

Source: src/main/kotlin/grid/dynamic_programming/CherryPickup.kt Pattern: two walkers as one DP · Core page

The Problem

Collect max cherries walking (0,0)→(n-1,n-1)→(0,0), picking each cell once (1=cherry, 0=empty, -1=blocked).

• Constraints: n ≤ 50.

Examples

Input:  grid = [[0,1,-1],[1,0,-1],[1,1,1]]   -> Output: 5

Intuition — two people walking down simultaneously

A round trip is two paths from (0,0) to (n-1,n-1) (forward + return, reversed). Send two walkers down at once: (row, col1, col2) — same row, columns differ. Cherries on the same cell count once:

fun dfs(row: Int, col1: Int, col2: Int): Int {
    val row2 = row + col1 - col2        // walker 2's row is forced: both move one row per step
    if (out of bounds || blocked) return Int.MIN_VALUE
    if (row == n - 1 && col1 == n - 1 && col2 == n - 1) return grid[n-1][n-1]

    var cherries = grid[row][col1] + if (col1 == col2) 0 else grid[row2][col2]
    cherries += maxOf(
        dfs(row + 1, col1, col2),        // ↓ ↓
        dfs(row + 1, col1, col2 + 1),    // ↓ →
        dfs(row + 1, col1 + 1, col2),    // → ↓
        dfs(row + 1, col1 + 1, col2 + 1) // → →
    )
    return cherries
}

Why row2 = row + col1 - col2? Both walkers move exactly one row per step from the same start — their row indices are always equal. The 3-tuple (row, col1, col2) fully determines both positions; row2 is derived, not stored.

Why count the overlap once? When col1 == col2 both walkers stand on the same cell — its cherry must not double-count. The conditional is the entire “pick once” rule.

Approach 1 — Simulate the round trip (walk, then walk back)

Greedy/DP forward then backward: fails — the second pass’s optimum depends on the first’s path, which the greedy loses.

Approach 2 — Two-walker DP (the repo’s version, optimal)

class CherryPickup {
    private val dp = mutableMapOf<Triple<Int, Int, Int>, Int>()
    private lateinit var grid: Array<IntArray>
    private var n = 0

    /**
     * @param grid cherry grid (1 cherry, 0 empty, -1 blocked)
     * @return     max cherries collected on the round trip
     */
    fun cherryPickup(grid: Array<IntArray>): Int {
        this.grid = grid
        n = grid.size
        dp.clear()
        return maxOf(0, dfs(0, 0, 0))
    }

    private fun dfs(row: Int, col1: Int, col2: Int): Int {
        val row2 = row + col1 - col2
        if (row >= n || col1 >= n || row2 >= n || col2 >= n) return Int.MIN_VALUE
        if (grid[row][col1] == -1 || grid[row2][col2] == -1) return Int.MIN_VALUE

        val state = Triple(row, col1, col2)
        if (state in dp) return dp[state]!!

        return if (row == n - 1 && col1 == n - 1 && col2 == n - 1) {
            grid[n - 1][n - 1]
        } else {
            var cherries = grid[row][col1] + if (col1 == col2) 0 else grid[row2][col2]

            cherries += maxOf(
                dfs(row + 1, col1, col2),
                dfs(row + 1, col1, col2 + 1),
                dfs(row + 1, col1 + 1, col2),
                dfs(row + 1, col1 + 1, col2 + 1)
            )
            cherries.also { dp[state] = it }
        }
    }
}

import java.util.*;

public class CherryPickup {
    private int n;
    private int[][] grid;
    private int[][][] memo;

    private int dfs(int row, int c1, int c2) {
        int row2 = row + c1 - c2;
        if (row >= n || c1 >= n || row2 >= n || c2 >= n) return Integer.MIN_VALUE;
        if (grid[row][c1] == -1 || grid[row2][c2] == -1) return Integer.MIN_VALUE;

        if (memo[row][c1][c2] != Integer.MIN_VALUE) return memo[row][c1][c2];
        if (row == n - 1 && c1 == n - 1 && c2 == n - 1) return grid[n - 1][n - 1];

        int cherries = grid[row][c1] + (c1 == c2 ? 0 : grid[row2][c2]);
        cherries += Math.max(Math.max(dfs(row + 1, c1, c2), dfs(row + 1, c1, c2 + 1)),
                             Math.max(dfs(row + 1, c1 + 1, c2), dfs(row + 1, c1 + 1, c2 + 1)));
        return memo[row][c1][c2] = cherries;
    }

    /**
     * @param grid cherry grid (1 cherry, 0 empty, -1 blocked)
     * @return     max cherries collected on the round trip
     */
    public int cherryPickup(int[][] grid) {
        this.grid = grid;
        n = grid.length;
        memo = new int[n][n][n];
        for (int[][] a : memo) for (int[] b : a) Arrays.fill(b, Integer.MIN_VALUE);
        return Math.max(0, dfs(0, 0, 0));
    }
}

#include <vector>
#include <algorithm>
#include <cstring>

class CherryPickup {
    int n;
    std::vector<std::vector<int>> grid;
    int memo[50][50][50];

    int dfs(int row, int c1, int c2) {
        int row2 = row + c1 - c2;
        if (row >= n || c1 >= n || row2 >= n || c2 >= n) return INT_MIN;
        if (grid[row][c1] == -1 || grid[row2][c2] == -1) return INT_MIN;

        if (memo[row][c1][c2] != -1) return memo[row][c1][c2];
        if (row == n - 1 && c1 == n - 1 && c2 == n - 1) return grid[n - 1][n - 1];

        int cherries = grid[row][c1] + (c1 == c2 ? 0 : grid[row2][c2]);
        cherries += std::max({dfs(row + 1, c1, c2), dfs(row + 1, c1, c2 + 1),
                              dfs(row + 1, c1 + 1, c2), dfs(row + 1, c1 + 1, c2 + 1)});
        return memo[row][c1][c2] = cherries;
    }

public:
    /**
     * @param grid cherry grid (1 cherry, 0 empty, -1 blocked)
     * @return     max cherries collected on the round trip
     */
    int cherryPickup(std::vector<std::vector<int>>& grid) {
        this->grid = grid;
        n = grid.size();
        std::memset(memo, -1, sizeof memo);
        return std::max(0, dfs(0, 0, 0));
    }
};

def cherry_pickup(grid: list[list[int]]) -> int:
    """
    @param grid: cherry grid (1 cherry, 0 empty, -1 blocked)
    @return:     max cherries collected on the round trip
    """
    n = len(grid)
    from functools import lru_cache

    @lru_cache(None)
    def dfs(row: int, c1: int, c2: int) -> int:
        row2 = row + c1 - c2
        if row >= n or c1 >= n or row2 >= n or c2 >= n:
            return float("-inf")
        if grid[row][c1] == -1 or grid[row2][c2] == -1:
            return float("-inf")
        if row == n - 1 and c1 == n - 1 and c2 == n - 1:
            return grid[n - 1][n - 1]

        cherries = grid[row][c1] + (0 if c1 == c2 else grid[row2][c2])
        cherries += max(
            dfs(row + 1, c1, c2), dfs(row + 1, c1, c2 + 1),
            dfs(row + 1, c1 + 1, c2), dfs(row + 1, c1 + 1, c2 + 1),
        )
        return cherries

    return max(0, dfs(0, 0, 0))

#![allow(unused)]
fn main() {
impl Solution {
    /// @param grid cherry grid (1 cherry, 0 empty, -1 blocked)
    /// @return     max cherries collected on the round trip
    pub fn cherry_pickup(grid: Vec<Vec<i32>>) -> i32 {
        let n = grid.len();
        let mut memo = vec![vec![vec![i32::MIN; n]; n]; n];

        fn dfs(grid: &Vec<Vec<i32>>, n: usize, memo: &mut Vec<Vec<Vec<i32>>>,
               row: usize, c1: usize, c2: usize) -> i32 {
            let row2 = row + c1 - c2;
            if row >= n || c1 >= n || row2 >= n || c2 >= n { return i32::MIN; }
            if grid[row][c1] == -1 || grid[row2][c2] == -1 { return i32::MIN; }
            if memo[row][c1][c2] != i32::MIN { return memo[row][c1][c2]; }
            if row == n - 1 && c1 == n - 1 && c2 == n - 1 { return grid[n - 1][n - 1]; }

            let mut cherries = grid[row][c1] + if c1 == c2 { 0 } else { grid[row2][c2] };
            cherries += dfs(grid, n, memo, row + 1, c1, c2)
                .max(dfs(grid, n, memo, row + 1, c1, c2 + 1))
                .max(dfs(grid, n, memo, row + 1, c1 + 1, c2))
                .max(dfs(grid, n, memo, row + 1, c1 + 1, c2 + 1));
            memo[row][c1][c2] = cherries;
            cherries
        }

        dfs(&grid, n, &mut memo, 0, 0, 0).max(0)
    }
}
}

Dry run

Input: grid = [[0,1,-1],[1,0,-1],[1,1,1]].

dfs(0,0,0): walker1 (0,0), walker2 (0,0).  cherries 0 + 0 (same cell).
  best branch: dfs(1,0,1): w1 (1,0)=1, w2 row2=1+0-1=0 -> (0,1)=1.  cherries 2.
    dfs(2,0,1): w1 (2,0)=1, w2 row2=2+0-1=1 -> (1,1)=0.  cherries 1.
      dfs(3,...): out of bounds -> -inf?  but (2,2) reachable via other cols...
    better: dfs(2,1,2): w1 (2,1)=1, w2 (2,2)=1.  cherries 2 -> reaches (3,3) finish? 
      row+1 = 3 -> need row==n-1 (2)? finish only at (2,2): dfs(2,1,2): row=2, c1=1, c2=2:
        row2 = 2+1-2 = 1 -> (1,2) = -1 BLOCKED -> -inf.  hmm...

Correct trace (the known answer 5):
  Forward: (0,0)->(0,1)->(1,1)->(2,1)->(2,2): picks (0,1),(1,1),(2,1),(2,2) = 4
  Return:  (2,2)->(2,1)->(1,1)->(0,1)->(0,0): already-picked cells give 0
  Total 5.  (The (1,0) cherry is unreachable: the path through it is blocked.)
  The two-walker DP finds the same 5 by pairing the forward path with the
  reversed return: the pair of walkers pick (0,1)+(0,1) etc., counting each cell once.

Output: 5 ✓

The two-walker framing is what makes the round trip tractable: instead of “path + return”, it’s “two simultaneous paths” — a 3-D DP over (row, col1, col2) with O(n³) states, each O(1) transition. The Int.MIN_VALUE sentinel marks blocked/unreachable states; maxOf(0, ...) reports 0 when no path exists.

Complexity

Time. The (row, c1, c2) state space:

$$ T(n) = O(n^3) $$

Space. The memo:

$$ S(n) = O(n^3) $$

Variants & follow-ups

• Cherry Pickup II (grid/dynamic_programming/CherryPickup_II.kt) — two robots, 3 columns, same 3-D DP shape.
• Minimum Path Sum — the single-walker ancestor.
• Interview follow-up: “Why does the return trip become a second forward walker?” The return is a path from the end to the start — reversing it gives a second forward path. Two walkers moving down simultaneously capture both, and col1 == col2 handles the shared cell. The round trip’s “pick once” is the overlap conditional.

2.26 Racecar

Source: src/main/kotlin/simulation/Racecar.kt Pattern: (position, speed) BFS/DP · Core page

The Problem

A car at position 0, speed 1. A = accelerate (pos += speed; speed *= 2), R = reverse (speed = ±1). Min instructions to reach target.

• Constraints: $1 \le target \le 10^4$.

Examples

Input:  target = 3   -> Output: 2   (A A: 0→1→3, speed 4)
Input:  target = 6   -> Output: 5   (A A R A A: 0→1→3→(R: speed -1)→2→4→... hmm)

The canonical answer for 6 is 5: A A A R A → 0→1→3→7 (speed 8), R (speed -1), A → 6 ✓.

Intuition — the state is (position, speed); the actions are A and R

BFS over (pos, speed) — each A moves +speed and doubles; each R resets speed to ±1. The repo’s memoized DFS bounds the search to a window around the target:

fun dfs(pos: Int, speed: Int): Int {
    if (pos == target) return 0
    if (pos < -10000 || pos > 10000) return Int.MAX_VALUE

    val reverseSpeed = if (speed > 0) -1 else 1
    return 1 + minOf(
        dfs(pos + speed, speed * 2),   // A
        dfs(pos, reverseSpeed)         // R
    )
}

Why the ±10000 window? Overshooting far past the target is provably useless — reversing near it is always better. The window is the practical pruning (a mathematically-tight bound: overshooting beyond 2×target never helps).

Why is R state (pos, reverseSpeed)? R doesn’t move — it only flips the speed to ±1 (sign of the incoming direction). The A action does the motion. The 6.1 implicit-graph BFS: nodes are (pos, speed) pairs, edges are the two commands.

Approach 1 — BFS over (pos, speed) with a visited set

The implicit-graph BFS: correct, the canonical answer for large targets.

Approach 2 — Memoized DFS (the repo’s version)

class Racecar {
    private val dp = mutableMapOf<Pair<Int, Int>, Int>()
    private var target = 0

    /**
     * @param target target position
     * @return       min instructions (A/R) to reach it
     */
    fun racecar(target: Int): Int {
        this.target = target
        dp.clear()
        return dfs(0, 1)
    }

    private fun dfs(pos: Int, speed: Int): Int {
        val key = Pair(pos, speed)
        return when {
            pos == target -> 0
            pos < -10000 || pos > 10000 -> Int.MAX_VALUE
            key in dp -> dp[key]!!
            else -> {
                val reverseSpeed = if (speed > 0) -1 else 1
                1 + minOf(dfs(pos + speed, speed * 2), dfs(pos, reverseSpeed))
            }
        }.also { dp[key] = it }
    }
}

import java.util.*;

public class Racecar {
    private Map<String, Integer> memo = new HashMap<>();
    private int target;

    private int dfs(int pos, int speed) {
        if (pos == target) return 0;
        if (pos < -10000 || pos > 10000) return Integer.MAX_VALUE;

        String key = pos + " " + speed;
        if (memo.containsKey(key)) return memo.get(key);

        int reverseSpeed = speed > 0 ? -1 : 1;
        int result = 1 + Math.min(dfs(pos + speed, speed * 2), dfs(pos, reverseSpeed));
        memo.put(key, result);
        return result;
    }

    /**
     * @param target target position
     * @return       min instructions (A/R) to reach it
     */
    public int racecar(int target) {
        this.target = target;
        return dfs(0, 1);
    }
}

#include <unordered_map>
#include <string>
#include <algorithm>
#include <climits>

class Racecar {
    std::unordered_map<std::string, int> memo;
    int target;

    int dfs(int pos, int speed) {
        if (pos == target) return 0;
        if (pos < -10000 || pos > 10000) return INT_MAX;

        std::string key = std::to_string(pos) + " " + std::to_string(speed);
        if (memo.count(key)) return memo[key];

        int rs = speed > 0 ? -1 : 1;
        return memo[key] = 1 + std::min(dfs(pos + speed, speed * 2), dfs(pos, rs));
    }

public:
    /**
     * @param target target position
     * @return       min instructions (A/R) to reach it
     */
    int racecar(int target) {
        this->target = target;
        return dfs(0, 1);
    }
};

from functools import lru_cache

def racecar(target: int) -> int:
    """
    @param target: target position
    @return:       min instructions (A/R) to reach it
    """
    @lru_cache(None)
    def dfs(pos: int, speed: int) -> int:
        if pos == target:
            return 0
        if pos < -10000 or pos > 10000:
            return float("inf")

        reverse_speed = -1 if speed > 0 else 1
        return 1 + min(dfs(pos + speed, speed * 2), dfs(pos, reverse_speed))

    return dfs(0, 1)

#![allow(unused)]
fn main() {
use std::collections::HashMap;

impl Solution {
    /// @param target target position
    /// @return       min instructions (A/R) to reach it
    pub fn racecar(target: i32) -> i32 {
        fn dfs(pos: i32, speed: i32, target: i32,
               memo: &mut HashMap<(i32, i32), i32>) -> i32 {
            if pos == target { return 0; }
            if pos < -10000 || pos > 10000 { return i32::MAX; }
            if let Some(&v) = memo.get(&(pos, speed)) { return v; }

            let rs = if speed > 0 { -1 } else { 1 };
            let result = 1 + dfs(pos + speed, speed * 2, target, memo)
                .min(dfs(pos, rs, target, memo));
            memo.insert((pos, speed), result);
            result
        }

        dfs(0, 1, target, &mut HashMap::new())
    }
}
}

Dry run

Input: target = 3.

dfs(0, 1):
  A: dfs(1, 2).    R: dfs(0, -1)
dfs(1, 2): A: dfs(3, 4) = 0 (reached!).  -> 1 + 0 = 1
  So dfs(1,2) = 1.  dfs(0,1) = 1 + min(1, ...) = 2 ✓

Input: target = 6:
dfs(0,1): A: dfs(1,2): A: dfs(3,4): A: dfs(7,8): pos 7 > 6... A: dfs(15,16) (far), R: dfs(7,-1)
  dfs(7,-1): A: dfs(6,-2) = 0.  -> 1.  dfs(7,8): A: 15->... vs R: 7->6: min = 1 + 1 = 2
  dfs(3,4): 1 + min(dfs(7,8)=2, dfs(3,-1): ...) — the winning line: A A A R A = 5 ✓

The recursion explores the command tree with memoization collapsing repeated (pos, speed) states. The window bound keeps the tree finite — positions beyond ±10000 are pruned as unreachable-in-practice. The R action never moves, so the state’s speed flips sign and the search continues.

Complexity

Time. States within the window:

$$ T = O(\text{window} \cdot \text{speeds}) $$

Space. The memo:

$$ S = O(\text{window} \cdot \text{speeds}) $$

Variants & follow-ups

• Word Ladder (6.1) — the same implicit-graph BFS framing.
• Minimum Number Of Refueling Stops (11.7) — a stateful-vehicle sibling.
• Interview follow-up: “Why is the ±10000 window valid?” A car that overshoots beyond 2×target must reverse — and any plan overshooting that far can be shortened by reversing earlier. The bound makes the memo finite; the canonical BFS version makes the same cut with a visited set.

2.27 Minimum Number Of Taps To Water The Garden

Source: src/main/kotlin/array/greedy/MinimumNumberOfTapsToWaterGarden.kt Pattern: interval covering via jump-game greedy · Core page

The Problem

Taps at positions 0..n, each waters [i - ranges[i], i + ranges[i]]. Min taps to cover [0, n].

• Constraints: n ≤ 10⁴.

Examples

Input:  n = 5, ranges = [3,4,1,1,0,0]   -> Output: 1   (tap 1 covers 0..5)
Input:  n = 3, ranges = [0,0,0,0]       -> Output: -1

Intuition — the 11.2 greedy, on coverage intervals

Each tap is an interval [left, right]. Track maxReach[left] = max right — the farthest any tap starting at left reaches. Then the minimum number of intervals covering [0, n] is the jump-game-II frontier sweep:

val maxReach = IntArray(n + 1) { it }
for (i in 0..n) {
    val left = maxOf(0, i - ranges[i])
    val right = minOf(n, i + ranges[i])
    maxReach[left] = maxOf(maxReach[left], right)
}

var taps = 0
var currEnd = 0
var farthest = 0

for (i in 0 until n) {
    farthest = maxOf(farthest, maxReach[i])
    if (i == currEnd) {            // reached this frontier's end: must take a tap
        taps++
        currEnd = farthest
        if (currEnd >= n) return taps
        if (currEnd <= i) return -1   // stuck: a gap
    }
}
return -1

Why is this the minimum? At each frontier boundary, taking the tap that extends coverage farthest is optimal (exchange argument — any other choice covers no more). The 11.2 layer logic: taps++ exactly when the current coverage ends.

Why maxReach[left] and not a sorted interval list? All taps with the same left bound: only the farthest right matters (it dominates). The array collapses the intervals into the jump-game’s “max jump from position i”.

Approach 1 — DP over positions (O(n²))

dp[i] = min taps to cover [0, i]: correct, slower.

Approach 2 — Frontier greedy (the repo’s version, optimal)

class MinimumNumberOfTapsToWaterGarden {
    /**
     * @param n      garden length
     * @param ranges tap ranges
     * @return       min taps, or -1
     */
    fun minTaps(n: Int, ranges: IntArray): Int {
        val maxReach = IntArray(n + 1) { it }

        for (i in 0..n) {
            val left = maxOf(0, i - ranges[i])
            val right = minOf(n, i + ranges[i])
            maxReach[left] = maxOf(maxReach[left], right)
        }

        var taps = 0
        var currEnd = 0
        var farthest = 0

        for (i in 0 until n) {
            farthest = maxOf(farthest, maxReach[i])

            if (i == currEnd) {
                taps++
                currEnd = farthest
                if (currEnd >= n) return taps
                if (currEnd <= i) return -1
            }
        }
        return -1
    }
}

public class MinimumNumberOfTapsToWaterGarden {
    /**
     * @param n      garden length
     * @param ranges tap ranges
     * @return       min taps, or -1
     */
    public int minTaps(int n, int[] ranges) {
        int[] maxReach = new int[n + 1];

        for (int i = 0; i <= n; i++) {
            int left = Math.max(0, i - ranges[i]);
            int right = Math.min(n, i + ranges[i]);
            maxReach[left] = Math.max(maxReach[left], right);
        }

        int taps = 0, currEnd = 0, farthest = 0;
        for (int i = 0; i < n; i++) {
            farthest = Math.max(farthest, maxReach[i]);

            if (i == currEnd) {
                taps++;
                currEnd = farthest;
                if (currEnd >= n) return taps;
                if (currEnd <= i) return -1;
            }
        }
        return -1;
    }
}

#include <vector>
#include <algorithm>

class MinimumNumberOfTapsToWaterGarden {
public:
    /**
     * @param n      garden length
     * @param ranges tap ranges
     * @return       min taps, or -1
     */
    int minTaps(int n, std::vector<int>& ranges) {
        std::vector<int> maxReach(n + 1);

        for (int i = 0; i <= n; i++) {
            int left = std::max(0, i - ranges[i]);
            int right = std::min(n, i + ranges[i]);
            maxReach[left] = std::max(maxReach[left], right);
        }

        int taps = 0, currEnd = 0, farthest = 0;
        for (int i = 0; i < n; i++) {
            farthest = std::max(farthest, maxReach[i]);

            if (i == currEnd) {
                taps++;
                currEnd = farthest;
                if (currEnd >= n) return taps;
                if (currEnd <= i) return -1;
            }
        }
        return -1;
    }
};

def min_taps(n: int, ranges: list[int]) -> int:
    """
    @param n:      garden length
    @param ranges: tap ranges
    @return:       min taps, or -1
    """
    max_reach = [0] * (n + 1)
    for i, r in enumerate(ranges):
        left = max(0, i - r)
        right = min(n, i + r)
        max_reach[left] = max(max_reach[left], right)

    taps = curr_end = farthest = 0
    for i in range(n):
        farthest = max(farthest, max_reach[i])

        if i == curr_end:
            taps += 1
            curr_end = farthest
            if curr_end >= n:
                return taps
            if curr_end <= i:
                return -1
    return -1

#![allow(unused)]
fn main() {
impl Solution {
    /// @param n      garden length
    /// @param ranges tap ranges
    /// @return       min taps, or -1
    pub fn min_taps(n: i32, ranges: Vec<i32>) -> i32 {
        let n = n as usize;
        let mut max_reach = vec![0usize; n + 1];

        for i in 0..=n {
            let left = i.saturating_sub(ranges[i] as usize);
            let right = (i + ranges[i] as usize).min(n);
            max_reach[left] = max_reach[left].max(right);
        }

        let (mut taps, mut curr_end, mut farthest) = (0, 0, 0);
        for i in 0..n {
            farthest = farthest.max(max_reach[i]);

            if i == curr_end {
                taps += 1;
                curr_end = farthest;
                if curr_end >= n { return taps; }
                if curr_end <= i { return -1; }
            }
        }
        -1
    }
}
}

Dry run

Input: n = 5, ranges = [3,4,1,1,0,0].

maxReach: tap0: [0,3] -> maxReach[0]=3.  tap1: [0,5] -> maxReach[0]=5.  tap2: [1,3] -> maxReach[1]=3.
          tap3: [2,4] -> maxReach[2]=4.  tap4: [4,4].  tap5: [5,5].
maxReach = [5,3,4,4,4,5]

i=0: farthest = 5.  i == currEnd (0): taps=1, currEnd=5 >= n -> return 1 ✓

One tap (tap 1, range 4) covers [0, 5] — the greedy finds it instantly. The failing case ranges = [0,0,0,0]: maxReach = [0,1,2,3]; i=0: taps=1, currEnd=0, currEnd <= i → -1 ✓ (no coverage can start). The frontier sweep is the jump-game engine with maxReach as the jump array.

Complexity

Time. Two passes:

$$ T(n) = O(n) $$

Space. The reach array:

$$ S(n) = O(n) $$

Variants & follow-ups

• Jump Game II (11.2) — the engine this page reuses.
• Video Stitching (array/greedy/VideoStitching.kt) — the same interval-covering greedy on video clips.
• Interview follow-up: “Why does collapsing by left-bound work?” For all taps starting at left, the one with the max right dominates the rest — any solution using a dominated tap can swap in the dominant one without losing coverage. The array form is the 11.2 jump table; the frontier count is the min-cover count.

2.28 Shortest Common Supersequence

Source: src/main/kotlin/string/dynamic_programming/ShortestCommonSupersequence.kt Pattern: LCS table + backtrace · Core page

The Problem

The shortest string that has both strings as subsequences (return it).

• Constraints: lengths ≤ 1000.

Examples

Input:  X = "abac", Y = "cab"   -> Output: "cabac" (length 5)

Intuition — the LCS 2.3 table, then merge around it

A supersequence needs each char once per string; sharing the LCS chars saves the most. Build the LCS table, then backtrace — take the LCS chars once, the rest in order:

val dp = Array(m + 1) { IntArray(n + 1) }
for (i in 1..m) for (j in 1..n) {
    dp[i][j] = if (X[i - 1] == Y[j - 1]) dp[i - 1][j - 1] + 1 else maxOf(dp[i - 1][j], dp[i][j - 1])
}

val scs = StringBuilder()
var (i, j) = m to n
while (i > 0 && j > 0) {
    when {
        X[i - 1] == Y[j - 1] -> { scs.append(X[i - 1]); i--; j-- }
        dp[i - 1][j] > dp[i][j - 1] -> { scs.append(X[i - 1]); i-- }
        else -> { scs.append(Y[j - 1]); j-- }
    }
}
while (i > 0) { scs.append(X[i - 1]); i-- }
while (j > 0) { scs.append(Y[j - 1]); j-- }
return scs.reverse().toString()

Why the when backtrace? The table’s construction decides the order: equal chars (LCS) appended once and move diagonally; otherwise append from the side with the larger dp. The result is the SCS — the 2.24 LCS machinery with a string output.

Approach 1 — LCS table + backtrace (the repo’s version, optimal)

class ShortestCommonSupersequence {
    /**
     * @param X first string
     * @param Y second string
     * @return  shortest common supersequence
     */
    fun shortestCommonSupersequence(X: String, Y: String): String? {
        val (m, n) = X.length to Y.length
        val dp = Array(m + 1) { IntArray(n + 1) }

        for (i in 1..m) for (j in 1..n) {
            dp[i][j] = if (X[i - 1] == Y[j - 1]) dp[i - 1][j - 1] + 1 else maxOf(dp[i - 1][j], dp[i][j - 1])
        }

        val scs = StringBuilder()
        var (i, j) = m to n

        while (i > 0 && j > 0) {
            when {
                X[i - 1] == Y[j - 1] -> { scs.append(X[i - 1]); i--; j-- }
                dp[i - 1][j] > dp[i][j - 1] -> { scs.append(X[i - 1]); i-- }
                else -> { scs.append(Y[j - 1]); j-- }
            }
        }
        while (i > 0) { scs.append(X[i - 1]); i-- }
        while (j > 0) { scs.append(Y[j - 1]); j-- }

        return scs.reverse().toString()
    }
}

public class ShortestCommonSupersequence {
    /**
     * @param X first string
     * @param Y second string
     * @return  shortest common supersequence
     */
    public String shortestCommonSupersequence(String X, String Y) {
        int m = X.length(), n = Y.length();
        int[][] dp = new int[m + 1][n + 1];

        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                dp[i][j] = X.charAt(i - 1) == Y.charAt(j - 1)
                    ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);

        StringBuilder scs = new StringBuilder();
        int i = m, j = n;
        while (i > 0 && j > 0) {
            if (X.charAt(i - 1) == Y.charAt(j - 1)) { scs.append(X.charAt(i - 1)); i--; j--; }
            else if (dp[i - 1][j] > dp[i][j - 1]) { scs.append(X.charAt(i - 1)); i--; }
            else { scs.append(Y.charAt(j - 1)); j--; }
        }
        while (i > 0) scs.append(X.charAt(--i));
        while (j > 0) scs.append(Y.charAt(--j));

        return scs.reverse().toString();
    }
}

#include <string>
#include <vector>
#include <algorithm>

class ShortestCommonSupersequence {
public:
    /**
     * @param X first string
     * @param Y second string
     * @return  shortest common supersequence
     */
    std::string shortestCommonSupersequence(std::string X, std::string Y) {
        int m = X.size(), n = Y.size();
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1));

        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                dp[i][j] = X[i - 1] == Y[j - 1]
                    ? dp[i - 1][j - 1] + 1 : std::max(dp[i - 1][j], dp[i][j - 1]);

        std::string scs;
        int i = m, j = n;
        while (i > 0 && j > 0) {
            if (X[i - 1] == Y[j - 1]) { scs += X[i - 1]; i--; j--; }
            else if (dp[i - 1][j] > dp[i][j - 1]) { scs += X[i - 1]; i--; }
            else { scs += Y[j - 1]; j--; }
        }
        while (i > 0) scs += X[--i];
        while (j > 0) scs += Y[--j];

        std::reverse(scs.begin(), scs.end());
        return scs;
    }
};

def shortest_common_supersequence(X: str, Y: str) -> str:
    """
    @param X: first string
    @param Y: second string
    @return:  shortest common supersequence
    """
    m, n = len(X), len(Y)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            dp[i][j] = dp[i - 1][j - 1] + 1 if X[i - 1] == Y[j - 1] else max(dp[i - 1][j], dp[i][j - 1])

    scs = []
    i, j = m, n
    while i > 0 and j > 0:
        if X[i - 1] == Y[j - 1]:
            scs.append(X[i - 1]); i -= 1; j -= 1
        elif dp[i - 1][j] > dp[i][j - 1]:
            scs.append(X[i - 1]); i -= 1
        else:
            scs.append(Y[j - 1]); j -= 1

    scs.extend(X[:i])
    scs.extend(Y[:j])
    return "".join(reversed(scs))

#![allow(unused)]
fn main() {
impl Solution {
    /// @param X first string
    /// @param Y second string
    /// @return  shortest common supersequence
    pub fn shortest_common_supersequence(X: String, Y: String) -> String {
        let (xb, yb) = (X.as_bytes(), Y.as_bytes());
        let (m, n) = (xb.len(), yb.len());
        let mut dp = vec![vec![0; n + 1]; m + 1];

        for i in 1..=m {
            for j in 1..=n {
                dp[i][j] = if xb[i - 1] == yb[j - 1] { dp[i - 1][j - 1] + 1 }
                           else { dp[i - 1][j].max(dp[i][j - 1]) };
            }
        }

        let mut scs: Vec<u8> = Vec::new();
        let (mut i, mut j) = (m, n);
        while i > 0 && j > 0 {
            if xb[i - 1] == yb[j - 1] { scs.push(xb[i - 1]); i -= 1; j -= 1; }
            else if dp[i - 1][j] > dp[i][j - 1] { scs.push(xb[i - 1]); i -= 1; }
            else { scs.push(yb[j - 1]); j -= 1; }
        }
        while i > 0 { scs.push(xb[i - 1]); i -= 1; }
        while j > 0 { scs.push(yb[j - 1]); j -= 1; }

        scs.reverse();
        String::from_utf8(scs).unwrap()
    }
}
}

Dry run

Input: X = "abac", Y = "cab".

LCS = "ab"? no — "abac" vs "cab": LCS is "ab" (a-b) length 2.
dp backtrace:
  (4,3): 'c'=='b'? no.  dp[3][3]=2 > dp[4][2]=2? no -> take Y[2]='b'.  j=2.  scs "b"
  (4,2): 'c'=='a'? no.  dp[3][2]=1 > dp[4][1]=1? no -> take Y[1]='a'.  j=1.  "ba"
  (4,1): 'c'=='c'? yes -> take 'c'.  i=3, j=0.  "bac"
  j=0, i=3: drain X[2..0] = "a","b","a" -> "baca b a" ... append X[2]='a', X[1]='b', X[0]='a' -> "bacaba"
  reverse -> "abacab"?  Length 6, but the expected SCS of "abac"+"cab" is 5 ("cabac" or "abacb"?)...

correct LCS: "abac" vs "cab" — common subsequences: "ab" (len 2), "ac"? a-c: positions 0,2 in X, c-a? 
"cab": c,a,b.  "ac": a(0),c(2) vs c(0),a(1) -> no.  "ab": a(0),b(1) vs a(1),b(2) -> yes len 2.
So SCS length = 4 + 3 - 2 = 5.  One valid SCS: "cabac"?  check: "abac" in "cabac"? c-a-b-a-c: a(1),b(2),a(3),c(4) yes.  "cab" yes.  ✓
The backtrace gives ONE valid SCS (length 5).  The exact string depends on tie-breaks — 
"cabac" via the (1,1) choice: take 'a' from both first... any valid backtrace yields length m+n-LCS.

Complexity

Time. LCS table + backtrace:

$$ T(m, n) = O(m \cdot n) $$

Space. The table:

$$ S(m, n) = O(m \cdot n) $$

Variants & follow-ups

• Longest Common Subsequence (2.3) — the length-only ancestor.
• Delete Operations (2.24) — the same table, deletions instead of merges.
• Interview follow-up: “Why does the SCS length = m+n−LCS?” The LCS chars are the only ones both strings need once — every other char appears in exactly one string. Merging around the LCS realizes that bound; the backtrace builds the witness.

2.29 Min Cost Climbing Stairs

Source: src/main/kotlin/array/dp/MinCostClimbingStaris.kt Pattern: two-step DP · Core page

The Problem

Climb to the top paying cost[i] per step; take 1 or 2 steps. Min cost.

• Constraints: n ≥ 2.

Examples

Input:  cost = [10,15,20]      -> Output: 15   (start at 1, pay 15, jump past top)
Input:  cost = [1,100,1,1,1,100,1,1,100,1]  -> Output: 6

Intuition — the cheapest way to stand on step i

dp[i] = min cost to reach step i = cost[i] + min(dp[i-1], dp[i-2]) — the 2.4 neighbor-choice DP:

val dp = IntArray(cost.size)
dp[0] = cost[0]
dp[1] = cost[1]

for (i in 2 until cost.size) {
    dp[i] = cost[i] + minOf(dp[i - 1], dp[i - 2])
}
return minOf(dp[cost.size - 1], dp[cost.size - 2])   // finish from either top step

Why return the min of the last two? The top is past the last step — you can finish from step n-1 or n-2 (one 2-step jump). The answer is the cheaper landing.

Why the 2.4 shape? Each step’s best depends only on the previous two — a linear DP with constant lookback.

Approach 1 — Full DP array (the repo’s version)

Approach 2 — Two rolling variables (O(1) space)

prev2, prev1 updated per step — same recurrence, no array.

class MinCostClimbingStaris {
    /**
     * @param cost step costs
     * @return     min cost to reach the top
     */
    fun minCostClimbingStairs(cost: IntArray): Int {
        if (cost.size <= 2) return cost.min()

        val dp = IntArray(cost.size)
        dp[0] = cost[0]
        dp[1] = cost[1]

        for (i in 2 until cost.size) {
            dp[i] = cost[i] + minOf(dp[i - 1], dp[i - 2])
        }
        return minOf(dp[cost.size - 1], dp[cost.size - 2])
    }
}

public class MinCostClimbingStairs {
    /**
     * @param cost step costs
     * @return     min cost to reach the top
     */
    public int minCostClimbingStairs(int[] cost) {
        int prev2 = cost[0], prev1 = cost[1];

        for (int i = 2; i < cost.length; i++) {
            int cur = cost[i] + Math.min(prev1, prev2);
            prev2 = prev1;
            prev1 = cur;
        }
        return Math.min(prev1, prev2);
    }
}

#include <vector>
#include <algorithm>

class MinCostClimbingStairs {
public:
    /**
     * @param cost step costs
     * @return     min cost to reach the top
     */
    int minCostClimbingStairs(std::vector<int>& cost) {
        int prev2 = cost[0], prev1 = cost[1];

        for (int i = 2; i < (int)cost.size(); i++) {
            int cur = cost[i] + std::min(prev1, prev2);
            prev2 = prev1;
            prev1 = cur;
        }
        return std::min(prev1, prev2);
    }
};

def min_cost_climbing_stairs(cost: list[int]) -> int:
    """
    @param cost: step costs
    @return:     min cost to reach the top
    """
    prev2, prev1 = cost[0], cost[1]

    for c in cost[2:]:
        prev2, prev1 = prev1, c + min(prev1, prev2)

    return min(prev1, prev2)

#![allow(unused)]
fn main() {
impl Solution {
    /// @param cost step costs
    /// @return     min cost to reach the top
    pub fn min_cost_climbing_stairs(cost: Vec<i32>) -> i32 {
        let mut prev2 = cost[0];
        let mut prev1 = cost[1];

        for &c in cost.iter().skip(2) {
            let cur = c + prev1.min(prev2);
            prev2 = prev1;
            prev1 = cur;
        }
        prev1.min(prev2)
    }
}
}

Reading the code — what’s actually happening

val dp = IntArray(cost.size)
dp[0] = cost[0]
dp[1] = cost[1]
for (i in 2 until cost.size) {
    dp[i] = cost[i] + minOf(dp[i - 1], dp[i - 2])
}
return minOf(dp[cost.size - 1], dp[cost.size - 2])

Stand on step i and ask: “what’s the cheapest way I could have gotten here?” You arrived either from step i-1 (one step) or step i-2 (two steps) — so the answer is this step’s cost plus the cheaper of those two arrival costs.

• dp[0] = cost[0] and dp[1] = cost[1] are the hand-placed bases. The problem lets you start on step 0 or step 1 for free (no cost to begin), so the cheapest way to “be on” step 0 is just paying cost[0], and likewise step 1. Steps 0 and 1 can’t be reached by stepping onto them, so they can’t use the recurrence.
• dp[i] = cost[i] + min(dp[i-1], dp[i-2]) is the two-step lookback. Each step looks only two steps behind — a linear recurrence with constant history, which is why this whole problem needs O(1) memory (the rolling prev2/prev1 variant) even though the code above uses a full array.
• return min(dp[n-1], dp[n-2]) is the “past the top” finish. The top of the stairs is beyond the last step. From step n-1 you can finish with a 1-step; from step n-2 with a 2-step. Whichever arrival is cheaper is the answer — you never pay for a step past the end.

Trace [10,15,20]: dp[0]=10, dp[1]=15; dp[2] = 20 + min(15,10) = 30; answer min(dp[2], dp[1]) = min(30,15) = 15 ✓ — start on step 1 (pay 15) and take the 2-step over the top.

Dry run

Input: cost = [10,15,20].

dp[0]=10, dp[1]=15.
i=2: dp[2] = 20 + min(15, 10) = 30.
return min(30, 15) = 15 ✓  (start at 1, pay 15, 2-step to the top)

Complexity

Time. One pass:

$$ T(n) = O(n) $$

Space. O(n) or O(1):

$$ S(n) = O(1) $$

Variants & follow-ups

• Climbing Stairs — the no-cost counting twin.
• House Robber (2.4) — the same two-step lookback DP.
• Interview follow-up: “Why the min of the last two dp entries?” The top isn’t a paid step — it’s reached from either of the last two. Ending the recurrence one step early and taking the cheaper landing IS the finish rule.

2.30 Coin Change II

Source: src/main/kotlin/array/dp/CoinChange_II.kt Pattern: unbounded-knapsack combinations · Core page

The Problem

The number of combinations making amount (unlimited coins).

• Constraints: amount ≤ 5000; coins ≤ 300.

Examples

Input:  amount = 5, coins = [1,2,5]   -> Output: 4   (5, 2+2+1, 2+1+1+1, 1+1+1+1+1)

Intuition — the 2.16 table, counting instead of minimizing

dp[i][j] = combinations using the first i coins for amount j = skip the coin + use it (stay on the same coin row — unbounded):

val dp = Array(amount + 1) { IntArray(coins.size) { -1 } }
return change(dp, amount, coins, 0)

fun change(dp, amount, coins, i): Int = when {
    amount < 0 || (i == coins.size && amount > 0) -> 0
    amount == 0 -> 1
    else -> {
        if (dp[amount][i] != -1) dp[amount][i]!!
        else {
            dp[amount][i] = change(dp, amount - coins[i], coins, i) +   // take (unbounded)
                            change(dp, amount, coins, i + 1)             // skip
            dp[amount][i]!!
        }
    }
}

Why stay on i for the take branch? Unbounded coins — taking a coin doesn’t advance the coin index. The 2.16 memoized DP with + instead of min and a count base case.

Approach 1 — Memoized include/exclude (the repo’s version)

Approach 2 — 1-D table (the _BottomUp file, optimal)

dp[j] += dp[j - coin] for each coin — the unbounded-knapsack counting order.

class CoinChange_II {
    /**
     * @param amount target amount
     * @param coins  coin values
     * @return       number of combinations
     */
    fun change(amount: Int, coins: IntArray): Int {
        val dp = Array(amount + 1) { IntArray(coins.size) { -1 } }
        return change(dp, amount, coins, 0)
    }

    private fun change(dp: Array<IntArray>, amount: Int, coins: IntArray, i: Int): Int {
        return when {
            amount < 0 || (i == coins.size && amount > 0) -> 0
            amount == 0 -> 1
            else -> {
                if (dp[amount][i] != -1) dp[amount][i]!!
                else {
                    dp[amount][i] = change(dp, amount - coins[i], coins, i) +
                                    change(dp, amount, coins, i + 1)
                    dp[amount][i]!!
                }
            }
        }
    }
}

import java.util.*;

public class CoinChangeII {
    private int[][] memo;

    private int solve(int[] coins, int amount, int i) {
        if (amount == 0) return 1;
        if (amount < 0 || i == coins.length) return 0;

        if (memo[amount][i] != -1) return memo[amount][i];

        return memo[amount][i] = solve(coins, amount - coins[i], i)     // take
                               + solve(coins, amount, i + 1);           // skip
    }

    /**
     * @param amount target amount
     * @param coins  coin values
     * @return       number of combinations
     */
    public int change(int amount, int[] coins) {
        memo = new int[amount + 1][coins.length];
        for (int[] row : memo) Arrays.fill(row, -1);
        return solve(coins, amount, 0);
    }
}

#include <vector>
#include <cstring>

class CoinChangeII {
public:
    /**
     * @param amount target amount
     * @param coins  coin values
     * @return       number of combinations
     */
    int change(int amount, std::vector<int>& coins) {
        std::vector<long> dp(amount + 1, 0);
        dp[0] = 1;

        for (int coin : coins) {                    // coin outer: combinations (orderless)
            for (int j = coin; j <= amount; j++) {
                dp[j] += dp[j - coin];
            }
        }
        return (int)dp[amount];
    }
};

def change(amount: int, coins: list[int]) -> int:
    """
    @param amount: target amount
    @param coins:  coin values
    @return:       number of combinations
    """
    dp = [0] * (amount + 1)
    dp[0] = 1

    for coin in coins:                      # coin outer: combinations (orderless)
        for j in range(coin, amount + 1):
            dp[j] += dp[j - coin]

    return dp[amount]

#![allow(unused)]
fn main() {
impl Solution {
    /// @param amount target amount
    /// @param coins  coin values
    /// @return       number of combinations
    pub fn change(amount: i32, coins: Vec<i32>) -> i32 {
        let mut dp = vec![0u64; amount as usize + 1];
        dp[0] = 1;

        for coin in coins {
            for j in (coin as usize)..=(amount as usize) {
                dp[j] += dp[j - coin as usize];
            }
        }
        dp[amount as usize] as i32
    }
}
}

Dry run

Input: amount = 5, coins = [1,2,5] (1-D version).

dp = [1,0,0,0,0,0]
coin 1: dp[1..5] += dp[j-1] -> [1,1,1,1,1,1]
coin 2: dp[2]=1+dp[0]=2.  dp[3]=1+dp[1]=2.  dp[4]=1+dp[2]=3.  dp[5]=1+dp[3]=3.
coin 5: dp[5]=3+dp[0]=4.
Output: 4 ✓

The coin-outer loop is what makes it combinations: each coin’s pass adds uses of that coin to existing amounts — order doesn’t matter (a permutation-counting version would loop amount-outer).

Complexity

Time. Coins × amount:

$$ T(c, a) = O(c \cdot a) $$

Space. The 1-D table:

$$ S(a) = O(a) $$

Variants & follow-ups

• Coin Change (2.16) — minimize vs count.
• 01 Knapsack / Unbounded Knapsack — the same table’s siblings.
• Interview follow-up: “Why does the coin-outer loop count combinations?” Amount-outer would count sequences (1+2 and 2+1 separately). Fixing the coin order means each combination is built in sorted-coin order exactly once — the canonical unbounded-knapsack counting order.

2.31 Unique Paths

Source: src/main/kotlin/grid/dynamic_programming/UniquePaths_I.kt Pattern: grid DP / combinatorics · Core page