1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
3 * This file is a part of LEMON, a generic C++ optimization library.
5 * Copyright (C) 2003-2010
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
21 [PAGE]sec_algorithms[PAGE] Algorithms
23 \todo This page is under construction.
25 \todo The following contents are mainly ported from the LEMON 0.x tutorial,
26 thus they have to be thoroughly revised and reworked.
28 \warning Currently, this section may contain old or faulty contents.
30 In addition to the graph structures, the most important parts of LEMON are
31 the various algorithms related to graph theory and combinatorial optimization.
32 The library provides quite flexible and efficient implementations
33 for well-known fundamental algorithms, such as breadth-first
34 search (BFS), depth-first search (DFS), Dijkstra algorithm, Kruskal algorithm
35 and methods for discovering graph properties like connectivity, bipartiteness
36 or Euler property, as well as more complex optimization algorithms for finding
37 maximum flows, minimum cuts, matchings, minimum cost flows and arc-disjoint
40 In this section, we present only some of the most fundamental algorithms.
41 For a complete overview, see the \ref algs module of the reference manual.
43 [SEC]sec_graph_search[SEC] Graph Search
45 See \ref Bfs, \ref Dfs and \ref graph_properties.
47 Both \ref lemon::Bfs "Bfs" and \ref lemon::Dfs "Dfs" are highly adaptable and efficient
48 implementations of the well known algorithms. The algorithms are placed most cases in
49 separated files named after the algorithm itself but lower case as all other header file names.
50 For example the next Bfs class is in the \c lemon/bfs.h.
52 The algorithm is implemented in the \ref lemon::Bfs "Bfs" template class - rather than as function.
53 The class has two template parameters: \b GR and \b TR.<br>
54 GR is the digraph the algorithm runs on. It has \ref lemon::ListDigraph "ListDigraph" as default type.
55 TR is a Traits class commonly used to easy the parameterization of templates. In most cases you
56 wont need to modify the default type \ref lemon::BfsDefaultTraits "BfsDefaultTraits<GR>".
58 To use the class, declare it!
60 Bfs<ListGraph> bfs(gr);
62 Note the lack of second template argument because of the default parameter.
64 It provides a simple but powerful interface to control the execution.
66 int dist = bfs.run(s,t);
68 It finds the shortest path from node \c s to node \c t and returns it, or zero
69 if there is no path from \c s to \c t.<br>
70 If you want the shortest path from a specified node to all other node, just write:
74 Now the distances and path information are stored in maps which you can access with
75 member functions like \ref lemon::Bfs::distMap "distMap()" or \ref lemon::Bfs::predMap "predMap()".<br>
76 Or more directly with other member functions like \ref lemon::Bfs::predNode "predNode()". Once the algorithm
77 is finished (or to be precise reached that node) \ref lemon::Bfs::dist "dist()" or \ref lemon::Bfs::predNode
78 "predNode()" can be called.
80 For an example let's say we want to print the shortest path of those nodes which
81 are in a certain distance.
85 for( ListGraph::NodeIt n(gr); n != INVALID; ++n ) {
86 if( bfs.reached(n) && bfs.dist(n) <= max_dist ) {
87 std::cout << gr.id(n);
89 Node prev = bfs.prevNode(n);
90 while( prev != INVALID ) {
91 std::cout << "<-" << gr.id(prev);
92 prev = bfs.prevNode(n);
95 std::cout << std::endl;
100 In the previous code we only used \c run(). Now we introduce the way you can directly
101 control the execution of the algorithm.
103 First you have to initialize the variables with \ref lemon::Bfs::init "init()".
108 Then you add one or more source nodes to the queue. They will be processed, as they would
109 be reached by the algorithm before. And yes - you can add more sources during the execution.
111 bfs.addSource(node_1);
112 bfs.addSource(node_2);
116 And finally you can start the process with \ref lemon::Bfs::start "start()", or
117 you can write your own loop to process the nodes one-by-one.
120 Since Dfs is very similar to Bfs with a few tiny differences we only see a bit more complex example
121 to demonstrate Dfs's capabilities.
123 We will see a program, which solves the problem of <b>topological ordering</b>.
124 We need to know in which order we should put on our clothes. The program will do the following:
126 <li>We run the dfs algorithm to all nodes.
127 <li>Put every node into a list when processed completely.
128 <li>Write out the list in reverse order.
131 \dontinclude topological_ordering.cc
132 First of all we will need an own \ref lemon::Dfs::ProcessedMap "ProcessedMap". The ordering
133 will be done through it.
136 The class meets the \ref concepts::WriteMap "WriteMap" concept. In it's \c set() method the only thing
137 we need to do is insert the key - that is the node whose processing just finished - into the beginning
139 Although we implemented this needed helper class ourselves it was not necessary.
140 The \ref lemon::FrontInserterBoolMap "FrontInserterBoolMap" class does exactly
141 what we needed. To be correct it's more general - and it's all in \c LEMON. But
142 we wanted to show you, how easy is to add additional functionality.
144 First we declare the needed data structures: the digraph and a map to store the nodes' label.
148 Now we build a digraph. But keep in mind that it must be DAG because cyclic digraphs has no topological
155 Then add arcs which represent the precedences between those items.
159 See how easy is to access the internal information of this algorithm trough maps.
160 We only need to set our own map as the class's \ref lemon::Dfs::ProcessedMap "ProcessedMap".
164 And now comes the third part. Write out the list in reverse order. But the list was
165 composed in reverse way (with \c push_front() instead of \c push_back() so we just iterate it.
169 The program is to be found in the \ref demo directory: \ref topological_ordering.cc
171 \todo Check the linking of the demo file, the code samples are missing.
173 More algorithms are described in the \ref algorithms2 "second part".
176 [SEC]sec_shortest_paths[SEC] Shortest Paths
178 See \ref Dijkstra and \ref BellmanFord.
181 If you want to solve some transportation problems in a network then you
182 will want to find shortest paths between nodes of a graph. This is
183 usually solved using Dijkstra's algorithm. A utility that solves this is
184 the LEMON Dijkstra class. The following code is a simple program using
185 the LEMON Dijkstra class: it calculates the shortest path between node s
186 and t in a graph g. We omit the part reading the graph g and the length
191 In LEMON, the algorithms are implemented basically as classes, but
192 for some of them, function-type interfaces are also available
193 for the sake of convenience.
194 For instance, the Dijkstra algorithm is implemented in the \ref Dijkstra
195 template class, but the \ref dijkstra() function is also defined,
196 which can still be used quite flexibly due to named parameters.
198 The original sample code could also use the class interface as follows.
201 Dijkstra<ListDigraph> dijkstra(g, length);
202 dijkstra.distMap(dist);
204 dijkstra.addSource(u);
208 The previous code is obviously longer than the original, but the
209 execution can be controlled to a higher extent. While using the function-type
210 interface, only one source can be added to the algorithm, the class
211 interface makes it possible to specify several root nodes.
212 Moreover, the algorithm can also be executed step-by-step. For instance,
213 the following code can be used instead of \ref dijkstra.start().
216 while (!dijkstra.emptyQueue()) {
217 ListDigraph::Node n = dijkstra.processNextNode();
218 cout << g.id(n) << ' ' << dijkstra.dist(g) << endl;
223 [SEC]sec_max_flow[SEC] Maximum Flows