/Src/Dependencies/Boost/boost/graph/transitive_closure.hpp
C++ Header | 370 lines | 298 code | 42 blank | 30 comment | 85 complexity | ca2194903a64459ef79cb0639e340eb3 MD5 | raw file
1// Copyright (C) 2001 Vladimir Prus <ghost@cs.msu.su> 2// Copyright (C) 2001 Jeremy Siek <jsiek@cs.indiana.edu> 3// Distributed under the Boost Software License, Version 1.0. (See 4// accompanying file LICENSE_1_0.txt or copy at 5// http://www.boost.org/LICENSE_1_0.txt) 6 7// NOTE: this final is generated by libs/graph/doc/transitive_closure.w 8 9#ifndef BOOST_GRAPH_TRANSITIVE_CLOSURE_HPP 10#define BOOST_GRAPH_TRANSITIVE_CLOSURE_HPP 11 12#include <vector> 13#include <algorithm> // for std::min and std::max 14#include <functional> 15#include <boost/config.hpp> 16#include <boost/bind.hpp> 17#include <boost/graph/vector_as_graph.hpp> 18#include <boost/graph/strong_components.hpp> 19#include <boost/graph/topological_sort.hpp> 20#include <boost/graph/graph_concepts.hpp> 21#include <boost/graph/named_function_params.hpp> 22 23namespace boost 24{ 25 26 namespace detail 27 { 28 inline void 29 union_successor_sets(const std::vector < std::size_t > &s1, 30 const std::vector < std::size_t > &s2, 31 std::vector < std::size_t > &s3) 32 { 33 BOOST_USING_STD_MIN(); 34 for (std::size_t k = 0; k < s1.size(); ++k) 35 s3[k] = min BOOST_PREVENT_MACRO_SUBSTITUTION(s1[k], s2[k]); 36 } 37 } // namespace detail 38 39 namespace detail 40 { 41 template < typename TheContainer, typename ST = std::size_t, 42 typename VT = typename TheContainer::value_type > 43 struct subscript_t:public std::unary_function < ST, VT > 44 { 45 typedef VT& result_type; 46 47 subscript_t(TheContainer & c):container(&c) 48 { 49 } 50 VT & operator() (const ST & i) const 51 { 52 return (*container)[i]; 53 } 54 protected: 55 TheContainer * container; 56 }; 57 template < typename TheContainer > 58 subscript_t < TheContainer > subscript(TheContainer & c) { 59 return subscript_t < TheContainer > (c); 60 } 61 } // namespace detail 62 63 template < typename Graph, typename GraphTC, 64 typename G_to_TC_VertexMap, 65 typename VertexIndexMap > 66 void transitive_closure(const Graph & g, GraphTC & tc, 67 G_to_TC_VertexMap g_to_tc_map, 68 VertexIndexMap index_map) 69 { 70 if (num_vertices(g) == 0) 71 return; 72 typedef typename graph_traits < Graph >::vertex_descriptor vertex; 73 typedef typename graph_traits < Graph >::edge_descriptor edge; 74 typedef typename graph_traits < Graph >::vertex_iterator vertex_iterator; 75 typedef typename property_traits < VertexIndexMap >::value_type size_type; 76 typedef typename graph_traits < 77 Graph >::adjacency_iterator adjacency_iterator; 78 79 function_requires < VertexListGraphConcept < Graph > >(); 80 function_requires < AdjacencyGraphConcept < Graph > >(); 81 function_requires < VertexMutableGraphConcept < GraphTC > >(); 82 function_requires < EdgeMutableGraphConcept < GraphTC > >(); 83 function_requires < ReadablePropertyMapConcept < VertexIndexMap, 84 vertex > >(); 85 86 typedef size_type cg_vertex; 87 std::vector < cg_vertex > component_number_vec(num_vertices(g)); 88 iterator_property_map < cg_vertex *, VertexIndexMap, cg_vertex, cg_vertex& > 89 component_number(&component_number_vec[0], index_map); 90 91 int num_scc = strong_components(g, component_number, 92 vertex_index_map(index_map)); 93 94 std::vector < std::vector < vertex > >components; 95 build_component_lists(g, num_scc, component_number, components); 96 97 typedef std::vector<std::vector<cg_vertex> > CG_t; 98 CG_t CG(num_scc); 99 for (cg_vertex s = 0; s < components.size(); ++s) { 100 std::vector < cg_vertex > adj; 101 for (size_type i = 0; i < components[s].size(); ++i) { 102 vertex u = components[s][i]; 103 adjacency_iterator v, v_end; 104 for (boost::tie(v, v_end) = adjacent_vertices(u, g); v != v_end; ++v) { 105 cg_vertex t = component_number[*v]; 106 if (s != t) // Avoid loops in the condensation graph 107 adj.push_back(t); 108 } 109 } 110 std::sort(adj.begin(), adj.end()); 111 typename std::vector<cg_vertex>::iterator di = 112 std::unique(adj.begin(), adj.end()); 113 if (di != adj.end()) 114 adj.erase(di, adj.end()); 115 CG[s] = adj; 116 } 117 118 std::vector<cg_vertex> topo_order; 119 std::vector<cg_vertex> topo_number(num_vertices(CG)); 120 topological_sort(CG, std::back_inserter(topo_order), 121 vertex_index_map(identity_property_map())); 122 std::reverse(topo_order.begin(), topo_order.end()); 123 size_type n = 0; 124 for (typename std::vector<cg_vertex>::iterator iter = topo_order.begin(); 125 iter != topo_order.end(); ++iter) 126 topo_number[*iter] = n++; 127 128 for (size_type i = 0; i < num_vertices(CG); ++i) 129 std::sort(CG[i].begin(), CG[i].end(), 130 boost::bind(std::less<cg_vertex>(), 131 boost::bind(detail::subscript(topo_number), _1), 132 boost::bind(detail::subscript(topo_number), _2))); 133 134 std::vector<std::vector<cg_vertex> > chains; 135 { 136 std::vector<cg_vertex> in_a_chain(num_vertices(CG)); 137 for (typename std::vector<cg_vertex>::iterator i = topo_order.begin(); 138 i != topo_order.end(); ++i) { 139 cg_vertex v = *i; 140 if (!in_a_chain[v]) { 141 chains.resize(chains.size() + 1); 142 std::vector<cg_vertex>& chain = chains.back(); 143 for (;;) { 144 chain.push_back(v); 145 in_a_chain[v] = true; 146 typename graph_traits<CG_t>::adjacency_iterator adj_first, adj_last; 147 boost::tie(adj_first, adj_last) = adjacent_vertices(v, CG); 148 typename graph_traits<CG_t>::adjacency_iterator next 149 = std::find_if(adj_first, adj_last, 150 std::not1(detail::subscript(in_a_chain))); 151 if (next != adj_last) 152 v = *next; 153 else 154 break; // end of chain, dead-end 155 156 } 157 } 158 } 159 } 160 std::vector<size_type> chain_number(num_vertices(CG)); 161 std::vector<size_type> pos_in_chain(num_vertices(CG)); 162 for (size_type i = 0; i < chains.size(); ++i) 163 for (size_type j = 0; j < chains[i].size(); ++j) { 164 cg_vertex v = chains[i][j]; 165 chain_number[v] = i; 166 pos_in_chain[v] = j; 167 } 168 169 cg_vertex inf = (std::numeric_limits< cg_vertex >::max)(); 170 std::vector<std::vector<cg_vertex> > successors(num_vertices(CG), 171 std::vector<cg_vertex> 172 (chains.size(), inf)); 173 for (typename std::vector<cg_vertex>::reverse_iterator 174 i = topo_order.rbegin(); i != topo_order.rend(); ++i) { 175 cg_vertex u = *i; 176 typename graph_traits<CG_t>::adjacency_iterator adj, adj_last; 177 for (boost::tie(adj, adj_last) = adjacent_vertices(u, CG); 178 adj != adj_last; ++adj) { 179 cg_vertex v = *adj; 180 if (topo_number[v] < successors[u][chain_number[v]]) { 181 // Succ(u) = Succ(u) U Succ(v) 182 detail::union_successor_sets(successors[u], successors[v], 183 successors[u]); 184 // Succ(u) = Succ(u) U {v} 185 successors[u][chain_number[v]] = topo_number[v]; 186 } 187 } 188 } 189 190 for (size_type i = 0; i < CG.size(); ++i) 191 CG[i].clear(); 192 for (size_type i = 0; i < CG.size(); ++i) 193 for (size_type j = 0; j < chains.size(); ++j) { 194 size_type topo_num = successors[i][j]; 195 if (topo_num < inf) { 196 cg_vertex v = topo_order[topo_num]; 197 for (size_type k = pos_in_chain[v]; k < chains[j].size(); ++k) 198 CG[i].push_back(chains[j][k]); 199 } 200 } 201 202 203 // Add vertices to the transitive closure graph 204 typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex; 205 { 206 vertex_iterator i, i_end; 207 for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i) 208 g_to_tc_map[*i] = add_vertex(tc); 209 } 210 // Add edges between all the vertices in two adjacent SCCs 211 typename graph_traits<CG_t>::vertex_iterator si, si_end; 212 for (boost::tie(si, si_end) = vertices(CG); si != si_end; ++si) { 213 cg_vertex s = *si; 214 typename graph_traits<CG_t>::adjacency_iterator i, i_end; 215 for (boost::tie(i, i_end) = adjacent_vertices(s, CG); i != i_end; ++i) { 216 cg_vertex t = *i; 217 for (size_type k = 0; k < components[s].size(); ++k) 218 for (size_type l = 0; l < components[t].size(); ++l) 219 add_edge(g_to_tc_map[components[s][k]], 220 g_to_tc_map[components[t][l]], tc); 221 } 222 } 223 // Add edges connecting all vertices in a SCC 224 for (size_type i = 0; i < components.size(); ++i) 225 if (components[i].size() > 1) 226 for (size_type k = 0; k < components[i].size(); ++k) 227 for (size_type l = 0; l < components[i].size(); ++l) { 228 vertex u = components[i][k], v = components[i][l]; 229 add_edge(g_to_tc_map[u], g_to_tc_map[v], tc); 230 } 231 232 // Find loopbacks in the original graph. 233 // Need to add it to transitive closure. 234 { 235 vertex_iterator i, i_end; 236 for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i) 237 { 238 adjacency_iterator ab, ae; 239 for (boost::tie(ab, ae) = adjacent_vertices(*i, g); ab != ae; ++ab) 240 { 241 if (*ab == *i) 242 if (components[component_number[*i]].size() == 1) 243 add_edge(g_to_tc_map[*i], g_to_tc_map[*i], tc); 244 } 245 } 246 } 247 } 248 249 template <typename Graph, typename GraphTC> 250 void transitive_closure(const Graph & g, GraphTC & tc) 251 { 252 if (num_vertices(g) == 0) 253 return; 254 typedef typename property_map<Graph, vertex_index_t>::const_type 255 VertexIndexMap; 256 VertexIndexMap index_map = get(vertex_index, g); 257 258 typedef typename graph_traits<GraphTC>::vertex_descriptor tc_vertex; 259 std::vector<tc_vertex> to_tc_vec(num_vertices(g)); 260 iterator_property_map < tc_vertex *, VertexIndexMap, tc_vertex, tc_vertex&> 261 g_to_tc_map(&to_tc_vec[0], index_map); 262 263 transitive_closure(g, tc, g_to_tc_map, index_map); 264 } 265 266 namespace detail 267 { 268 template < typename Graph, typename GraphTC, typename G_to_TC_VertexMap, 269 typename VertexIndexMap> 270 void transitive_closure_dispatch 271 (const Graph & g, GraphTC & tc, 272 G_to_TC_VertexMap g_to_tc_map, VertexIndexMap index_map) 273 { 274 typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex; 275 typename std::vector < tc_vertex >::size_type 276 n = is_default_param(g_to_tc_map) ? num_vertices(g) : 1; 277 std::vector < tc_vertex > to_tc_vec(n); 278 279 transitive_closure 280 (g, tc, 281 choose_param(g_to_tc_map, make_iterator_property_map 282 (to_tc_vec.begin(), index_map, to_tc_vec[0])), 283 index_map); 284 } 285 } // namespace detail 286 287 template < typename Graph, typename GraphTC, 288 typename P, typename T, typename R > 289 void transitive_closure(const Graph & g, GraphTC & tc, 290 const bgl_named_params < P, T, R > ¶ms) 291 { 292 if (num_vertices(g) == 0) 293 return; 294 detail::transitive_closure_dispatch 295 (g, tc, get_param(params, orig_to_copy_t()), 296 choose_const_pmap(get_param(params, vertex_index), g, vertex_index) ); 297 } 298 299 300 template < typename G > void warshall_transitive_closure(G & g) 301 { 302 typedef typename graph_traits < G >::vertex_descriptor vertex; 303 typedef typename graph_traits < G >::vertex_iterator vertex_iterator; 304 305 function_requires < AdjacencyMatrixConcept < G > >(); 306 function_requires < EdgeMutableGraphConcept < G > >(); 307 308 // Matrix form: 309 // for k 310 // for i 311 // if A[i,k] 312 // for j 313 // A[i,j] = A[i,j] | A[k,j] 314 vertex_iterator ki, ke, ii, ie, ji, je; 315 for (boost::tie(ki, ke) = vertices(g); ki != ke; ++ki) 316 for (boost::tie(ii, ie) = vertices(g); ii != ie; ++ii) 317 if (edge(*ii, *ki, g).second) 318 for (boost::tie(ji, je) = vertices(g); ji != je; ++ji) 319 if (!edge(*ii, *ji, g).second && edge(*ki, *ji, g).second) { 320 add_edge(*ii, *ji, g); 321 } 322 } 323 324 325 template < typename G > void warren_transitive_closure(G & g) 326 { 327 using namespace boost; 328 typedef typename graph_traits < G >::vertex_descriptor vertex; 329 typedef typename graph_traits < G >::vertex_iterator vertex_iterator; 330 331 function_requires < AdjacencyMatrixConcept < G > >(); 332 function_requires < EdgeMutableGraphConcept < G > >(); 333 334 // Make sure second loop will work 335 if (num_vertices(g) == 0) 336 return; 337 338 // for i = 2 to n 339 // for k = 1 to i - 1 340 // if A[i,k] 341 // for j = 1 to n 342 // A[i,j] = A[i,j] | A[k,j] 343 344 vertex_iterator ic, ie, jc, je, kc, ke; 345 for (boost::tie(ic, ie) = vertices(g), ++ic; ic != ie; ++ic) 346 for (boost::tie(kc, ke) = vertices(g); *kc != *ic; ++kc) 347 if (edge(*ic, *kc, g).second) 348 for (boost::tie(jc, je) = vertices(g); jc != je; ++jc) 349 if (!edge(*ic, *jc, g).second && edge(*kc, *jc, g).second) { 350 add_edge(*ic, *jc, g); 351 } 352 // for i = 1 to n - 1 353 // for k = i + 1 to n 354 // if A[i,k] 355 // for j = 1 to n 356 // A[i,j] = A[i,j] | A[k,j] 357 358 for (boost::tie(ic, ie) = vertices(g), --ie; ic != ie; ++ic) 359 for (kc = ic, ke = ie, ++kc; kc != ke; ++kc) 360 if (edge(*ic, *kc, g).second) 361 for (boost::tie(jc, je) = vertices(g); jc != je; ++jc) 362 if (!edge(*ic, *jc, g).second && edge(*kc, *jc, g).second) { 363 add_edge(*ic, *jc, g); 364 } 365 } 366 367 368} // namespace boost 369 370#endif // BOOST_GRAPH_TRANSITIVE_CLOSURE_HPP