From: asutton_at_[hidden]
Date: 2007-08-01 13:46:49
Author: asutton
Date: 2007-08-01 13:46:48 EDT (Wed, 01 Aug 2007)
New Revision: 38341
URL: http://svn.boost.org/trac/boost/changeset/38341
Log:
Renamed files
Added:
sandbox/SOC/2007/graphs/boost/graph/bron_kerbosch_all_cliques.hpp
- copied unchanged from r38340, /sandbox/SOC/2007/graphs/boost/graph/clique.hpp
sandbox/SOC/2007/graphs/boost/graph/tiernan_all_cycles.hpp
- copied unchanged from r38340, /sandbox/SOC/2007/graphs/boost/graph/cycle.hpp
Removed:
sandbox/SOC/2007/graphs/boost/graph/clique.hpp
sandbox/SOC/2007/graphs/boost/graph/cycle.hpp
Deleted: sandbox/SOC/2007/graphs/boost/graph/clique.hpp
==============================================================================
--- sandbox/SOC/2007/graphs/boost/graph/clique.hpp 2007-08-01 13:46:48 EDT (Wed, 01 Aug 2007)
+++ (empty file)
@@ -1,226 +0,0 @@
-// (C) Copyright Andrew Sutton 2007
-//
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0 (See accompanying file
-// LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_GRAPH_CLIQUE_HXX
-#define BOOST_GRAPH_CLIQUE_HXX
-
-namespace boost
-{
-
- // The algorithm implemented in this paper is based on the so-called
- // Algorithm 457, published as:
- //
- // @article{362367,
- // author = {Coen Bron and Joep Kerbosch},
- // title = {Algorithm 457: finding all cliques of an undirected graph},
- // journal = {Communications of the ACM},
- // volume = {16},
- // number = {9},
- // year = {1973},
- // issn = {0001-0782},
- // pages = {575--577},
- // doi = {http://doi.acm.org/10.1145/362342.362367},
- // publisher = {ACM Press},
- // address = {New York, NY, USA},
- // }
- //
- // Sort of. This implementation is adapted from the 1st version of the
- // algorithm and does not implement the candidate selection optimization
- // described as published - it could, it just doesn't yet.
- //
- // The algorithm is given as proportional to (3.14)^(n/3) power. This is
- // not the same as O(...), but based on time measures and approximation.
- //
- // Unfortunately, this implementation may be less efficient on non-
- // AdjacencyMatrix modeled graphs due to the non-constant implementation
- // of the edge(u,v,g) functions.
- //
- // TODO: It might be worthwhile to provide functionality for passing
- // a connectivity matrix to improve the efficiency of those lookups
- // when needed. This could simply be passed as a BooleanMatrix
- // s.t. edge(u,v,B) returns true or false. This could easily be
- // abstracted for adjacency matricies.
- //
- // The following paper is interesting for a number of reasons. First,
- // it lists a number of other such algorithms and second, it describes
- // a new algorithm (that does not appear to require the edge(u,v,g)
- // function and appears fairly efficient. It is probably worth investigating.
- //
- // @article{DBLP:journals/tcs/TomitaTT06,
- // author = {Etsuji Tomita and Akira Tanaka and Haruhisa Takahashi},
- // title = {The worst-case time complexity for generating all maximal cliques and computational experiments},
- // journal = {Theor. Comput. Sci.},
- // volume = {363},
- // number = {1},
- // year = {2006},
- // pages = {28-42}
- // ee = {http://dx.doi.org/10.1016/j.tcs.2006.06.015}
- // }
-
- struct clique_visitor
- {
- template <typename VertexSet, typename Graph>
- void clique(const VertexSet&, Graph&)
- { }
- };
-
- namespace detail
- {
- template <typename Graph>
- inline bool
- is_connected_to_clique(const Graph& g,
- typename graph_traits<Graph>::vertex_descriptor u,
- typename graph_traits<Graph>::vertex_descriptor v,
- typename graph_traits<Graph>::undirected_category)
- {
- return edge(u, v, g).second;
- }
-
- template <typename Graph>
- inline bool
- is_connected_to_clique(const Graph& g,
- typename graph_traits<Graph>::vertex_descriptor u,
- typename graph_traits<Graph>::vertex_descriptor v,
- typename graph_traits<Graph>::directed_category)
- {
- // Note that this could alternate between using an or to determine
- // full connectivity. I believe that this should produce strongly
- // connected components. Note that using && instead of || will
- // change the results to a fully connected subgraph (i.e., symmetric
- // edges between all vertices s.t., if a->b, then b->a.
- //
- // TODO: use this, the other, or allow switching based on a user-
- // define strategy.
- return edge(u, v, g).second && edge(v, u, g).second;
- }
-
- template <typename Graph, typename Container>
- inline void
- filter_unconnected_vertices(const Graph& g,
- typename graph_traits<Graph>::vertex_descriptor v,
- const Container& in,
- Container& out)
- {
- typename graph_traits<Graph>::directed_category cat;
- typename Container::const_iterator i, end = in.end();
- for(i = in.begin(); i != end; ++i) {
- if(is_connected_to_clique(g, v, *i, cat)) {
- out.push_back(*i);
- }
- }
- }
-
- template <
- typename Graph,
- typename Clique, // compsub type
- typename Container, // candidates/not type
- typename Visitor
- >
- void extend_clique(const Graph& g,
- Clique& clique,
- Container& cands,
- Container& nots,
- Visitor vis)
- {
- typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
- {
- // is there vertex in nots that is connected to all vertices
- // in the candidate set? if so, no clique can ever be found.
- typename Container::iterator ni, nend = nots.end();
- typename Container::iterator ci, cend = cands.end();
- for(ni = nots.begin(); ni != nend; ++ni) {
- for(ci = cands.begin(); ci != cend; ++ci) {
- // if we don't find an edge, then we're okay.
- if(!edge(*ni, *ci, g).second) break;
- }
- // if we iterated all the way to the end, then *ni
- // is connected to all *ci
- if(ci == cend) break;
- }
- // if we broke early, we found *ni connected to all *ci
- if(ni != nend) return;
- }
-
- // TODO: the original algorithm 457 describes an alternative
- // (albeit really complicated) mechanism for selecting candidates.
- // The given optimizaiton seeks to bring about the above
- // condition sooner (i.e., there is a vertex in the not set
- // that is connected to all candidates). unfortunately, the
- // method they give for doing this is fairly unclear.
-
- // basically, for every vertex in not, we should know how many
- // vertices it is disconnected from in the candidate set. if
- // we fix some vertex in the not set, then we want to keep
- // choosing vertices that are not connected to that fixed vertex.
- // apparently, by selecting fix point with the minimum number
- // of disconnections (i.e., the maximum number of connections
- // within the candidate set), then the previous condition wil
- // be reached sooner.
-
- // there's some other stuff about using the number of disconnects
- // as a counter, but i'm jot really sure i followed it.
-
- // otherwise, iterate over candidates and and test
- // for maxmim cliquiness.
- typename Container::iterator i, j, end = cands.end();
- for(i = cands.begin(); i != cands.end(); ) {
- Vertex candidate = *i;
-
- // add the candidate to the clique (keeping the iterator!)
- typename Clique::iterator ci =
- clique.insert(clique.end(), candidate);
-
- // remove it from the candidate set
- i = cands.erase(i);
-
- // build new candidate and not sets by removing all vertices
- // that are not connected to the current candidate vertex.
- // these actually invert the operation, adding them to the new
- // sets if the vertices are connected. its semantically the same.
- Container new_cands, new_nots;
- filter_unconnected_vertices(g, candidate, cands, new_cands);
- filter_unconnected_vertices(g, candidate, nots, new_nots);
-
- if(new_cands.empty() && new_nots.empty()) {
- // our current clique is maximal since there's nothing
- // that's connected that we haven't already visited
- vis.clique(clique, g);
- }
- else {
- // recurse to explore the new candidates
- extend_clique(g, clique, new_cands, new_nots, vis);
- }
-
- // we're done with this vertex, so we need to move it
- // to the nots, and remove the candidate from the clique.
- nots.push_back(candidate);
- clique.erase(ci);
- }
- }
- }
-
-
- template <typename Graph, typename Visitor>
- inline void
- bron_kerbosch_all_cliques(const Graph& g, Visitor vis)
- {
- typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
- typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
- typedef std::vector<Vertex> VertexSet;
- typedef std::list<Vertex> Clique;
-
- VertexIterator i, end;
- tie(i, end) = vertices(g);
-
- VertexSet cands(i, end); // start with all vertices as candidates
- VertexSet nots; // start with no vertices visited
- Clique clique; // the first clique is an empty vertex set
- detail::extend_clique(g, clique, cands, nots, vis);
- }
-}
-
-#endif
Deleted: sandbox/SOC/2007/graphs/boost/graph/cycle.hpp
==============================================================================
--- sandbox/SOC/2007/graphs/boost/graph/cycle.hpp 2007-08-01 13:46:48 EDT (Wed, 01 Aug 2007)
+++ (empty file)
@@ -1,317 +0,0 @@
-// (C) Copyright Andrew Sutton 2007
-//
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0 (See accompanying file
-// LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_GRAPH_CYCLE_HXX
-#define BOOST_GRAPH_CYCLE_HXX
-
-#include <vector>
-#include <limits>
-
-#include <boost/utility.hpp>
-#include <boost/graph/graph_traits.hpp>
-
-namespace boost
-{
-
- // The implementation of this algorithm is a reproduction of the Teirnan
- // approach for directed graphs: bibtex follows
- //
- // @article{362819,
- // author = {James C. Tiernan},
- // title = {An efficient search algorithm to find the elementary circuits of a graph},
- // journal = {Commun. ACM},
- // volume = {13},
- // number = {12},
- // year = {1970},
- // issn = {0001-0782},
- // pages = {722--726},
- // doi = {http://doi.acm.org/10.1145/362814.362819},
- // publisher = {ACM Press},
- // address = {New York, NY, USA},
- // }
- //
- // It should be pointed out that the author does not provide a complete analysis for
- // either time or space. This is in part, due to the fact that it's a fairly input
- // sensitive problem related to the density and construction of the graph, not just
- // its size.
- //
- // I've also taken some liberties with the interpretation of the algorithm - I've
- // basically modernized it to use real data structures (no more arrays and matrices).
- // Oh... and there's explicit control structures - not just gotos.
- //
- // The problem is definitely NP-complete, an an unbounded implementation of this
- // will probably run for quite a while (i.e.) on a large graph. The conclusions
- // of this paper alkso reference a Paton algorithm for undirected graphs as being
- // much more efficient (apparently based on spanning trees). Although not implemented,
- // it can be found here:
- //
- // @article{363232,
- // author = {Keith Paton},
- // title = {An algorithm for finding a fundamental set of cycles of a graph},
- // journal = {Commun. ACM},
- // volume = {12},
- // number = {9},
- // year = {1969},
- // issn = {0001-0782},
- // pages = {514--518},
- // doi = {http://doi.acm.org/10.1145/363219.363232},
- // publisher = {ACM Press},
- // address = {New York, NY, USA},
- // }
-
- struct cycle_visitor
- {
- template <class Vertex, class Graph>
- inline void start_vertex(Vertex v, Graph& g)
- { }
-
- template <class Vertex, class Graph>
- inline void finish_vertex(Vertex v, Graph& g)
- { }
-
- template <class Path, class Graph>
- inline void cycle(const Path& p, Graph& g)
- { }
- };
-
- namespace detail
- {
- template <typename Graph, typename Path>
- inline bool
- is_in_path(const Graph&,
- typename graph_traits<Graph>::vertex_descriptor v,
- const Path& p)
- {
- return (std::find(p.begin(), p.end(), v) != p.end());
- }
-
- template <typename Graph, typename ClosedMatrix>
- inline bool
- is_path_closed(const Graph& g,
- typename graph_traits<Graph>::vertex_descriptor u,
- typename graph_traits<Graph>::vertex_descriptor v,
- const ClosedMatrix& closed)
- {
- // the path from u to v is closed if v can be found in the list
- // of closed vertices associated with u.
- typedef typename ClosedMatrix::const_reference Row;
- Row r = closed[get(vertex_index, g, u)];
- if(find(r.begin(), r.end(), v) != r.end()) {
- return true;
- }
- return false;
- }
-
- template <typename Graph, typename Path, typename ClosedMatrix>
- inline bool
- ignore_vertex(const Graph& g,
- typename graph_traits<Graph>::vertex_descriptor u,
- typename graph_traits<Graph>::vertex_descriptor v,
- const Path& p,
- const ClosedMatrix& m)
- {
- // notice the vth index must be greater than the first index of
- // path in order for it to be considered.
-
- return get(vertex_index, g, p.front()) > get(vertex_index, g, v) ||
- is_in_path(g, v, p) ||
- is_path_closed(g, u, v, m);
- }
-
- template <
- typename Graph,
- typename Path,
- typename ClosedMatrix>
- inline bool
- can_extend_path(const Graph& g,
- typename graph_traits<Graph>::edge_descriptor e,
- const Path& p,
- const ClosedMatrix& m)
- {
- typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
- // get the vertices in question
- Vertex
- u = source(e, g),
- v = target(e, g);
-
- // conditions for allowing a traversal along this edge are:
- // 1. the index of v must be greater than that at which the
- // the path is rooted (p.front()).
- // 2. the vertex v cannot already be in the path
- // 3. the vertex v cannot be closed to the vertex u
-
- bool indices = get(vertex_index, g, p.front()) < get(vertex_index, g, v);
- bool path = !is_in_path(g, v, p);
- bool closed = !is_path_closed(g, u, v, m);
- return indices && path && closed;
- }
-
- template <
- typename Graph,
- typename Path>
- inline bool
- can_wrap_path(const Graph& g,
- const Path& p)
- {
- typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
- typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
-
- // iterate over the out-edges of the back, looking for the
- // front of the path. also, we can't travel along the same
- // edge that we did on the way here.
- Vertex
- u = p.back(),
- v = p.front();
- OutIterator i, end;
- for(tie(i, end) = out_edges(u, g); i != end; ++i) {
- if((target(*i, g) == v)) {
- return true;
- }
- }
- return false;
- }
-
- template <
- typename Graph,
- typename Path,
- typename ClosedMatrix>
- inline typename graph_traits<Graph>::vertex_descriptor
- extend_path(const Graph& g,
- Path& p,
- ClosedMatrix& closed)
- {
- typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
- typedef typename graph_traits<Graph>::edge_descriptor Edge;
- typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
-
- // get the current vertex
- Vertex u = p.back();
- Vertex ret = graph_traits<Graph>::null_vertex();
-
- // AdjacencyIterator i, end;
- OutIterator i, end;
- for(tie(i, end) = out_edges(u, g); i != end; ++i) {
- Vertex v = target(*i, g);
-
- // if we can actually extend along this edge,
- // then that's what we want to do
- if(can_extend_path(g, *i, p, closed)) {
- p.push_back(v); // add the vertex to the path
- ret = v;
- break;
- }
- }
- return ret;
- }
-
- template <typename Graph,
- typename Path,
- typename ClosedMatrix>
- inline bool
- exhaust_paths(const Graph& g,
- Path& p,
- ClosedMatrix& closed)
- {
- typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
- // if there's more than one vertex in the path, this closes
- // of some possible routes and returns true. otherwise, if there's
- // only one vertex left, the vertex has been used up
- if(p.size() > 1) {
- // get the last and second to last vertices, popping the last
- // vertex off the path
- Vertex last, prev;
- last = p.back();
- p.pop_back();
- prev = p.back();
-
- // reset the closure for the last vertex of the path and
- // indicate that the last vertex in p is now closed to
- // the next-to-last vertex in p
- closed[get(vertex_index, g, last)].clear();
- closed[get(vertex_index, g, prev)].push_back(last);
- return true;
- }
- else {
- return false;
- }
- }
-
- template <typename Graph, typename Visitor>
- inline void
- all_cycles_at_vertex(const Graph& g,
- typename graph_traits<Graph>::vertex_descriptor v,
- Visitor vis,
- std::size_t maxlen,
- std::size_t minlen)
- {
- typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
- typedef typename graph_traits<Graph>::edge_descriptor Edge;
-
- typedef std::vector<Vertex> Path;
- typedef std::vector<Vertex> VertexList;
- typedef std::vector<VertexList> ClosedMatrix;
-
- // this is an added type that helps us determine traversability
- // for paths in undirected graphs. Specifically, when we consider
- // traversability, we have to ensure that the move to the next
- // vertex does not walk down the same path as this vertex.
-
- const Vertex null = graph_traits<Graph>::null_vertex();
-
- // The path is the sequence of vertices
- Path p;
- ClosedMatrix closed(num_vertices(g), VertexList());
-
- // each path investigation starts at the ith vertex
- p.push_back(v);
-
- while(1) {
- // extend the path until we've reached the end or the
- // maxlen-sized cycle
- Vertex j = null;
- while(((j = detail::extend_path(g, p, closed)) != null)
- && (p.size() < maxlen))
- ; // empty loop
-
- // if we're done extending the path and there's an edge
- // connecting the back to the front, then we should have
- // a cycle.
- if(can_wrap_path(g, p) && p.size() > minlen) {
- vis.cycle(p, g);
- }
-
- if(!detail::exhaust_paths(g, p, closed)) {
- break;
- }
- }
- }
- }
-
- template <typename Graph, typename Visitor>
- inline void
- tiernan_all_cycles(const Graph& g, Visitor vis,
- std::size_t maxlen,
- std::size_t minlen)
- {
- typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-
- VertexIterator i, end;
- for(tie(i, end) = vertices(g); i != end; ++i) {
- detail::all_cycles_at_vertex(g, *i, vis, maxlen, minlen);
- }
- }
-
- template <typename Graph, typename Visitor>
- inline void
- tiernan_all_cycles(const Graph& g, Visitor vis)
- {
- tiernan_all_cycles(g, vis, 2, std::numeric_limits<std::size_t>::max());
- }
-}
-
-#endif