[ceph.git] / ceph / src / boost / libs / graph / doc / johnson_all_pairs_shortest.html

<HTML>
<!--
     Copyright (c) Jeremy Siek 2000
    
     Distributed under the Boost Software License, Version 1.0.
     (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)
  -->
<Head>
<Title>Johnson All Pairs Shortest Paths</Title>
<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
<IMG SRC="../../../boost.png" 
     ALT="C++ Boost" width="277" height="86"> 

<BR Clear>

<H1><A NAME="sec:johnson"></A>
<TT>johnson_all_pairs_shortest_paths</TT>
</H1>

<PRE>
<i>// named parameter version</i>
  template &lt;class VertexAndEdgeListGraph, class DistanceMatrix,
            class VertexID, class Weight, class BinaryPredicate, 
            class BinaryFunction, class Infinity, class DistanceZero&gt;
  bool
  johnson_all_pairs_shortest_paths(VertexAndEdgeListGraph& g1, 
               DistanceMatrix&amp; D,
               VertexID id1, Weight w1, const BinaryPredicate&amp; compare, 
               const BinaryFunction&amp; combine, const Infinity&amp; inf,
               DistanceZero zero);

template &lt;typename Graph, typename DistanceMatrix, typename P, typename T, typename R&gt;
bool johnson_all_pairs_shortest_paths(Graph&amp; g, DistanceMatrix&amp; D,
  const bgl_named_params&lt;P, T, R&gt;&amp; params = <i>all defaults</i>)

<i>// non-named parameter version</i>
template &lt;typename Graph, typename DistanceMatrix,
          typename VertexIndex, typename WeightMap, typename DT&gt;
bool
johnson_all_pairs_shortest_paths(VertexAndEdgeListGraph&amp; g1, 
  DistanceMatrix&amp; D,
  VertexIndex i_map, WeightMap w_map, DT zero)
</PRE>

<P>
This algorithm finds the shortest distance between every pair of
vertices in the graph. The algorithm returns false if there is a
negative weight cycle in the graph and true otherwise. The distance
between each pair of vertices is stored in the distance matrix
<TT>D</TT>. This is one of the more time intensive graph algorithms,
having a time complexity of <i>O(V E log V)</i>.

<P>This algorithm should be used to compute shortest paths between
every pair of vertices for sparse graphs. For dense graphs, use <a
href="floyd_warshall_shortest.html"><code>floyd_warshall_all_pairs_shortest_paths</code></a>.

<H3>Where Defined</H3>

<P>
<a href="../../../boost/graph/johnson_all_pairs_shortest.hpp"><TT>boost/graph/johnson_all_pairs_shortest.hpp</TT></a>


<h3>Parameters</h3>

IN: <tt>Graph&amp; g</tt>
<blockquote>
A directed or undirected graph. The graph type must be a model of
<a href="VertexListGraph.html">Vertex List Graph</a>,
<a href="EdgeListGraph.html">Edge List Graph</a>,
and <a href="IncidenceGraph.html">Incidence Graph</a>.
</blockquote>

OUT: <tt>DistanceMatrix&amp; D</tt>
<blockquote>
The length of the shortest path between each pair of vertices
<i>u,v</i> in the graph is stored in <tt>D[u][v]</tt>. The tuple of
types (<tt>DistanceMatrix, vertices_size_type, D</tt>) must be a model
of <a href="BasicMatrix.html">BasicMatrix</a> where <tt>D</tt> is the
value type of the <tt>DistanceMap</tt>.  There must be implicit conversions
between the value type of the distance matrix and the value type of the weight
map.
</blockquote>


<h3>Named Parameters</h3>

IN: <tt>weight_map(WeightMap w_map)</tt>   
<blockquote>
  The weight or "length" of each edge in the graph.
  The type <tt>WeightMap</tt> must be a model of
  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
  the graph needs to be usable as the key type for the weight
  map.  The value type of the weight map must support a subtraction operation.<br>
  <b>Default:</b>  <tt>get(edge_weight, g)</tt>
</blockquote>

UTIL: <tt>weight_map2(WeightMap2 w2_map)</tt>   
<blockquote>
  This parameter is no longer needed, and will be ignored.
</blockquote>

IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt> 
<blockquote>
  This maps each vertex to an integer in the range <tt>[0,
    num_vertices(g))</tt>. This is necessary for efficient updates of the
  heap data structure in the internal call to Dijkstra's algorithm.  The type
  <tt>VertexIndexMap</tt> must be a model of
  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
  integer type. The vertex descriptor type of the graph needs to be
  usable as the key type of the map.<br>
  <b>Default:</b> <tt>get(vertex_index, g)</tt>
    Note: if you use this default, make sure your graph has
    an internal <tt>vertex_index</tt> property. For example,
    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
    not have an internal <tt>vertex_index</tt> property.
   <br>
</blockquote>


UTIL: <tt>distance_map(DistanceMap d_map)</tt> 
<blockquote>
  This parameter is no longer needed, and will be ignored.
</blockquote>

IN: <tt>distance_compare(CompareFunction cmp)</tt> 
<blockquote>
  This function is use to compare distances to determine
  which vertex is closer to the source vertex.
  The <tt>CompareFunction</tt> type must be a model of
  <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>
  and have argument types that
  match the value type of the <tt>WeightMap</tt> property map.<br>
  <b>Default:</b> <tt>std::less&lt;DT&gt;</tt> with
  <tt>DT=typename&nbsp;property_traits&lt;WeightMap&gt;::value_type</tt>
</blockquote>

IN: <tt>distance_combine(CombineFunction cmb)</tt> 
<blockquote>
  This function is used to combine distances to compute the distance
  of a path. The <tt>CombineFunction</tt> type must be a model of <a
  href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary
  Function</a>. Both argument types and the return type of the binary function
  must match the value type of the <tt>WeightMap</tt> property map.  This operation is required to act as the sum operation for the weight type; in particular, it must be the inverse of the binary <tt>-</tt> operator on that type.<br>
  <b>Default:</b> <tt>std::plus&lt;DT&gt;</tt> with
   <tt>DT=typename&nbsp;property_traits&lt;WeightMap&gt;::value_type</tt>
</blockquote>

IN: <tt>distance_inf(DT inf)</tt> 
<blockquote>
  This value is used to initialize the distance for each
  vertex before the start of the algorithm. 
  The type <tt>DT</tt> must be the value type of the <tt>WeightMap</tt>.<br>
  <b>Default:</b> <tt>std::numeric_limits::max()</tt>
</blockquote>

IN: <tt>distance_zero(DT zero)</tt> 
<blockquote>
  This value is used to initialize the distance for the source
  vertex before the start of the algorithm.  The type <tt>DT</tt>
  must be the value type of the <tt>WeightMap</tt>.<br>
  <b>Default:</b> <tt>0</tt>
</blockquote>

UTIL/OUT: <tt>color_map(ColorMap c_map)</tt> 
<blockquote>
  This is used during the execution of the algorithm to mark the
  vertices. The vertices start out white and become gray when they are
  inserted in the queue. They then turn black when they are removed
  from the queue. At the end of the algorithm, vertices reachable from
  the source vertex will have been colored black. All other vertices
  will still be white. The type <tt>ColorMap</tt> must be a model of
  <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
  Property Map</a>. A vertex descriptor must be usable as the key type
  of the map, and the value type of the map must be a model of
  <a href="./ColorValue.html">Color Value</a>.<br>
  <b>Default:</b> an <a
  href="../../property_map/doc/iterator_property_map.html">
  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
  of <tt>default_color_type</tt> of size <tt>num_vertices(g)</tt> and
  using the <tt>i_map</tt> for the index map.
</blockquote>


<h3>Complexity</h3>

The time complexity is <i>O(V E log V)</i>.


<H3>Example</H3>

<P>
The file <a
href="../example/johnson-eg.cpp"><tt>example/johnson-eg.cpp</tt></a> applies
Johnson's algorithm for all-pairs shortest paths to the example graph
from page 568 of the CLR&nbsp;[<A
HREF="bibliography.html#clr90">8</A>].


<br>
<HR>
<TABLE>
<TR valign=top>
<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
</TD></TR></TABLE>

</BODY>
</HTML>
Commit	Line	Data
7c673cae FG	1	<HTML>
	2	<!--
	3	Copyright (c) Jeremy Siek 2000
	4
	5	Distributed under the Boost Software License, Version 1.0.
	6	(See accompanying file LICENSE_1_0.txt or copy at
	7	http://www.boost.org/LICENSE_1_0.txt)
	8	-->
	9	<Head>
	10	<Title>Johnson All Pairs Shortest Paths</Title>
	11	<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
	12	ALINK="#ff0000">
	13	<IMG SRC="../../../boost.png"
	14	ALT="C++ Boost" width="277" height="86">
	15
	16	<BR Clear>
	17
	18	<H1><A NAME="sec:johnson"></A>
	19	<TT>johnson_all_pairs_shortest_paths</TT>
	20	</H1>
	21
	22	<PRE>
	23	<i>// named parameter version</i>
	24	template <class VertexAndEdgeListGraph, class DistanceMatrix,
	25	class VertexID, class Weight, class BinaryPredicate,
	26	class BinaryFunction, class Infinity, class DistanceZero>
	27	bool
	28	johnson_all_pairs_shortest_paths(VertexAndEdgeListGraph& g1,
	29	DistanceMatrix& D,
	30	VertexID id1, Weight w1, const BinaryPredicate& compare,
	31	const BinaryFunction& combine, const Infinity& inf,
	32	DistanceZero zero);
	33
	34	template <typename Graph, typename DistanceMatrix, typename P, typename T, typename R>
	35	bool johnson_all_pairs_shortest_paths(Graph& g, DistanceMatrix& D,
	36	const bgl_named_params<P, T, R>& params = <i>all defaults</i>)
	37
	38	<i>// non-named parameter version</i>
	39	template <typename Graph, typename DistanceMatrix,
	40	typename VertexIndex, typename WeightMap, typename DT>
	41	bool
	42	johnson_all_pairs_shortest_paths(VertexAndEdgeListGraph& g1,
	43	DistanceMatrix& D,
	44	VertexIndex i_map, WeightMap w_map, DT zero)
	45	</PRE>
	46
	47	<P>
	48	This algorithm finds the shortest distance between every pair of
	49	vertices in the graph. The algorithm returns false if there is a
	50	negative weight cycle in the graph and true otherwise. The distance
	51	between each pair of vertices is stored in the distance matrix
	52	<TT>D</TT>. This is one of the more time intensive graph algorithms,
	53	having a time complexity of <i>O(V E log V)</i>.
	54
	55	<P>This algorithm should be used to compute shortest paths between
	56	every pair of vertices for sparse graphs. For dense graphs, use <a
	57	href="floyd_warshall_shortest.html"><code>floyd_warshall_all_pairs_shortest_paths</code></a>.
	58
	59	<H3>Where Defined</H3>
	60
	61	<P>
	62	<a href="../../../boost/graph/johnson_all_pairs_shortest.hpp"><TT>boost/graph/johnson_all_pairs_shortest.hpp</TT></a>
	63
	64
65	<h3>Parameters</h3>
66
67	IN: <tt>Graph& g</tt>
68	<blockquote>
69	A directed or undirected graph. The graph type must be a model of
70	<a href="VertexListGraph.html">Vertex List Graph</a>,
71	<a href="EdgeListGraph.html">Edge List Graph</a>,
72	and <a href="IncidenceGraph.html">Incidence Graph</a>.
73	</blockquote>
74
75	OUT: <tt>DistanceMatrix& D</tt>
76	<blockquote>
77	The length of the shortest path between each pair of vertices
78	<i>u,v</i> in the graph is stored in <tt>D[u][v]</tt>. The tuple of
79	types (<tt>DistanceMatrix, vertices_size_type, D</tt>) must be a model
80	of <a href="BasicMatrix.html">BasicMatrix</a> where <tt>D</tt> is the
81	value type of the <tt>DistanceMap</tt>. There must be implicit conversions
82	between the value type of the distance matrix and the value type of the weight
83	map.
84	</blockquote>
85
86
87	<h3>Named Parameters</h3>
88
89	IN: <tt>weight_map(WeightMap w_map)</tt>
90	<blockquote>
91	The weight or "length" of each edge in the graph.
92	The type <tt>WeightMap</tt> must be a model of
93	<a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
94	the graph needs to be usable as the key type for the weight
95	map. The value type of the weight map must support a subtraction operation.<br>
96	<b>Default:</b> <tt>get(edge_weight, g)</tt>
97	</blockquote>
98
99	UTIL: <tt>weight_map2(WeightMap2 w2_map)</tt>
100	<blockquote>
101	This parameter is no longer needed, and will be ignored.
102	</blockquote>
103
104	IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
105	<blockquote>
106	This maps each vertex to an integer in the range <tt>[0,
107	num_vertices(g))</tt>. This is necessary for efficient updates of the
108	heap data structure in the internal call to Dijkstra's algorithm. The type
109	<tt>VertexIndexMap</tt> must be a model of
110	<a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
111	integer type. The vertex descriptor type of the graph needs to be
112	usable as the key type of the map.<br>
113	<b>Default:</b> <tt>get(vertex_index, g)</tt>
114	Note: if you use this default, make sure your graph has
115	an internal <tt>vertex_index</tt> property. For example,
116	<tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
117	not have an internal <tt>vertex_index</tt> property.
118	<br>
119	</blockquote>
120
121
122	UTIL: <tt>distance_map(DistanceMap d_map)</tt>
123	<blockquote>
124	This parameter is no longer needed, and will be ignored.
125	</blockquote>
126
127	IN: <tt>distance_compare(CompareFunction cmp)</tt>
128	<blockquote>
129	This function is use to compare distances to determine
130	which vertex is closer to the source vertex.
131	The <tt>CompareFunction</tt> type must be a model of
132	<a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>
133	and have argument types that
134	match the value type of the <tt>WeightMap</tt> property map.<br>
135	<b>Default:</b> <tt>std::less<DT></tt> with
136	<tt>DT=typename property_traits<WeightMap>::value_type</tt>
137	</blockquote>
138
139	IN: <tt>distance_combine(CombineFunction cmb)</tt>
140	<blockquote>
141	This function is used to combine distances to compute the distance
142	of a path. The <tt>CombineFunction</tt> type must be a model of <a
143	href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary
144	Function</a>. Both argument types and the return type of the binary function
145	must match the value type of the <tt>WeightMap</tt> property map. This operation is required to act as the sum operation for the weight type; in particular, it must be the inverse of the binary <tt>-</tt> operator on that type.<br>
146	<b>Default:</b> <tt>std::plus<DT></tt> with
147	<tt>DT=typename property_traits<WeightMap>::value_type</tt>
148	</blockquote>
149
150	IN: <tt>distance_inf(DT inf)</tt>
151	<blockquote>
152	This value is used to initialize the distance for each
153	vertex before the start of the algorithm.
154	The type <tt>DT</tt> must be the value type of the <tt>WeightMap</tt>.<br>
155	<b>Default:</b> <tt>std::numeric_limits::max()</tt>
156	</blockquote>
157
158	IN: <tt>distance_zero(DT zero)</tt>
159	<blockquote>
160	This value is used to initialize the distance for the source
161	vertex before the start of the algorithm. The type <tt>DT</tt>
162	must be the value type of the <tt>WeightMap</tt>.<br>
163	<b>Default:</b> <tt>0</tt>
164	</blockquote>
165
166	UTIL/OUT: <tt>color_map(ColorMap c_map)</tt>
167	<blockquote>
168	This is used during the execution of the algorithm to mark the
169	vertices. The vertices start out white and become gray when they are
170	inserted in the queue. They then turn black when they are removed
171	from the queue. At the end of the algorithm, vertices reachable from
172	the source vertex will have been colored black. All other vertices
173	will still be white. The type <tt>ColorMap</tt> must be a model of
174	<a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
175	Property Map</a>. A vertex descriptor must be usable as the key type
176	of the map, and the value type of the map must be a model of
177	<a href="./ColorValue.html">Color Value</a>.<br>
178	<b>Default:</b> an <a
179	href="../../property_map/doc/iterator_property_map.html">
180	<tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
181	of <tt>default_color_type</tt> of size <tt>num_vertices(g)</tt> and
182	using the <tt>i_map</tt> for the index map.
183	</blockquote>
184
185
186	<h3>Complexity</h3>
187
188	The time complexity is <i>O(V E log V)</i>.
189
190
191
192	<H3>Example</H3>
193
194	<P>
195	The file <a
196	href="../example/johnson-eg.cpp"><tt>example/johnson-eg.cpp</tt></a> applies
197	Johnson's algorithm for all-pairs shortest paths to the example graph
198	from page 568 of the CLR [<A
199	HREF="bibliography.html#clr90">8</A>].
200
201
202	<br>
203	<HR>
204	<TABLE>
205	<TR valign=top>
206	<TD nowrap>Copyright © 2000-2001</TD><TD>
207	<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
208	</TD></TR></TABLE>
209
210	</BODY>
211	</HTML>