Constrain Path Optimization on Time-Dependent Road Networks

TL;DR

This paper introduces SCOPE, a novel algorithm for time-dependent constrained path optimization that significantly improves solution quality and parallel scalability in urban navigation scenarios.

Contribution

SCOPE exploits spatial and temporal properties of road networks to efficiently solve the NP-hard TD-CPO problem with near-linear parallel speedup.

Findings

SCOPE achieves nearly 2x better solution quality than existing algorithms.

SCOPE's parallel implementation scales almost linearly up to 24 CPUs.

The approach effectively balances solution quality and computational efficiency.

Abstract

Time-Dependent Constrained Path Optimization (TD-CPO) takes the following input: (i) time-dependent (TD) road network, (ii) source ($s$), (iii) destination ($d$), (iv) departure time ($t$) and, (v) budget ($\mathcal{B}$). In TD graph, each edge is characterized by a time-dependent arrival time and a score function. TD-CPO aims to determine a loopless path $s$--$d$ departing from $s$ at time $t$ and arriving at $d$ on or before $t+\mathcal{B}$ while maximizing the score. TD-CPO has applications in urban navigation. TD-CPO is a variant of the Arc Orienteering Problem (AOP) known to be NP-hard in nature. The key computational challenge of TD-CPO is that we need to find the "longest path" in terms of score within the given budget constraint in a TD graph. Current works prune down the search space very aggressively. Thus, despite having low execution time, these algorithms often produce low-quality solutions. In contrast, our proposed approach $\mathcal{SCOPE}$ efficiently solves TD-CPO by exploiting road networks' spatial and temporal properties. The inherent computational structure of $\mathcal{SCOPE}$ enables trivial parallelization for improved performance. Our experiments indicate that $\mathcal{SCOPE}$ produces superior quality solutions (nearly $2x$) compared to the state-of-the-art algorithm while having comparable running times. Furthermore, $\mathcal{SCOPE}$ exhibits almost linear speedup as the number of CPUs (cores) increases (up to 24 CPUs).