Sequential Hiring Problem

• Sequential Hiring Problem is a dynamic optimization model where positions are filled sequentially using adaptive, value-based decision rules.
• Block-responsive policies compress decision trees to O((log n)^k) nodes, enabling tractable, near-optimal strategies with provable approximation guarantees.
• Approximation schemes using enumeration and rounding achieve (1-ε) performance, balancing efficiency and minimal loss in multi-stage hiring under uncertainty.

The sequential hiring problem is a dynamic optimization model central to decision-making under uncertainty in adaptive resource allocation. In its canonical form, a firm aims to maximize expected value by filling a limited number of positions by sequentially interviewing a known pool of applicants, each characterized by a value and a stochastic acceptance probability. Modern formulations focus on semi-adaptive and block-responsive strategies, yielding significant advances in provable performance guarantees and tractable algorithm design (Segev et al., 19 Jan 2026). This article surveys foundational models, core methodologies, recent algorithmic advances (especially block-responsive policies), approximation guarantees, and selected applications.

1. Formal Model and Core Definitions

The basic sequential hiring problem is defined by:

• $n$ applicants indexed by $i\in[n]$, each presenting a known value $v_i>0$ and acceptance probability $p_i\in(0,1]$.
• $k$ vacancies to fill, with offers made adaptively and irrevocably.
• At each time $t$, conditioned on history (which applicants remain, how many slots are left), the firm selects an available applicant to make an offer; if accepted, the applicant is hired and one slot is filled.

A general adaptive policy (can be represented as a decision tree) specifies which applicant to offer under each possible state (subset of remaining applicants, stages, and open positions). The optimal policy maximizes total expected value but may require exponential-size representations.

Block-responsive policies generalize this by allowing a batch (block) of offers in a specified order, awarding the first acceptance and aborting further offers within the block. The state evolves naturally by updating the block, time index, open positions, and remaining applicants.

Formally, a block-responsive policy $\mathsf{HB}$ is a mapping

$$\mathsf{HB}: [T] \times \{0,1,\dots,k\} \times 2^{[n]} \to \biguplus_{\ell=1}^n (2^{[n]}_{\ell} \times S_{\ell}),$$

choosing at each system state $(t,k,A)$ a block $B\subseteq A$ and total order $\pi$ (a permutation of $B$). Offers proceed in this order until one applicant accepts, at which point the block ends, updating to $(t+|B|,k-1,A\setminus B)$, or else (if all reject) to $(t+|B|,k,A\setminus B)$ (Segev et al., 19 Jan 2026).

2. Structural Results and Representation Compression

Fully adaptive policies, though optimal in expectation, cause a combinatorial explosion in policy-tree size—generally $n^k$ leaves for $k$ slots among $n$ applicants.

The core innovation of block-responsive strategies is their representational compression. Succinct decision trees are built by:

• Grouping contiguous segments of the leftmost root-to-leaf path (sequence of failed offers) into single blocks.
• Recursing on right children (corresponding to acceptances) to continue the process for the remaining $k-1$ slots.

Formally, the optimal adaptive tree $T^*$ is compressed by identifying $O(\log n)$ "terminals," merging intervals into blocks, and recursively handling right subtrees. This guarantees at most $k$ recursion levels, with each level having $O(\log n)$ depth. Hence, the resulting policy tree has $O((\log n)^k)$ nodes for constant $k$—a polynomial-size representation even for adaptively intricate strategies (Segev et al., 19 Jan 2026).

3. Approximation Schemes and Performance Guarantees

A main algorithmic advance is the first polynomial-time approximation scheme (PTAS) for sequential hiring:

• For any fixed $\epsilon>0$, there exists a block-responsive policy $\mathsf{HB}$ whose expected total value satisfies

$$R(\mathsf{HB}) \geq (1-O(\epsilon^3 k)) R^* \geq (1-\epsilon) R^*,$$

where $R^*$ is the expected value of the fully optimal adaptive policy.

• This result holds when $k=O(1)$ (constant number of slots), as the polynomial complexity is in terms of $n$ (number of applicants), $T$ (time stages), and $1/\epsilon$.

The construction uses enumeration and rounding:

1. Applicants are partitioned into classes according to their acceptance probabilities.
2. For each block along the principal branch, enumerate (and discretize) overall value and rejection rates by class.
3. Assign applicants greedily within classes to meet block-level constraints.
4. Build right subtrees recursively for $k-1$ positions.

For $k$ large, prior linear-programming (LP) relaxations already yield $(1-e^{-k}k^k/k!)$-approximations, converging to $(1-\epsilon)$ for $k\geq O(\log(1/\epsilon))$ (Segev et al., 19 Jan 2026).

4. Algorithmic Construction and Complexity

Block-responsive policy construction for the PTAS is grounded on recursive enumeration:

• Fix target $k$ (slots) and $\epsilon>0$.
• Partition applicants into $M=O(\frac{1}{\epsilon}\log T)$ probability classes.
• For each of $F=O(\frac{1}{\epsilon}\log T)$ blocks, enumerate possible value-contributions and rejection-probabilities (rounded to integer increments or geometrically).
• Greedily fill each block by value within classes.
• Recursively build right subtrees for remaining positions.

The time complexity is

$O(n^{O(1)} \cdot T^{O(1/\epsilon^2)}),$

which is polynomial in $n,T$ for any constant $\epsilon>0$. This circumvents the exponential blow-up of fully adaptive trees while guaranteeing near-optimality (Segev et al., 19 Jan 2026).

5. Proof Techniques and Loss Analysis

Key technical arguments establish that merging consecutive single-offer steps into larger blocks incurs only $O(\epsilon^3)$ per-slot loss:

• Block grouping exploits the fact that, with high probability, no acceptance occurs within short stretches, and thus skipping the remaining suboptimal offers has negligible impact.
• The loss over $k$ positions is additive, giving the final bound.
• The internal order of offers within blocks—in non-increasing value order for each class—does not degrade the expected value.
• Enumeration and rounding suffice to capture all performance-critical block types.

This proof approach bridges the adaptivity gap and clarifies why block-responsive policies suffice in practice when compared to the theoretical optimal (Segev et al., 19 Jan 2026).

6. Numerical Illustration and Practical Impact

A representative small-scale example with $n=4$ applicants ($p = [0.2, 0.8, 0.5, 0.2]$, $v = [10,20,15,10]$, $k=2$) reveals that a block-responsive policy (offering $\{2,3\}$, then, if needed, $\{1,4\}$) closely approximates the optimal: most expected value is captured by just two blocks, validating both the compression and effectiveness of the method.

Implications include:

• Drastic reduction in policy representation size without significant loss in performance.
• Applicability to a range of adaptive allocation settings beyond classical hiring (e.g., adaptive resource throttling, job scheduling under uncertainty).
• Foundational support for augmenting semi-adaptive policy designs in operations research and online decision making (Segev et al., 19 Jan 2026).

---

References:

• "Approximation Schemes for Sequential Hiring Problems" (Segev et al., 19 Jan 2026)
• LP-based constant factor bounds: Epstein and Ma (Operations Research, 2024, cited in (Segev et al., 19 Jan 2026))