Shortest Non-Simple 1-Covering Path Problem

• The paper establishes that the 1-covering path problem redefines cost by charging for each covered element only once, despite allowing vertex revisits and self-crossings.
• Key formulations span edge-labeled graphs, vertex-colored walks, and geometric covering paths, each with tailored objectives and NP-hardness proofs.
• Geometric models show that permitting self-crossing can reduce link counts by a fixed amount, while structured grid formulations often yield near-optimal simple solutions.

“Shortest Non-Simple 1-Covering Path Problem” is best treated as an Editor’s term for a family of path-optimization problems in which a path, walk, or polygonal chain must cover each required object at least once, while repeated vertices, repeated states, or self-crossings are permitted. In the current literature, closely matching formalizations occur in at least four settings: edge-labeled shortest paths with one-time payment per label, vertex-colored walks that must hit every color, geometric covering paths for planar point sets and grids, and grid-routing models in which a path connects stops whose coverage neighborhoods 1-cover all required vertices (Träff, 2015, Bilge et al., 2015, Keszegh, 2013, Zeng et al., 2017).

1. Terminological scope and formalizations

The phrase combines three independent attributes: “shortest,” “non-simple,” and “1-covering.” The precise meaning of each attribute depends on the model. In graph-theoretic formulations, “non-simple” usually means that a feasible solution is a walk and may revisit vertices or edges. In geometric formulations, it usually means that the polygonal path may be self-crossing. “1-covering” may mean that every label or color is represented at least once, or that every demand point is visited or lies within the coverage radius of some stop on the path.

Formulation	Coverage unit	Objective
Edge information reuse shortest path	edge-information labels $f(e)$	minimize $\sum_{\ell \in L(U)} c(\ell)$
All Colors Shortest Path	vertex colors $\kappa(v)$	minimize walk length from base $s$
Covering path / covering trail	planar grid points or point sets	minimize number of segments, or Euclidean length under a minimum-link constraint
D-CPPG on a grid	vertices within radius $k$ of chosen stops	minimize path length $L$, stop count $T$, or both

This suggests that no single standard definition dominates the literature. Instead, the term names a recurring combinatorial theme: the cost depends on what is covered at least once, rather than on simple additive traversal alone. That shift is mathematically substantial, because it changes both feasible objects and objective structure.

2. Label-based graph formulations

A direct graph-theoretic realization appears in the edge information reuse shortest path problem. The input is a weighted, directed, acyclic graph $G=(V,E,w)$, source $s$, sink $t$, and a mapping $\sum_{\ell \in L(U)} c(\ell)$0 assigning an information label to each edge, with the constraint

$\sum_{\ell \in L(U)} c(\ell)$1

For a path $\sum_{\ell \in L(U)} c(\ell)$2, the reuse-aware length is defined by counting an edge’s weight only at the first occurrence of its label: $\sum_{\ell \in L(U)} c(\ell)$3 Because equal labels imply equal weights, this is equivalently

$\sum_{\ell \in L(U)} c(\ell)$4

where $\sum_{\ell \in L(U)} c(\ell)$5 (Träff, 2015).

This is a literal 1-covering cost over labels: each label is paid for once, regardless of how many times it appears on the path. Under this interpretation, a shortest 1-covering path is not additive over edges. The paper proves that the decision version is NP-complete by reduction from 3SAT, and the hardness already holds on a directed acyclic graph with nonnegative weights restricted to $\sum_{\ell \in L(U)} c(\ell)$6 (Träff, 2015).

The acyclicity assumption is important for terminology. The paper speaks of a simple $\sum_{\ell \in L(U)} c(\ell)$7-path, but on a DAG every directed path is automatically simple. The same source explicitly observes that, under the given assumptions, “simple” versus “non-simple” is irrelevant. A plausible implication is that allowing non-simple walks in a more general digraph does not remove hardness: the DAG instances remain valid special cases, so NP-hardness carries over.

The 3SAT reduction also clarifies how 1-covering semantics encode satisfiability. Variable gadgets force one weight-1 choice per variable, clause gadgets contribute zero precisely when they reuse a label already paid for in the variable layer, and a path of total reuse-aware cost $\sum_{\ell \in L(U)} c(\ell)$8 exists if and only if the formula with $\sum_{\ell \in L(U)} c(\ell)$9 variables is satisfiable (Träff, 2015). The same paper notes an alternate route through the minimum-color path problem: if $\kappa(v)$0 is the color map and all edge weights are 1, minimizing $\kappa(v)$1 is exactly minimizing the number of distinct colors used along a path.

3. Vertex-color covering and non-simple walks

A second, and more explicitly non-simple, formulation is the All Colors Shortest Path problem. Here the input is an undirected edge-weighted graph $\kappa(v)$2, a color set $\kappa(v)$3, a color map $\kappa(v)$4, and a designated base vertex $\kappa(v)$5. A feasible solution is a possibly non-simple walk

$\kappa(v)$6

such that every color in $\kappa(v)$7 occurs at least once on the walk, and the objective is to minimize

$\kappa(v)$8

The paper presents this as the first formal study of that model and emphasizes that allowing a node to be visited multiple times makes the problem computationally unique (Bilge et al., 2015).

Under a cluster or class interpretation of colors, ACSP is exactly a shortest non-simple 1-covering path problem on vertices: 1-covering means “at least one vertex from every color class,” and non-simple means revisits are allowed. The paper proves NP-hardness by reduction from Hamiltonian Path. It also establishes a strong inapproximability result: ACSP does not admit a constant-factor polynomial-time approximation unless $\kappa(v)$9 (Bilge et al., 2015).

The inapproximability proof passes through $s$0-GMST, also called CLASS TREE. For the same clustered instance, the paper proves the sandwich inequality

$s$1

where $s$2 denotes the ACSP instance with base $s$3. Thus ACSP is bounded below by the cost of a cluster-covering tree and above by a depth-first traversal of such a tree with no return to the root (Bilge et al., 2015). Structurally, this places shortest non-simple covering walks between Steiner-like tree constructions and path-based traversal costs.

The same paper proves a useful local property: in an optimal ACSP solution, no directed edge can be visited more than once in any given direction (Bilge et al., 2015). This does not eliminate backtracking, since both orientations may still appear, but it sharply constrains repetition. The paper also gives a compact flow-based ILP with binary edge-use variables $s$4, node-visit variables $s$5, and connectivity flow variables $s$6, together with LP-relaxation-based heuristics and metaheuristics based on simulated annealing, ant colony optimization, and genetic algorithm (Bilge et al., 2015).

4. Geometric covering paths and self-crossing chains

In geometric formulations, the covered objects are planar points rather than labels or colors. A covering path is a polygonal path whose straight segments visit all points of a set; Steiner points are allowed, and self-crossings may or may not be forbidden. Here the dominant objective in the cited literature is usually the number of segments rather than Euclidean length.

For point sets in general position, the fundamental lower bound is $s$7 segments, since a segment can contain at most two points. The sharp asymptotic upper bound for possibly self-crossing covering paths is

$s$8

while for noncrossing covering paths the paper proves the upper bound

$s$9

and exhibits point sets requiring at least

$k$0

segments in every such path (Dumitrescu et al., 2013). This establishes that self-crossing and noncrossing covering paths differ asymptotically in segment complexity.

For planar grids, the geometry becomes more rigid. On an $k$1 grid, the minimum number of segments of a possibly self-crossing covering path is

$k$2

and

$k$3

By contrast, the minimum number of segments of a noncrossing covering path is always

$k$4

The same formulas hold for covering trees when edges, rather than merged collinear segments, are counted (Keszegh, 2013). The exact gain from allowing self-crossings is therefore only one segment, and only for square grids of size at least $k$5.

That one-segment gap is realized by explicit self-crossing constructions. For square grids $k$6 with $k$7, the paper describes axis-aligned spiral coverings generalizing the classical $k$8 “9-dots” construction (Keszegh, 2013). A plausible implication is that non-simplicity is highly model-dependent: in general point sets it supports a substantial reduction in link complexity, but on rectangular grids it yields only a constant additive improvement.

5. Square-grid minimum-link trails and Euclidean length

A more refined square-grid study distinguishes link minimization from total Euclidean length. For

$k$9

the paper defines covering paths, trails, circuits, and cycles as polygonal chains in $L$0 with straight edges, no repeated edges, and possible Steiner points; self-crossing is allowed (Ripà, 2022).

The primary combinatorial result is that, for $L$1, the minimum-link covering trail has exactly

$L$2

edges. Moreover, for every $L$3 there exists a covering path $L$4 with

$L$5

and for every even $L$6 there exists a covering cycle $L$7 with

$L$8

The constructions are explicit and are based on a bottom triangular spiral, a top triangular spiral, and a connecting segment between the unique uncovered middle points of those spirals (Ripà, 2022).

The same paper then asks for the minimum total Euclidean length among all minimum-link covering trails. It proves the bounds

$L$9

and for $T$0 sharpens the lower bound to a strict inequality on the left (Ripà, 2022). The gap between the two bounds is

$T$1

a constant independent of $T$2. This does not solve the unconstrained shortest covering path problem, because the link count is fixed first, but it shows that minimum-link non-simple coverings on square grids can be made Euclidean-near-optimal up to a small additive constant.

6. Radius-1 coverage on grid graphs

A different notion of 1-covering appears in the covering path problem on a grid. Here the grid is a graph

$T$3

with Manhattan metric. One chooses a subset of stops $T$4 and a path $T$5 connecting them so that every required point lies within distance $T$6 of some stop. In the discrete version D-CPPG, the demand set is all grid vertices, so the coverage constraints are

$T$7

For the length-only objective, the paper studies minimization of

$T$8

with $T$9 on grid edges (Zeng et al., 2017).

For the special case $G=(V,E,w)$0, this is a direct grid-graph realization of a shortest 1-covering path problem: every vertex must be within $G=(V,E,w)$1-distance 1 of some stop on the chosen path. The paper states that non-simplicity is allowed, but because edge costs are positive, useless cycles can be removed; the structured optimal constructions are serpentine and effectively simple (Zeng et al., 2017).

The central asymptotic result for the pure-length objective is

$G=(V,E,w)$2

Substituting $G=(V,E,w)$3 yields

$G=(V,E,w)$4

This bound is achieved, up to the $G=(V,E,w)$5 term, by a type-1 discrete up-and-down path: traversals are spaced every $G=(V,E,w)$6 columns, stops are placed at every grid vertex on each traversal, and the traversals are connected in an up-and-down pattern (Zeng et al., 2017). In this model, non-simple feasibility does not improve the optimum, because every repeated edge or cycle only increases $G=(V,E,w)$7.

7. Structural themes, difficulty, and recurring misconceptions

Across these formulations, the shortest non-simple 1-covering path problem is not a single complexity class but a family of related problems whose difficulty is driven by the meaning of “covering.” In edge-information reuse, the objective is additive over labels rather than over traversals, and classical shortest-path recurrences fail; the problem is NP-complete even on DAGs with $G=(V,E,w)$8 weights (Träff, 2015). In ACSP, coverage is over color classes, non-simplicity is intrinsic, and the problem is NP-hard with no constant-factor approximation unless $G=(V,E,w)$9 (Bilge et al., 2015). In planar covering-path models, the dominant cost is often the number of links, and self-crossings may or may not help depending on the geometry (Dumitrescu et al., 2013, Keszegh, 2013). In D-CPPG, 1-covering is metric rather than combinatorial, and positive edge lengths suppress any advantage of repeated traversal (Zeng et al., 2017).

A common misconception is that “non-simple” always changes the optimum substantially. The cited results show the opposite. In a DAG-based label-reuse model, the issue disappears because every directed path is already simple (Träff, 2015). In D-CPPG, non-simple walks are allowed but unnecessary in optimal length minimization (Zeng et al., 2017). In geometric segment-count problems on square grids, self-crossing helps by exactly one segment and only in the case $s$0 (Keszegh, 2013). By contrast, in ACSP the permission to revisit vertices is part of the formal identity of the problem and one source of its distinctive hardness profile (Bilge et al., 2015).

A second misconception is that all “covering path” problems are shortest-path variants in the classical additive sense. The label-reuse formulation makes the failure explicit: the cost of using an edge depends on path history, namely on whether its label has already appeared (Träff, 2015). This suggests why Dijkstra-style local relaxation is inapplicable, and why reductions from SAT, Hamiltonian Path, and cluster-covering tree problems arise so naturally.

Taken together, these results define a coherent research area rather than a single standardized problem name. The unifying object is a path-like structure that must cover each required entity once, while the decisive technical questions are what is being covered, how coverage is certified, whether self-intersection or revisitation is useful, and whether the objective is traversal length, number of links, or a one-time cost over covered classes.