Parametric Shortest Paths in a Linearly Interpolated Graph

Abstract: We consider the parametric shortest paths problem in a linearly interpolated graph. Given two positively-weighted directed graphs $G_0=(V,E,ω_0)$ and $G_1=(V,E,ω_1),$ the linearly interpolated graph is the family of graphs $(1-λ)G_0+λG_1$, parameterized by $λ\in [0,1]$. The problem is to compute all distinct parametric shortest paths. We compute a data structure in $Θ(k|E|\log |V|)$ time, where~$k$ is the number of distinct parametric shortest paths over all~$λ\in [0,1]$ that exist for a nontrivial interval of parameters, each corresponding to a linear function in a maximal sub-interval of $[0,1]$. Using this data structure, a shortest path query takes~$Θ(\log k)$ time.

• The paper introduces a divide-and-conquer algorithm that recursively computes all distinct parametric s–t shortest paths as the interpolation parameter varies.
• It leverages modified Dijkstra procedures to efficiently detect breakpoint intersections among linear path cost functions, ensuring rapid queries.
• The method improves on prior approaches by minimizing redundant computations and achieving output-sensitive performance even under varying graph weights.

Parametric Shortest Paths in Linearly Interpolated Graphs: A Formal Analysis

Problem Formulation and Motivation

This work formalizes and solves the parametric shortest paths problem within the context of linearly interpolated edge weights between two positively-weighted directed graphs sharing the same topology. Given $G_0 = (V, E, \omega_0)$ and $G_1 = (V, E, \omega_1)$, the edge weights in $G_\lambda$ are defined as $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$ for $\lambda \in [0, 1]$. The core objective is to compute all parametric $s$–$t$ shortest paths as $\lambda$ varies, parameterizing the evolution of optimal paths in terms of $\lambda$.

The fundamental observation underpinning this approach is that the cost of any given path $P$ in $G_1 = (V, E, \omega_1)$0 is a linear function of $G_1 = (V, E, \omega_1)$1. Thus, for fixed endpoints, the family of candidate paths induces a finite arrangement of lines. The parametric shortest path value for a given $G_1 = (V, E, \omega_1)$2 is the lower envelope of these cost lines. Breakpoints in this envelope correspond to values of $G_1 = (V, E, \omega_1)$3 at which the identity of the shortest path changes.

Figure 1: The base graphs $G_1 = (V, E, \omega_1)$4 and $G_1 = (V, E, \omega_1)$5 and the corresponding parametric path lengths across $G_1 = (V, E, \omega_1)$6 under interpolation.

Algorithmic Contributions

The primary contribution is a recursive, divide-and-conquer algorithm that efficiently computes the set of all distinct, nontrivial parametric shortest paths between two vertices as $G_1 = (V, E, \omega_1)$7 progresses through $G_1 = (V, E, \omega_1)$8. This method constructs a data structure—an ordered list of disjoint intervals $G_1 = (V, E, \omega_1)$9, each paired with a corresponding shortest path over that sub-interval.

At each recursive step, the algorithm determines whether the shortest paths at two interval endpoints $G_\lambda$0 and $G_\lambda$1 remain optimal across $G_\lambda$2. If so, a single representative path suffices for the interval (via Theorem~\ref{thm:samesp}). Otherwise, the intersection point $G_\lambda$3 of the cost functions for each endpoint's path is identified; here, path optimality may transition, requiring further refinement.

For each discovered breakpoint, modified Dijkstra procedures identify shortest paths that respectively minimize and maximize the cost function slope, efficiently extending the lower envelope only where strictly necessary. Notably, the algorithm only computes paths lying on the actual lower envelope, bypassing the need to enumerate all possible paths.

Figure 2: Before recursion, $G_\lambda$4 and $G_\lambda$5 intersect at $G_\lambda$6, determining a candidate breakpoint for the partitioning of intervals.

Central to this approach is the augmentation of Dijkstra's algorithm so that among ties for equal path length, the slope (as a function of $G_\lambda$7) is minimized or maximized. This modification enables lex minimization (or maximization) over $G_\lambda$8 tuples for each vertex, where $G_\lambda$9 is current path cost and $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$0 is slope.

The overall runtime is $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$1, where $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$2 is the number of breakpoints (i.e., intervals where the shortest path changes). Each path-discriminating event incurs a further Dijkstra computation, and the interval tree construction underpins efficient subsequent queries.

Comparison to Prior Work

Earlier approaches, notably Karp and Orlin [karp1981parametric], compute shortest path trees for each critical $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$3, updating these trees as breakpoints are encountered. These methods require $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$4 time and do not provide an efficient means to return the actual shortest path for a given $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$5—only its cost can be rapidly queried, as the tree traversal remains necessary.

Other works have improved preprocessing time for related parametric path and minimum spanning tree problems, usually via advanced heap or dynamic tree methods [young1991faster, PAgarwal, DEppstein]. However, these either address different parametric models (such as arbitrary real $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$6) or minimize other graph objectives.

A notable assertion in this paper is that, for the defined model (edges varying linearly between $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$7 and $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$8), the total number of relevant shortest path intervals (i.e., $$\omega_\lambda = (1-\lambda)\omega_0 + \lambda\omega_1$$9) is minimal in the sense that only genuinely necessary breakpoints are computed, and the query time to report both the cost and the explicit path for any $\lambda \in [0, 1]$0 is $\lambda \in [0, 1]$1 (where $\lambda \in [0, 1]$2 is the length of the returned path). This is a substantial improvement over earlier methods which often have query times dependent on $\lambda \in [0, 1]$3 due to path reconstruction.

Strong Numerical and Theoretical Results

• Algorithmic Complexity: The authors achieve a running time of $\lambda \in [0, 1]$4 for preprocessing. While $\lambda \in [0, 1]$5 can be super-polynomial in $\lambda \in [0, 1]$6 even for planar graphs [gajjar2019lowerbound], the algorithm is output-sensitive and optimal with respect to the number of true lower envelope breakpoints.
• Query Efficiency: A shortest path for a given $\lambda \in [0, 1]$7 can be retrieved in logarithmic time with respect to the number of breakpoints (plus path length), a substantial practical advantage for real-time or repeated query use cases.
• Correctness (Bold Claim): If the shortest path is identical at both $\lambda \in [0, 1]$8 and $\lambda \in [0, 1]$9, it remains so for all $s$0, obviating further computation—theoretical completeness is established via Theorem~\ref{thm:samesp}.

Practical and Theoretical Implications

Practically, this development enables efficient analysis of systems where edge costs interpolate as a function of a continuous external parameter—scenarios common in network design, sensitivity analysis, and kinetic data structures. Because the data structure supports rapid computation of explicit paths, it is well-suited for interactive applications or design tools in which path structure (rather than merely cost) is of interest.

Theoretically, this formalism refines understanding of the combinatorial and algorithmic complexity induced by parameterized optimization over linearly varying structures, elucidating the boundary between tractable preprocessing and potentially exponential $s$1. The divide-and-conquer paradigm for isolating only "breakpoint" paths may inspire analogous sparsification techniques for more complex parametric or kinetic graph optimization tasks.

Future Directions

Open questions remain regarding the asymptotic behavior of $s$2 in specific classes of graphs and whether further improvements in preprocessing or update time are attainable under additional structural assumptions (planarity, sparsity, etc.). Extensions to polynomial or piecewise-linear interpolation, higher-dimensional parameter spaces, or related problems like parametric flows or matchings present natural future research avenues.

Developing data structures that maintain rapid query access under incremental changes to $s$3 or $s$4—or that handle edge insertions and deletions—would also significantly expand the practical utility of this approach in dynamic or time-evolving networks.

Conclusion

This paper presents an efficient, output-sensitive algorithm and data structure for enumerating and querying parametric $s$5–$s$6 shortest paths in a linearly interpolated directed graph. By leveraging the geometric structure of linear path cost variation and augmenting core shortest path routines, the authors establish both theoretical guarantees and practical superiority over canonical parametric optimization algorithms for this class of problems. The work has both immediate algorithmic relevance and lays groundwork for advances in dynamic and parametric network optimization.