Merge pull request JuliaAttic#153 from JuliaGraphs/opt/connected-components

Opt/connected components

Author: sbromberger

bench/connectivity.jl

@@ -29,7 +29,7 @@ function loadmat(matname)
     return g
 end
 
-names = ["Newman/football" , "Newman/cond-mat-2003", "SNAP/amazon0302"]#, "SNAP/roadNet-CA"]
+names = ["Newman/football" , "Newman/cond-mat-2003", "SNAP/amazon0302","SNAP/roadNet-CA"]
 sucesses = []
 failures = []
 for matname in names
@@ -40,7 +40,11 @@ for matname in names
     label = zeros(Int, nv(g))
     @time label = LightGraphs.connected_components!(label, g)
     @time components = LightGraphs.connected_components!(visitor, g)
+    fill!(visitor.tree, 0)
+    @time LightGraphs.bfs_tree!(visitor, g, 1)
     @show length(components)
+    #= 
     @time components_slow = LightGraphs.connected_components(g)
     @assert length(components) == length(components_slow)
+    =#
 end

src/connectivity.jl

@@ -5,35 +5,36 @@
 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(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]
-            visitor.tree[:] = 0
+            fill!(visitor.tree, 0)
+            visitor.tree[v] = v
             parents = bfs_tree!(visitor, g, v)
             found_vertices = @compat Vector{Int}()
             for i in 1:nvg
@@ -50,23 +51,82 @@ function connected_components!(visitor::TreeBFSVisitorVector, g::Graph)
     return components
 end
 
+"""connected_components! produces a label array of components
+
+Arguments:
+    label: a place to store the output
+    g: the graph
+Output:
+    c = labels[i] => vertex i belongs to component c. 
+    c is the smallest vertex id in the component.
+"""
 function connected_components!(label::Vector{Int}, g::Graph)
     nvg = nv(g)
-    visitor = LightGraphs.TreeBFSVisitorVector(zeros(Int, nv(g)))
+    visitor = LightGraphs.ComponentVisitorVector(label, 0)
+    colormap = zeros(Int,nvg)
+    que = @compat Vector{Int}()
+    sizehint!(que, nvg)
     for v in 1:nvg
         if label[v] == 0
-            visitor.tree[:] = 0
-            parents = bfs_tree!(visitor, g, v)
-            for i in 1:nvg
-                if parents[i] > 0
-                    label[i] = v
-                end
-            end
+            visitor.labels[v] = v
+            visitor.seed = v
+            traverse_graph(g, BreadthFirst(), v, visitor; colormap=colormap, que=que)
         end
     end
     return label
 end
 
+"""components_dict(labels) converts an array of labels to a Dict{Int,Vector{Int}} of components
+
+Arguments:
+    c = labels[i] => vertex i belongs to component c.
+Output:
+    vs = d[c] => vertices in vs belong to component c.
+"""
+function components_dict(labels::Vector{Int})
+    d = Dict{Int,Vector{Int}}()
+    for (v,l) in enumerate(labels)
+        vec = get(d, l, @compat Vector{Int}())
+        push!(vec, v)
+        d[l] = vec
+    end
+    return d
+end
+
+"""components(labels) converts an array of labels to a Vector{Vector{Int} of components
+
+Arguments:
+    c = labels[i] => vertex i belongs to component c.
+Output:
+    vs = c[i] => vertices in vs belong to component i.
+    a = d[i] => if label[v[j]]==i then j in c[a] end
+"""
+function components(labels::Vector{Int})
+    d = Dict{Int, Int}()
+    c = Vector{Vector{Int}}()
+    i = 1
+    for (v,l) in enumerate(labels)
+        index = get(d, l, i)
+        d[l] = index
+        if length(c) >= index
+            vec = c[index]
+            push!(vec, v)
+            c[index] = vec
+        else
+            push!(c, [v])
+            i += 1
+        end
+    end
+    return c, d
+end
+
+function connected_components(g)
+    label = zeros(Int, nv(g))
+    connected_components!(label, g)
+    c, d = components(label) 
+    return c
+end
+
 """Returns `true` if `g` is connected.
 For DiGraphs, this is equivalent to a test of weak connectivity."""
 is_connected(g::Graph) = length(connected_components(g)) == 1

src/traversals/bfs.jl

@@ -42,15 +42,13 @@ function breadth_first_visit_impl!(
     nothing
 end
 
-
 function traverse_graph(
     graph::SimpleGraph,
     alg::BreadthFirst,
     s::Int,
     visitor::SimpleGraphVisitor;
-    colormap = zeros(Int, nv(graph)))
-
-    que = @compat Vector{Int}()
+    colormap = zeros(Int, nv(graph)),
+    que = @compat Vector{Int}())
 
     colormap[s] = 1
     discover_vertex!(visitor, s) || return
@@ -59,15 +57,13 @@ function traverse_graph(
     breadth_first_visit_impl!(graph, que, colormap, visitor)
 end
 
-
 function traverse_graph(
     graph::SimpleGraph,
     alg::BreadthFirst,
     sources::AbstractVector{Int},
     visitor::SimpleGraphVisitor;
-    colormap = zeros(Int, nv(graph)))
-
-    que = @compat Vector{Int}()
+    colormap = zeros(Int, nv(graph)),
+    que = @compat Vector{Int}())
 
     for s in sources
         colormap[s] = 1
@@ -136,13 +132,25 @@ type TreeBFSVisitorVector <: SimpleGraphVisitor
     tree::Vector{Int}
 end
 
+type ComponentVisitorVector <: SimpleGraphVisitor
+    labels::Vector{Int}
+    seed::Int
+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
     end
     return true
 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
 # Return the DAG representing the traversal of a graph.
 
 TreeBFSVisitor(n::Int) = TreeBFSVisitor(DiGraph(n))
@@ -172,8 +180,12 @@ function bfs_tree(visitor::TreeBFSVisitorVector, g::SimpleGraph, s::Int)
     return bfs_tree!(visitor, g, s)
 end
 
-function bfs_tree!(visitor::TreeBFSVisitorVector, g::SimpleGraph, s::Int)
-    traverse_graph(g, BreadthFirst(), s, visitor)
+function bfs_tree!(visitor::TreeBFSVisitorVector,
+        g::SimpleGraph,
+        s::Int;
+        colormap=zeros(Int, nv(g)),
+        que=Vector{Int}())
+    traverse_graph(g, BreadthFirst(), s, visitor; colormap=colormap, que=que)
     return visitor.tree
 end
 

test/connectivity.jl

@@ -10,9 +10,20 @@ add_edge!(g,10,9)
 @test is_connected(HouseGraph())
 
 cc = connected_components(g)
-
-
-@test length(cc) == 3 && sort(cc[3]) == [8,9,10]
+visitor = LightGraphs.TreeBFSVisitorVector(zeros(Int, nv(g)))
+label = zeros(Int, nv(g))
+label = LightGraphs.connected_components!(label, g)
+ccfast = LightGraphs.connected_components!(visitor, 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]
+@test cclab[5] == [5,6,7]
+@test cclab[8] == [8,9,10]
+
+
+@test length(cc) >= 3 && sort(cc[3]) == [8,9,10]
 
 
 # graph from https://en.wikipedia.org/wiki/Strongly_connected_component

test/traversals/bfs.jl

@@ -1,5 +1,8 @@
 z = bfs_tree(g5, 1)
+visitor = LightGraphs.TreeBFSVisitorVector(zeros(Int,nv(g5)))
+t = LightGraphs.bfs_tree(visitor, g5, 1)
 @test nv(z) == 4 && ne(z) == 3 && !has_edge(z, 2, 3)
+@test t == [1,1,1,3]
 
 g = HouseGraph()
 @test gdistances(g, 2) == [1, 0, 2, 1, 2]