Merge pull request #31 from BatyLeo/better-topological-order

Improve topological order robustness

Author: BatyLeo

CITATION.bib

@@ -2,7 +2,7 @@ @misc{ConstrainedShortestPaths.jl
 	author  = {Léo Baty and contributors},
 	title   = {ConstrainedShortestPaths.jl},
 	url     = {https://github.com/BatyLeo/ConstrainedShortestPaths.jl},
-	version = {v0.6.3},
-	year    = {2024},
-	month   = {12}
+	version = {v0.6.4},
+	year    = {2025},
+	month   = {03}
 }

Project.toml

@@ -1,7 +1,7 @@
 name = "ConstrainedShortestPaths"
 uuid = "b3798467-87dc-4d99-943d-35a1bd39e395"
 authors = ["Léo Baty and contributors"]
-version = "0.6.3"
+version = "0.6.4"
 
 [deps]
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"

src/ConstrainedShortestPaths.jl

@@ -12,6 +12,7 @@ using Graphs:
     dst,
     edges,
     outneighbors,
+    inneighbors,
     induced_subgraph
 using PiecewiseLinearFunctions:
     PiecewiseLinearFunction, convex_meet, remove_redundant_breakpoints, convex_meet

src/interface.jl

@@ -70,10 +70,15 @@ function CSPInstance(;
     cost_function,
     forward_functions,
     backward_functions=nothing,
+    topological_ordering=nothing,
 )
     @assert is_directed(graph) "`graph` must be a directed graph"
     @assert !is_cyclic(graph) "`graph` must be acyclic"
-    useful_vertices = topological_order(graph, origin_vertex, destination_vertex)
+    useful_vertices = if isnothing(topological_ordering)
+        topological_order(graph, origin_vertex, destination_vertex)
+    else
+        topological_ordering
+    end
     is_useful = falses(nv(graph))
     is_useful[useful_vertices] .= true
     if isnothing(destination_backward_resource) && isnothing(backward_functions)

src/utils/utils.jl

@@ -13,6 +13,22 @@ function remove_dominated!(Mw::AbstractVector{R}, rq::R) where {R}
     return nothing
 end
 
+function dfs(graph::G, v::T; out=true) where {T,G<:AbstractGraph{T}}
+    visited = falses(nv(graph))
+    stack = [v]
+    while !isempty(stack)
+        v = pop!(stack)
+        if visited[v]
+            continue
+        end
+        visited[v] = true
+        for w in (out ? outneighbors(graph, v) : inneighbors(graph, v))
+            push!(stack, w)
+        end
+    end
+    return visited
+end
+
 # Topological order computing
 function scan!(
     graph::G, vertex::T, order::Vector{T}, opened::BitVector
@@ -29,11 +45,19 @@ function scan!(
 end
 
 function topological_order(graph::G, s::T, t::T) where {T,G<:AbstractGraph{T}}
+    s_visited = dfs(graph, s; out=true)
+    t_visited = dfs(graph, t; out=false)
+    visited = s_visited .& t_visited
+
     order = Int[]
     opened = falses(nv(graph))
     scan!(graph, s, order, opened)
 
-    start = findfirst(x -> (x == t), order)  # Can we do smarter than that ?
-    @assert !isnothing(start)
-    return order[start:end]
+    res = [o for o in order if visited[o]]
+    @assert res[1] == t
+    return res
+
+    # start = findfirst(x -> (x == t), order)  # Can we do smarter than that ?
+    # @assert !isnothing(start)
+    # return order[start:end]
 end