An Improved Quality Hierarchical Congestion Approximator in Near-Linear Time

A single-commodity congestion approximator for a graph is a compact data structure that approximately predicts the edge congestion required to route any set of single-commodity flow demands in a network. A hierarchical congestion approximator (HCA) consists of a laminar family of cuts in the graph and has numerous applications in approximating cut and flow problems in graphs, designing efficient routing schemes, and managing distributed networks. There is a tradeoff between the running time for computing an HCA and its approximation quality. The best polynomial-time construction in an $n$-node graph gives an HCA with approximation quality $O(\log^{1.5}n \log \log n)$. Among near-linear time algorithms, the best previous result achieves approximation quality $O(\log^4 n)$. We improve upon the latter result by giving the first near-linear time algorithm for computing an HCA with approximation quality $O(\log^2 n \log \log n)$. Additionally, our algorithm can be implemented in the parallel setting with polylogarithmic span and near-linear work, achieving the same approximation quality. This improves upon the best previous such algorithm, which has an $O(\log^9n)$ approximation quality. We also present a lower bound of $Ω(\log n)$ for the approximation guarantee of hierarchical congestion approximators. Crucial for achieving a near-linear running time is a new partitioning routine that, unlike previous such routines, manages to avoid recursing on large subgraphs. To achieve the improved approximation quality, we introduce the new concept of border routability of a cut and provide an improved sparsest cut oracle for general vertex weights.

💡 Research Summary

The paper addresses the construction of hierarchical congestion approximators (HCAs), compact data structures that capture the cut‑structure of an undirected graph and can be used to estimate the edge congestion required to route any single‑commodity demand vector. An HCA is a laminar family of cuts; equivalently it can be viewed as a tree cut sparsifier. Prior work showed that an HCA with approximation quality O(log¹·⁵ n log log n) can be built in polynomial time, while the best near‑linear‑time construction achieved only O(log⁴ n) quality. This gap is significant for large‑scale applications where both speed and approximation quality matter.

The authors present a new algorithm that, in Õ(m) time (near‑linear in the number of edges), constructs an HCA with approximation factor O(log² n log log n) for single‑commodity flows. By the flow‑cut gap λ = O(log n), this immediately yields a multi‑commodity HCA with factor O(log³ n log log n). The algorithm also parallelizes efficiently: it runs in O(m polylog n) work with O(polylog n) span, achieving the same approximation guarantee. This improves on the previous best parallel result (O(log⁹ n) quality) by a large margin.

Two technical innovations enable these improvements:

1. A new partitioning routine that avoids recursion on large subgraphs.
   Traditional near‑linear‑time HCA constructions recursively partition the graph, and each recursive call can still contain a large fraction of the vertices, leading to an extra logarithmic factor in the approximation. The new routine first decomposes the graph into small “blocks” (clusters of bounded size) using a fast sparsifier‑based technique, then processes each block independently. The key notion introduced is border routability: for a cut C, the capacity crossing the boundary of C must be sufficient to support the demand that would be routed across C. By explicitly checking border routability, the algorithm can safely discard large portions of the graph without losing approximation quality, thereby eliminating the extra log factor.

2. An improved sparsest‑cut oracle for arbitrary vertex weights.
   Existing sparsest‑cut approximators assume uniform vertex weights or work only on edge‑weighted graphs. The authors extend the cut‑matching game framework (originally due to Khandekar‑Rao‑Vazirani) to handle general vertex weight functions. They design a game between a “cut player” and a “matching player” that converges to an O(log n)‑approximate sparsest cut in linear time with respect to the number of edges. The subroutines FairCutFlow and TwoWayTrim are used to balance flow across the cut and to prune unnecessary edges, respectively. This oracle is invoked repeatedly during the block construction and partitioning phases, and its linear‑time guarantee is crucial for the overall near‑linear running time.

The algorithm proceeds in four high‑level stages:

• Building Blocks. The graph is partitioned into a collection of small blocks. For each block the algorithm computes a local routing structure (a set of cuts that approximate congestion within the block). This step uses the new sparsest‑cut oracle and runs in Õ(m) time.

• Constructing the Congestion Approximator. The block‑level structures are combined hierarchically. At each level the algorithm merges adjacent blocks, checks border routability, and adds the corresponding cut to the laminar family. Because the blocks are small, the number of levels is O(log n), and the approximation factor incurred at each level multiplies to O(log² n log log n).

• Partitioning a Cluster. When a cluster becomes too large, the new partitioning routine is applied. It uses FairCutFlow to find a balanced cut and TwoWayTrim to trim away low‑capacity edges, guaranteeing that the remaining subclusters satisfy the border‑routability condition. This step prevents deep recursion on large subgraphs and is the main source of the improved approximation bound.

• Parallel Implementation. Each of the above components is parallelized. The cut‑matching game is executed in parallel using a PRAM model; the sparsest‑cut oracle runs with O(m polylog n) work and O(polylog n) depth. Consequently the whole HCA construction inherits these bounds.

In addition to the algorithmic contributions, the paper proves a lower bound of Ω(log n) on the approximation factor achievable by any hierarchical congestion approximator. The proof reduces from the known lower bound for oblivious routing: any oblivious routing scheme incurs an Ω(log n) congestion blow‑up on some demand, and a hierarchical congestion approximator can be turned into an oblivious routing scheme with comparable performance. Hence the authors’ O(log² n log log n) result is within a polylogarithmic factor of the optimal possible for HCAs.

The paper includes a comprehensive comparison table (Table 1) that lists prior results for both single‑commodity and multi‑commodity settings, their running times, and approximation guarantees. The new result matches the best known polynomial‑time guarantee (up to a log log n factor) while running in near‑linear time, and it simultaneously improves the parallel state‑of‑the‑art from O(log⁹ n) to O(log² n log log n).

Overall, the work makes a substantial step forward in the theory of graph congestion approximation. By introducing border routability, a novel block‑based partitioning scheme, and a generalized sparsest‑cut oracle, the authors achieve near‑linear time construction of high‑quality hierarchical congestion approximators, both sequentially and in parallel. This advancement opens the door to faster algorithms for a host of downstream problems—such as oblivious routing, expander decompositions, and dynamic network design—where HCAs serve as a fundamental building block.