Merge pull request JuliaAttic#176 from JuliaGraphs/issue/JuliaAttic#162

Replace the inefficient bfs_tree

Author: sbromberger

src/connectivity.jl

@@ -1,55 +1,6 @@
 # Parts of this code were taken / derived from Graphs.jl. See LICENSE for
 # licensing details.
 
-"""Returns the [connected components](https://en.wikipedia.org/wiki/Connectivity_(graph_theory))
-of an undirected graph `g` as a vector of components, each represented by a
-vector of vectors of vertices belonging to the component.
-"""
-#= function connected_components(g::Graph) =#
-#=      nvg = nv(g) =#
-#=      found = zeros(Bool, nvg) =#
-#=      components = @compat Vector{Vector{Int}}() =#
-#=      for v in 1:nvg =#
-#=          if !found[v] =#
-#=              bfstree = bfs_tree(g, v) =#
-#=              found_vertices = @compat Vector{Int}() =#
-#=              for e in edges(bfstree) =#
-#=                  push!(found_vertices, src(e)) =#
-#=                  push!(found_vertices, dst(e)) =#
-#=              end =#
-#=              found_vertices = unique(found_vertices) =#
-#=              found[found_vertices] = true =#
-#=              if length(found_vertices) > 0 =#
-#=                  push!(components, found_vertices) =#
-#=             end =#
-#=         end =#
-#=     end =#
-#=     return components =#
-#= end =#
-
-function connected_components!(visitor::TreeBFSVisitorVector, g::Graph)
-    nvg = nv(g)
-    found = zeros(Bool, nvg)
-    components = @compat Vector{Vector{Int}}()
-    for v in 1:nvg
-        if !found[v]
-            fill!(visitor.tree, 0)
-            visitor.tree[v] = v
-            parents = bfs_tree!(visitor, g, v)
-            found_vertices = @compat Vector{Int}()
-            for i in 1:nvg
-                if parents[i] > 0
-                    push!(found_vertices, i)
-                end
-            end
-            found[found_vertices] = true
-            if length(found_vertices) > 0
-                push!(components, found_vertices)
-            end
-        end
-    end
-    return components
-end
 
 """connected_components! produces a label array of components
 
@@ -61,6 +12,13 @@ Output:
     c is the smallest vertex id in the component.
 """
 function connected_components!(label::Vector{Int}, g::Graph)
+    # this version of connected components uses Breadth First Traversal
+    # with custom visitor type in order to improve performance.
+    # one BFS is performed for each component.
+    # This algorithm is linear in the number of edges of the graph
+    # each edge is touched once. memory performance is a single allocation.
+    # the return type is a vector of labels which can be used directly or
+    # passed to components(a)
     nvg = nv(g)
     visitor = LightGraphs.ComponentVisitorVector(label, 0)
     colormap = zeros(Int,nvg)
@@ -120,6 +78,10 @@ function components(labels::Vector{Int})
     return c, d
 end
 
+"""Returns the [connected components](https://en.wikipedia.org/wiki/Connectivity_(graph_theory))
+of an undirected graph `g` as a vector of components, each represented by a
+vector of vectors of vertices belonging to the component.
+"""
 function connected_components(g)
     label = zeros(Int, nv(g))
     connected_components!(label, g)

src/traversals/bfs.jl

@@ -124,37 +124,64 @@ function gdistances(graph::SimpleGraph, sources; defaultdist::Int=-1)
     gdistances!(graph, sources, dists)
 end
 
+###########################################
+# Constructing BFS trees                  #
+###########################################
+
+# this type has been deprecated in favor of TreeBFSVisitorVector and the tree function.
+"""TreeBFSVisitor is a type for representing a BFS traversal of the graph as a DiGraph"""
 type TreeBFSVisitor <:SimpleGraphVisitor
     tree::DiGraph
 end
 
+TreeBFSVisitor(n::Int) = TreeBFSVisitor(DiGraph(n))
+
+@deprecate TreeBFSVisitor(x) TreeBFSVisitorVector(x)
+
+"""TreeBFSVisitorVector is a type for representing a BFS traversal
+of the graph as a parents array. This type allows for a more performant implementation.
+"""
 type TreeBFSVisitorVector <: SimpleGraphVisitor
     tree::Vector{Int}
 end
 
-type ComponentVisitorVector <: SimpleGraphVisitor
-    labels::Vector{Int}
-    seed::Int
+function TreeBFSVisitorVector(n::Int)
+    return TreeBFSVisitorVector(zeros(Int, n))
 end
-function examine_neighbor!(visitor::TreeBFSVisitorVector, u::Int, v::Int, vcolor::Int, ecolor::Int)
-    # println("discovering $u -> $v, vcolor = $vcolor, ecolor = $ecolor")
-    if u != v && vcolor == 0
-        visitor.tree[v] = u
+
+"""TreeBFSVisitor converts a parents array into a DiGraph"""
+function TreeBFSVisitor(tvv::TreeBFSVisitorVector)
+    n = length(tvv.tree)
+    parents = tvv.tree
+    g = tree(parents)
+    return TreeBFSVisitor(g)
+end
+
+"""tree converts a parents array into a DiGraph"""
+function tree(parents::AbstractVector)
+    n = length(parents)
+    t = DiGraph(n)
+    for i in 1:n
+        parent = parents[i]
+        if parent > 0  && parent != i
+            add_edge!(t, parent, i)
+        end
     end
-    return true
+    return t
 end
 
-function examine_neighbor!(visitor::ComponentVisitorVector, u::Int, v::Int, vcolor::Int, ecolor::Int)
+tree(parents::TreeBFSVisitorVector) = tree(parents.tree)
+
+function examine_neighbor!(visitor::TreeBFSVisitorVector, u::Int, v::Int, vcolor::Int, ecolor::Int)
     # println("discovering $u -> $v, vcolor = $vcolor, ecolor = $ecolor")
     if u != v && vcolor == 0
-        visitor.labels[v] = visitor.seed
+        visitor.tree[v] = u
     end
     return true
 end
-# Return the DAG representing the traversal of a graph.
 
-TreeBFSVisitor(n::Int) = TreeBFSVisitor(DiGraph(n))
 
+# Return the DAG representing the traversal of a graph.
 function examine_neighbor!(visitor::TreeBFSVisitor, u::Int, v::Int, vcolor::Int, ecolor::Int)
     # println("discovering $u -> $v, vcolor = $vcolor, ecolor = $ecolor")
     if u != v && vcolor == 0
@@ -163,34 +190,58 @@ function examine_neighbor!(visitor::TreeBFSVisitor, u::Int, v::Int, vcolor::Int,
     return true
 end
 
-"""Provides a breadth-first traversal of the graph `g` starting with source vertex `s`,
-and returns a directed acyclic graph of vertices in the order they were discovered.
-"""
-function bfs_tree(g::SimpleGraph, s::Int)
-    nvg = nv(g)
-    visitor = TreeBFSVisitor(nvg)
-    traverse_graph(g, BreadthFirst(), s, visitor)
-    return visitor.tree
-end
 
-function bfs_tree(visitor::TreeBFSVisitorVector, g::SimpleGraph, s::Int)
-    nvg = nv(g)
-    visitor = TreeBFSVisitorVector(zeros(Int,nvg))
-    visitor.tree[s] = s
-    return bfs_tree!(visitor, g, s)
-end
 
 function bfs_tree!(visitor::TreeBFSVisitorVector,
         g::SimpleGraph,
         s::Int;
         colormap=zeros(Int, nv(g)),
         que=Vector{Int}())
+    # this version of bfs_tree! allows one to reuse the memory necessary to compute the tree
+    # the output is stored in the visitor.tree array whose entries are the vertex id of the
+    # parent of the index. This function checks if the scratch space is too small for the graph.
+    # and throws an error if it is too small.
+    # the source is represented in the output by a fixed point v[root] == root.
+    # this function is considered a performant version of bfs_tree for useful when the parent
+    # array is more helpful than a DiGraph struct, or when performance is critical.
+    nvg = nv(g)
+    length(visitor.tree) >= nvg || error("visitor.tree too small for graph")
+    visitor.tree[s] = s
     traverse_graph(g, BreadthFirst(), s, visitor; colormap=colormap, que=que)
-    return visitor.tree
 end
 
-# Test graph for bipartiteness
+"""Provides a breadth-first traversal of the graph `g` starting with source vertex `s`,
+and returns a directed acyclic graph of vertices in the order they were discovered.
+
+This function is a high level wrapper around bfs_tree!, use that function for more performance.
+"""
+function bfs_tree(g::SimpleGraph, s::Int)
+    nvg = nv(g)
+    visitor = TreeBFSVisitorVector(nvg)
+    bfs_tree!(visitor, g, s)
+    return tree(visitor)
+end
+
+############################################
+# Connected Components with BFS            #
+############################################
+"""Performing connected components with BFS starting from seed"""
+type ComponentVisitorVector <: SimpleGraphVisitor
+    labels::Vector{Int}
+    seed::Int
+end
+
+function examine_neighbor!(visitor::ComponentVisitorVector, u::Int, v::Int, vcolor::Int, ecolor::Int)
+    # println("discovering $u -> $v, vcolor = $vcolor, ecolor = $ecolor")
+    if u != v && vcolor == 0
+        visitor.labels[v] = visitor.seed
+    end
+    return true
+end
 
+############################################
+# Test graph for bipartiteness             #
+############################################
 type BipartiteVisitor <: SimpleGraphVisitor
     bipartitemap::Vector{UInt8}
     is_bipartite::Bool

test/connectivity.jl

@@ -10,12 +10,9 @@ add_edge!(g,10,9)
 @test is_connected(HouseGraph())
 
 cc = connected_components(g)
-visitor = LightGraphs.TreeBFSVisitorVector(zeros(Int, nv(g)))
 label = zeros(Int, nv(g))
-label = LightGraphs.connected_components!(label, g)
-ccfast = LightGraphs.connected_components!(visitor, g)
+LightGraphs.connected_components!(label, g)
 @test label[1:10] == [1,1,1,1,5,5,5,8,8,8]
-@test ccfast[1:3] == map(sort, cc)[1:3]
 import LightGraphs: components, components_dict
 cclab = components_dict(label)
 @test cclab[1] == [1,2,3,4]
@@ -25,7 +22,6 @@ cclab = components_dict(label)
 
 @test length(cc) >= 3 && sort(cc[3]) == [8,9,10]
 
-
 # graph from https://en.wikipedia.org/wiki/Strongly_connected_component
 h = DiGraph(8)
 add_edge!(h,1,2); add_edge!(h,2,3); add_edge!(h,2,5);

test/traversals/bfs.jl

@@ -1,6 +1,7 @@
 z = bfs_tree(g5, 1)
 visitor = LightGraphs.TreeBFSVisitorVector(zeros(Int,nv(g5)))
-t = LightGraphs.bfs_tree(visitor, g5, 1)
+LightGraphs.bfs_tree!(visitor, g5, 1)
+t = visitor.tree
 @test nv(z) == 4 && ne(z) == 3 && !has_edge(z, 2, 3)
 @test t == [1,1,1,3]
 
@@ -14,3 +15,39 @@ add_edge!(g,1,2); add_edge!(g,1,4)
 add_edge!(g,2,3); add_edge!(g,2,5)
 add_edge!(g,3,4)
 @test is_bipartite(g)
+
+
+import LightGraphs: TreeBFSVisitorVector, bfs_tree!, TreeBFSVisitor, tree
+g = HouseGraph()
+n = nv(g)
+visitor = TreeBFSVisitorVector(n)
+@test length(visitor.tree) == n
+parents = visitor.tree
+bfs_tree!(visitor, g, 1)
+maxdepth = n
+
+function istree(parents::Vector{Int})
+    flag = true
+    for i in 1:n
+        s = i
+        depth = 0
+        while parents[s] > 0 && parents[s] != s
+            s = parents[s]
+            depth += 1
+            if depth > maxdepth
+                return false
+            end
+        end
+    end
+    return flag
+end
+
+@test istree(parents) == true
+tvis = TreeBFSVisitor(visitor)
+@test nv(tvis.tree) == nv(g)
+@test typeof(tvis.tree) <: DiGraph
+t = tree(parents)
+@test typeof(t) <: DiGraph
+@test typeof(tvis.tree) <: DiGraph
+@test t == tvis.tree
+@test ne(t) < nv(t)