---
title: Bottleneck Assignment with Path Costs
url: https://www.emergentmind.com/topics/bottleneck-assignment-with-path-costs
type: topic
---

# Bottleneck Assignment with Path Costs

The bottleneck assignment problem with path costs centers on optimizing the maximal edge length (“bottleneck cost”) in matchings between two finite point sets, under translations of one set, and extends to problems involving continuous paths, constraints, and worst-case analysis. The problem has deep connections with hyperplane arrangements and geometric combinatorics, underpinning advanced algorithmic approaches and establishing polynomial complexity bounds that are optimal with respect to the input size and dimension [1405.0900].

## 1. Problem Formulation and Bottleneck Distance Under Translation

Let $A \subset \mathbb{R}^2$ and $B \subset \mathbb{R}^2$ be finite point sets with cardinalities $|A| = n \geq k = |B|$. For $t \in \mathbb{R}^2$, translation of $B$ is denoted $B + t = \{b + t : b \in B\}$. A matching is defined as an injection $\sigma : B \hookrightarrow A$. The (squared) bottleneck cost function of $\sigma$ under translation $t$ is:
$$
f_\sigma(t) = \max_{b \in B} \| (b + t) - \sigma(b) \|^2 \,.
$$
The global bottleneck distance function is:
$$
E(t) = \min_{\sigma: B \hookrightarrow A} f_\sigma(t) \,,
$$
i.e., the minimum maximal squared distance incurred over all matchings, for a given translation $t$.

The optimization objective is:
$$
\min_{t \in \mathbb{R}^2} E(t) \,,
$$
with the attendant recovery of a matching $\sigma^*$ that realizes $E(t^*)$. This formulation transparently supports lexicographic tie-breaking: for injection $\sigma$, let $g_\sigma(t) \in \mathbb{R}^k$ be the sorted (descending) vector of squared edge lengths; $\sigma$ is lex-bottleneck optimal at $t$ if $g_\sigma(t)$ is lexicographically minimal among all injections.

## 2. Bottleneck and Lex-Bottleneck Voronoi Diagrams: Structure and Complexity

As translation $t$ varies, the bottleneck-optimal matching $\sigma^*$ can change—specifically, at points where candidate matchings “swap” order via edge length equality. For edges $ab$, $a'b'$ ($a, a' \in A$, $b, b' \in B$) with $(b - a) \neq (b' - a')$, define the bisector hyperplane:
$$
h(a, b; a', b') = \{ t \in \mathbb{R}^2 : \|b + t - a\|^2 = \|b' + t - a'\|^2 \}
$$
which is a straight line in $\mathbb{R}^2$. The finite set $H$ of all such bisector lines partitions $\mathbb{R}^2$ into convex polygonal cells. On each open cell, the lex-bottleneck matching is invariant.

The lex-bottleneck diagram (the arrangement $\operatorname{Arr}(H)$) defines a partition, with the coarser bottleneck diagram formed by contracting cells that support the same maximal edge set. Theoretical bounds are as follows:
- For general dimension $d$, the number of bisectors $|H| = O(n^2 k^2)$, and the arrangement has $O(n^{2d} k^{2d})$ cells.
- In the planar case ($d=2$), most bisectors are irrelevant: only those corresponding to order-$\leq k$ Voronoi edges of $A-b$ (for each $b$), or order-$\leq 2k-1$ edges of $(A-b) \cup (A-b')$ (for distinct $b, b'$), can contribute.
- Using the Clarkson–Shor technique, one finds only $O(nk^3)$ bisectors, so the arrangement in $\mathbb{R}^2$ has $O(n^2 k^6)$ cells, which is optimal in $n$.

## 3. Algorithmic Construction and Optimization Over Translations

The bottleneck diagram enables efficient optimization and matching recovery. The algorithm for construction and solution proceeds as follows (complexity in the plane):

1. **Identify Critical Bisectors:** For each $b \in B$, compute the (≤$k$)-level in the arrangement of lines dual to $A - b$ in $O(nk)$ expected time; for each unordered pair $\{b, b'\}$, compute the (≤$2k-1$) level in the arrangement of lines dual to $(A-b) \cup (A-b')$. The total number of critical bisectors is $O(nk^3)$.
2. **Build Diagram Arrangement:** Construct the arrangement of $O(nk^3)$ lines using $O(n^2 k^6)$ time.
3. **Initialize and Label:** For a cell $C_0$, evaluate $E(t_0)$ (for interior $t_0$), assemble the $k$-closest edges for each $b$, and map the relevant candidate edge set. Build a bipartite graph and solve for the minimum bottleneck matching using Gabow–Tarjan’s algorithm.
4. **Traverse and Update:** Walk the arrangement’s adjacency graph; as adjacent cells are crossed, update the candidate edge sets and matchings using efficient augmenting path computations.
5. **Find Global Minimum:** For each cell, minimize the convex quadratic $f_\mu(t)$ over the polygonal cell (minimizer occurs at a vertex or edge). Track the global minimum.

The complex step is traversal and update, conducting $O(n^2 k^8)$ work overall due to $O(n^2 k^6)$ cells and per-cell update/labeling cost $O(k^2)$.

| Quantity                              | Symbol/Definition                 | Complexity (Plane)              |
|----------------------------------------|-----------------------------------|---------------------------------|
| Bottleneck diagram cells               | $O(n^2 k^6)$                      | $O(n^2 k^6)$                    |
| Construction (including labeling)      |                                   | $O(n^2 k^8)$                    |
| Global optimum/min of $E(t)$           |                                   | $O(n^2 k^8)$                    |

## 4. Path Optimization: Minimum-Bottleneck Trajectories

With the bottleneck diagram labeled, path cost queries become tractable. One defines the **bottleneck adjacency graph** $D^*$:
- Vertices correspond to cells $C$ of the diagram.
- Edges connect adjacent cells $\{C, D\}$, with weight $w(C, D) = \min_{t \in \ell} E(t)$ for shared boundary segment $\ell$.

Consider translations $t_0 \in C_0, t_1 \in C_1$. A path $\gamma$ from $t_0$ to $t_1$ in $\mathbb{R}^2$ with maximal cost $\leq \Delta$ exists if and only if both $E(t_0), E(t_1) \leq \Delta$, and there is a path in $D^*$ from $C_0$ to $C_1$ with all edge weights $\leq \Delta$.

Computing the minimum-bottleneck path in this context reduces to a min-max path problem in an undirected graph of $O(n^2 k^6)$ size, solvable with Dijkstra-style variants in $O(n^2 k^6 \log(nk))$.

## 5. Coverage and Maximum Bottleneck Costs Within Convex Constraints

Given a convex polygon $Q \subset \mathbb{R}^2$ (with $m$ vertices), the worst-case or “cover” bottleneck cost over all translations $t$ with $B + t \subset Q$—i.e., the maximum $E(t)$ in the intersection $Q^*$ of $k$ translates of $Q$—can be determined efficiently:
- Overlay the arrangement diagram and $Q^*$, yielding a decomposition with $O((n^2 k^6 + m) \log(n+m))$ time.
- Over each cell of the refined arrangement, the cost function $E(t)$ is convex; the maximum is attained at a vertex.
- Thus, the cover radius $\max_{t: B + t \subset Q} E(t)$ can be found in $O(n^2 k^8 + (n^2 k^6 + m) \log(n+m))$ time.

## 6. Complexity Summaries and Generalizations

All complexity results generalize to higher dimensions, with exponents $2 \to d$ for dimension $d$. For example, diagram construction entails $O(n^{2d}k^{2d})$ cells and $O(n^{2d}k^{2d+2})$ labeling time in $\mathbb{R}^d$.

| Problem Variant                  | Plane Complexity                                              |
|----------------------------------|--------------------------------------------------------------|
| Diagram cell count               | $O(n^2 k^6)$                                                 |
| Construction and labeling        | $O(n^2 k^8)$                                                 |
| Optimal translation/min $E(t)$   | $O(n^2 k^8)$                                                 |
| Min-bottleneck path              | $O(n^2 k^6 \log(nk))$                                        |
| Cover radius in convex $Q$       | $O(n^2 k^8 + (n^2 k^6 + m) \log(n+m))$                       |

These polynomial bounds are optimal in $n$, leveraging methods including Clarkson–Shor for $k$-level arrangements, Chan’s low-level construction techniques, classic bottleneck matching algorithms (Hopcroft–Karp; Gabow–Tarjan), and Dijkstra-style min-max algorithms.

## 7. Context, Applications, and Algorithmic Foundations

Bottleneck assignment with path costs finds application in geometric optimization, shape comparison, motion planning, and computer vision. Voronoi-type diagrams for bottleneck and lex-bottleneck matchings encode critical combinatorial structures. Efficient realization of arrangements and minimization paths relies on advanced geometric and graph algorithms. The approach described draws on core algorithmic tools:
- Clarkson–Shor framework for bounding arrangement complexity;
- Chan’s randomized algorithm for construction at low levels;
- Gabow–Tarjan and Hopcroft–Karp methods for bipartite bottleneck matchings;
- Standard graph algorithms for min-max path computation.

No nontrivial improvement in complexity is possible in $n$ for general cases, as the bounds are established as optimal [1405.0900].

Source: https://www.emergentmind.com/topics/bottleneck-assignment-with-path-costs