DP-IRC: Dynamic Programming Integrated Routing Cost

• DP-IRC is a dynamic programming framework that integrates routing costs into a state-transition system for multi-stage network optimization.
• It leverages Bellman recursions and pseudo-polynomial arc-flow models to embed resource constraints and achieve tight linear relaxations.
• The method significantly improves scalability and decision quality in applications ranging from LEO constellation routing to stochastic vehicle routing.

Searching arXiv for the cited papers and related DP-routing work. Dynamic Programming-based Integrated Routing Cost (DP-IRC) denotes routing formulations in which a dynamic program is endowed with an integrated cost that aggregates the application’s routing-relevant terms, and the resulting Bellman recursion is solved directly, through an equivalent arc-flow model, or through batched min-plus kernels. In one explicit instantiation, DP-IRC is the named algorithm for inter-shell routing in low Earth orbit mega-constellation networks, where the integrated routing cost is $$\mathrm{IRC}(P_t,P_{t-1})=\alpha H(P_t)+\beta \Delta_{\mathrm{ISL}}(P_t,P_{t-1})$$ (Wang et al., 11 Jul 2025). In broader optimization settings, the same phrase is used to describe scenario-integrated second-stage routing costs in stochastic vehicle routing and integrated reduced-cost pricing in deterministic IP routing and scheduling (Zhao et al., 5 Feb 2026, Krolikowski et al., 2020). The common theoretical substrate is the equivalence between dynamic programming and pseudo-polynomial arc-flow networks, in which states become nodes, feasible decisions become arcs, and the optimal value is a shortest- or longest-path value on a directed acyclic graph (Lima et al., 2020).

1. Dynamic-programming and arc-flow foundations

The foundational construction is the dynamic-programming recurrence

$$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$

where $S$ is the state space, $s_0$ is the initial state, $s^*$ is the terminal state, $A(s)$ is the set of feasible decisions, and $T(s,a)$ is the transition mapping. This recurrence is equivalent to a shortest path in a directed acyclic graph whose nodes are states and whose arcs are feasible decisions. Formally, the DP network is $N=(V,E,c)$ with $V=S$, $v_{\text{source}}\equiv s_0$, $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$0, and

$$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$1

The corresponding single-commodity arc-flow model minimizes $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$2 subject to flow conservation

$$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$3

with $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$4, $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$5, and $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$6 otherwise; for a pure DP subproblem, $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$7 and $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$8 (Lima et al., 2020).

Within this framework, pseudo-polynomial arc-flow models are distinguished from compact polynomial formulations by their stronger linear relaxations and lower symmetry. Enriching the state space with resource layers such as time, capacity, or duty turns resource feasibility into network structure rather than weak side constraints. The survey literature links this effect to Dantzig–Wolfe decomposition: path-based models remain strong but exponential, whereas pseudo-polynomial arc-flow models encode much of the pricing network explicitly and often remain directly solvable by MILP for practical instance sizes. The same line of work also gives a dual explanation: the dual of an arc-flow model contains one dual constraint per arc, strengthened by node potentials, whereas path-based duals contain one constraint per path. This yields a tighter dual feasible region and, according to the survey, improved simplex convergence (Lima et al., 2020).

State-space relaxation is the principal device for keeping the network tractable. Exact visited-set states can make the network exponential, but aggregations such as $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$9 yield layered graphs of size $S$0 nodes and $S$1 arcs. This preserves a strong relaxation while allowing non-elementary paths; feasibility is then recovered through customer-visit constraints or analogous side constraints (Lima et al., 2020).

2. Integrated cost construction and state-space design

The integrated cost in DP-IRC is application-specific but always additive along transitions once the state has been chosen correctly. In routing with resources, a typical state is

$S$2

where $S$3 is the current node, $S$4 is the load on board, $S$5 is arrival time, $S$6 is accumulated duty or service time, and $S$7 is cumulative distance. A transition to customer $S$8 updates the resources by

$S$9

subject to conditions such as $s_0$0, $s_0$1, $s_0$2, and $s_0$3. The associated arc cost may integrate distance, travel time, service time, waiting, overtime, soft time-window penalties, fuel, and emissions:

$s_0$4

Layered graph variants encode these updates implicitly in node definitions and thereby avoid big-$s_0$5 propagation constraints (Lima et al., 2020).

In two-stage stochastic routing, the same additive principle appears at the level of recourse costs. For a fixed first-stage sequence $s_0$6, the integrated routing cost is

$s_0$7

where each scenario-specific cost is the optimal value of a second-stage integer DP. In the split formulation for a giant tour, the state is the covered prefix length and the transition cost is the cost of turning a contiguous segment into one route under scenario $s_0$8 (Zhao et al., 5 Feb 2026).

In the LEO inter-shell setting, the state is the selected inter-shell transfer point at each time slot, and the integrated routing cost is explicitly

$s_0$9

Here $s^*$0 measures current path efficiency through hop counts, while $s^*$1 penalizes inter-slot instability through changes in hop components across shells (Wang et al., 11 Jul 2025).

In deterministic IP routing and scheduling with CSQF, the integrated cost arises as the reduced cost of a scheduled path column. For a candidate scheduled path $s^*$2 of flow $s^*$3, the DP-IRC interpretation is

$s^*$4

or, on the extended graph, $s^*$5. This combines route choice, cycle assignment, and congestion prices in one dynamic-programming objective (Krolikowski et al., 2020).

Taken together, these formulations suggest that DP-IRC is best understood not as one fixed objective, but as a dynamic-programming pattern in which the state is expanded until the target routing cost becomes additive.

3. Sample-average approximation and split recursions

In the stochastic vehicle-routing literature, DP-IRC is tied to sample-average approximation (SAA). The first-stage decision is a routing chromosome or giant tour $s^*$6, and the second-stage recourse cost $s^*$7 is the optimal cost of adapting that sequence to realized scenario data. The SAA objective is

$s^*$8

or, in the CVRPSD notation,

$s^*$9

The split DP computes the scenario-conditioned recourse exactly by selecting route breaks along the sequence (Zhao et al., 5 Feb 2026, Zhao et al., 22 Nov 2025).

For a scenario $A(s)$0, the route-segment cost for serving customers $A(s)$1 through $A(s)$2 in one route is

$A(s)$3

with feasibility condition

$A(s)$4

The masked segment cost is

$A(s)$5

The Bellman recursion is

$A(s)$6

This is the classical split operator: each transition chooses the last cut before position $A(s)$7 (Zhao et al., 5 Feb 2026).

A later formulation makes the capacity logic explicitly vectorized by precomputing the earliest feasible split point

$A(s)$8

so that the recursion becomes

$A(s)$9

By turning feasibility into an interval bound, the update becomes a masked min-plus reduction and avoids on-the-fly branching (Zhao et al., 22 Nov 2025).

The same min-plus structure extends beyond the split operator. In dynamic stochastic inventory routing, the Bellman update is written over inventory states,

$T(s,a)$0

with route options minimized inside $T(s,a)$1. This shows that the DP-IRC viewpoint is not confined to route partitioning, but applies whenever scenario-conditioned recourse can be written as a layered forward DP (Zhao et al., 5 Feb 2026).

4. GPU reformulation and high-throughput Bellman updates

A major recent development is the reformulation of forward DP recursions as GPU kernels. The core idea is to express Bellman updates as batched min-plus matrix-vector products over layered DAGs, then exploit parallelism across scenarios, DP layers, and transition options. In the split operator, one parallel axis indexes scenarios and the other indexes predecessors $T(s,a)$2 for a fixed destination $T(s,a)$3. In richer inventory-routing recursions, a third axis indexes route options or inventory transitions (Zhao et al., 5 Feb 2026, Zhao et al., 22 Nov 2025).

For the split DP, the scenario-batched tensors are typically organized as $T(s,a)$4 for masked transition costs and $T(s,a)$5 for DP values. Infeasible transitions are encoded by $T(s,a)$6, allowing numerically safe masked reductions without branch divergence. A conceptual update at layer $T(s,a)$7 evaluates

$T(s,a)$8

for all scenarios $T(s,a)$9 in parallel, with warp-level intrinsics and shared memory used for the reduction. After the terminal layer, the integrated routing cost is obtained by a parallel reduction over terminal values,

$N=(V,E,c)$0

The resulting implementation performs the entire SAA evaluation in one batched pass (Zhao et al., 5 Feb 2026).

The reported scale is substantially larger than CPU-oriented scenario-based DP. One implementation evaluates more than $N=(V,E,c)$1 realizations in a single GPU pass and scales nearly linearly in the number of scenarios (Zhao et al., 5 Feb 2026). For CVRPSD split, the GPU runtime at $N=(V,E,c)$2 scenarios remained in seconds, with about $N=(V,E,c)$3 speedup versus a single-thread CPU and about $N=(V,E,c)$4 versus an 8-thread CPU; for dynamic stochastic inventory reinsertion, reported improvements reach $N=(V,E,c)$5 versus a single-thread CPU and $N=(V,E,c)$6 versus a multi-thread CPU (Zhao et al., 5 Feb 2026). A related implementation reports near-linear scaling in the scenario count, two- to three-dimensional GPU parallelism, and peak speedups of up to $N=(V,E,c)$7 versus a multithreaded CPU, with $N=(V,E,c)$8 scenarios processed in seconds on a single RTX 2080 Ti (11 GB) (Zhao et al., 22 Nov 2025).

These results directly affect the quality of stochastic first-stage decisions. The papers state that larger scenario sets reduce bias and improve SAA estimates, and that higher DP-IRC throughput permits evaluating many more first-stage candidates under fixed time budgets, yielding stronger first-stage solutions (Zhao et al., 5 Feb 2026, Zhao et al., 22 Nov 2025).

5. DP-IRC as an inter-shell routing algorithm in LEO networks

In LEO mega-constellation networks, DP-IRC is the explicit name of a multistage routing algorithm for stabilizing inter-shell paths under dynamic topologies. The setting consists of multiple orbital shells, a time-slotted topology, and inter-shell transfers mediated by ground stations that simultaneously maintain one active GSL to each shell. For a candidate path $N=(V,E,c)$9 at time $V=S$0, the total intra-shell hop count is

$V=S$1

where

$V=S$2

The switching term between consecutive paths is

$V=S$3

and the normalized inter-slot switching rate is

$V=S$4

The integrated routing cost is

$V=S$5

with initialization $V=S$6 (Wang et al., 11 Jul 2025).

The dynamic program is defined over time slots $V=S$7. The state at stage $V=S$8 is the selected inter-shell transfer point, represented by a feasible ground station. Let $V=S$9 denote the candidate path through ground station $v_{\text{source}}\equiv s_0$0 at time $v_{\text{source}}\equiv s_0$1. The Bellman recursion is

$v_{\text{source}}\equiv s_0$2

$v_{\text{source}}\equiv s_0$3

Backtracking over recorded predecessors yields the optimal sequence of transfer points over the horizon. Because candidate sets are restricted to ground stations with valid dual-shell GSLs, the complexity is $v_{\text{source}}\equiv s_0$4 time and $v_{\text{source}}\equiv s_0$5 space; with $v_{\text{source}}\equiv s_0$6 and $v_{\text{source}}\equiv s_0$7, the paper states that this is tractable in real time (Wang et al., 11 Jul 2025).

The reported experiments use Starlink shell 1 with $v_{\text{source}}\equiv s_0$8, $v_{\text{source}}\equiv s_0$9, OneWeb primary shell with $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$00, $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$01, 165 ground stations, and 60 time slots with 5-minute GSL updates. The average ISL switching rates are 0.74249 for DP-IRC, 0.95233 for APR, and 1.21962 for the Minimum Hop Path set strategy. The cumulative end-to-end distances are 16.19672 for DP-IRC, 14.49180 for MHP, and 17.39344 for APR. The paper therefore reports a 39.1% reduction in switching versus MHP and a 22.0% reduction versus APR, while maintaining near-optimal end-to-end path distances (Wang et al., 11 Jul 2025).

This formulation also clarifies a common contrast in the LEO routing literature. MHP minimizes current-slot hop counts only, while APR enforces a 60% path-similarity threshold but remains greedy and can revert to shortest paths when the threshold is unmet. DP-IRC differs by coupling consecutive decisions explicitly in the Bellman recursion, so stability is optimized globally over the planning horizon rather than through a local similarity heuristic (Wang et al., 11 Jul 2025).

6. Extensions to deterministic routing, scheduling, and exact combinatorial optimization

In large-scale deterministic IP networks with CSQF and segment routing, dynamic programming appears inside column generation. The master problem selects feasible scheduled paths, while the pricing problem is a resource-constrained shortest path on an extended graph with nodes $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$02 for node-cycle pairs. The arc weight for flow $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$03 on physical link $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$04 at cycle $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$05 is

$$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$06

and the DP state is $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$07, where $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$08 is accumulated delay in cycles. The reduced cost of a scheduled path is

$$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$09

which the synthesis explicitly interprets as a DP-IRC. Negative reduced cost identifies a profitable column. On realistic instances, the paper reports an optimality gap smaller than 10% in a few seconds for the column-generation-plus-randomized-rounding approach, while an adaptive greedy algorithm runs in about $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$10 per demand with an additional gap of about 5% versus CG-RR (Krolikowski et al., 2020).

A distinct but related exact combinatorial line concerns the Delay Constrained Unsplittable Shortest Path Routing problem. There, the integrated routing objective is to minimize maximum congestion while choosing administrative weights that induce unique shortest paths and satisfy end-to-end delay bounds. The dynamic program is built on a tree decomposition and uses states $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$11, where $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$12 is a routing contract summarizing the partial routing structure in the current subtree and $$f(s)=\min_{a\in A(s)}\{c(a)+f(T(s,a))\}, \qquad f(s^*)=0,$$13 is a delay contract recording accumulated delay per commodity. The DP combines structural feasibility under unique-shortest-path semantics, per-commodity delay accumulation, and congestion minimization, and the paper states that the resulting algorithm is fixed-parameter tractable in the treewidth and the number of demands (Benhamiche et al., 2020).

These deterministic-network formulations broaden the meaning of DP-IRC. In one case, the integrated cost is a reduced cost over route-cycle usage priced by dual congestion multipliers; in the other, it is a combinatorial state summary that jointly carries routing structure, delay resources, and congestion. This suggests a unifying interpretation: DP-IRC is the practice of embedding all routing-relevant costs and feasibility resources into a dynamic-programming state-transition system until the optimization can be written as Bellman updates, shortest paths on layered DAGs, or equivalent arc-flow models.