/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2010

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

namespace lemon {

/**

[PAGE]sec_algorithms[PAGE] Algorithms

\todo This page is under construction.

\todo This section should be revised and extended.

In addition to the graph structures, the most important parts of LEMON are

the various algorithms related to graph theory and combinatorial optimization.

The library provides quite flexible and efficient implementations

for well-known fundamental algorithms, such as \ref Bfs

"breadth-first search (BFS)", \ref Dfs "depth-first search (DFS)",

\ref Dijkstra "Dijkstra algorithm", \ref kruskal "Kruskal algorithm"

and methods for discovering \ref graph_properties "graph properties" like

connectivity, bipartiteness or Euler property, as well as more complex

optimization algorithms for finding \ref max_flow "maximum flows",

\ref min_cut "minimum cuts", \ref matching "matchings",

\ref min_cost_flow_algs "minimum cost flows" etc.

In this section, we present only some of the most fundamental algorithms.

For a complete overview, see the \ref algs module of the reference manual.

[SEC]sec_graph_search[SEC] Graph Search

The common graph search algorithms, namely \ref Bfs "breadth-first search (BFS)"

and \ref Dfs "depth-first search (DFS)" are implemented in highly adaptable and

efficient algorithm classes \ref Bfs and \ref Dfs. In LEMON, 

the algorithms are typically placed in separated files, which are named after

the algorithm itself but with lower case like all other header files.

For example, we have to include <tt>bfs.h</tt> for using \ref Bfs.

\code

   #include <lemon/bfs.h>

\endcode

Basically, all algorithms are implemented in template classes.

The template parameters typically specify the used graph type (for more

information, see \ref sec_graph_structures) and the required map types.

For example, an instance of the \ref BFs class can be created like this.

\code

  ListDigraph g;

  Bfs<ListDigraph> bfs(g);

\endcode

This class provides a simple but powerful interface to control the execution

of the algorithm and to obtain all the results.

You can execute the algorithm from a given source node by calling

the \ref Bfs::run() "run()" function.

\code

  bfs.run(s);

\endcode

This operation finds the shortest paths from \c s to all other nodes.

If you are looking for an s-t path for a certain target node \c t,

you can also call the \ref Bfs::run() "run()" function with two

parameters. In this case, the BFS search will terminate once it has found

the shortest path from \c s to \c t. 

\code

  bfs.run(s,t);

\endcode

By default, the distances and the path information are stored in internal

maps, which you can access with member functions like \ref lemon::Bfs::distMap

"distMap()" and \ref lemon::Bfs::predMap() "predMap()" or more directly with

other member functions like \ref lemon::Bfs::dist() "dist()",

\ref lemon::Bfs::path() "path()", \ref lemon::Bfs::predNode() "predNode()",

\ref lemon::Bfs::predArc() "predArc()". Once the execution of the algorithm

is finished, these query functions can be called.

For an example, let us say we want to print the shortest path of those nodes

that are at most in a certain distance \c max_dist.

\code

bfs.run(s);

for (ListGraph::NodeIt n(g); n != INVALID; ++n) {

  if (bfs.reached(n) && bfs.dist(n) <= max_dist) {

    std::cout << gr.id(n);

    Node prev = bfs.prevNode(n);

    while (prev != INVALID) {

      std::cout << "<-" << gr.id(prev);

      prev = bfs.prevNode(n);

    }    

    std::cout << std::endl;

  }

}

\endcode

The class interfaces of the algorithms also support a finer control on

the execution. For example, we can specify more source nodes and we can

even run the algorithm step-by-step.

If you need such control on the execution, you have to use more functions

instead of \ref Bfs::run() "run()". First, you have to call \ref Bfs::init()

"init()" to initialize the internal data structures.

\code

  bfs.init();

\endcode

Then you can add one or more source nodes to the queue with

\ref Bfs::addSource() "addSource()". They will be processed, as they would

be reached by the algorithm before. And yes, you can even add more sources

during the execution.

\code

  bfs.addSource(s1);

  bfs.addSource(s2);

  ...

\endcode

Finally, the actual path computation of the algorithm can be performed with

the \ref Bfs::start() "start()" function.

\code

  bfs.start(t);

\endcode

Instead of using \ref Bfs::start() "start()", you can even execute the

algorithm step-by-step, so you can write your own loop to process the

nodes one-by-one.

For example, the following code will executes the algorithm in such a way,

that it reaches all nodes in the digraph, namely the algorithm is started

for each node that is not visited before.

\code

  bfs.init();

  for (NodeIt n(g); n != INVALID; ++n) {

    if (!bfs.reached(n)) {

      bfs.addSource(n);

      bfs.start();

    }

  }

\endcode

<tt>bfs.start()</tt> is only a shortcut of the following code.

\code

  while (!bfs.emptyQueue()) {

    bfs.processNextNode();

  }

\endcode

\todo Write about function-type interfaces

Since the DFS algorithm is very similar to BFS with a few tiny differences,

the \ref Dfs class can be used similarly to \ref Bfs.

[SEC]sec_shortest_paths[SEC] Shortest Paths

If you would like to solve some transportation problems in a network, then

you will most likely want to find shortest paths between nodes of a graph.

This is usually solved using Dijkstra's algorithm. 

The following code is a simple program using the LEMON \ref Dijkstra class

through the function-type interface \ref dijkstra().

It calculates the shortest path between node \c s and \c t in a digraph \c g.

\code

  dijkstra(g, length).distMap(dist).run(s,t);

\endcode

In LEMON, the algorithms are implemented basically as classes, but

for some of them, function-type interfaces are also available

for the sake of convenience.

For instance, the Dijkstra algorithm is implemented in the \ref Dijkstra

template class, but the \ref dijkstra() function is also defined,

which can still be used quite flexibly due to named parameters.

The above sample code could also use the class interface as follows.

\code

  Dijkstra<ListDigraph> dijkstra(g, length);

  dijkstra.distMap(dist);

  dijsktra.init();

  dijkstra.addSource(s);

  dijkstra.start();

\endcode

The previous code is obviously longer than the original, but the

execution can be controlled to a higher extent. While using the function-type

interface, only one source can be added to the algorithm, the class

interface makes it possible to specify several root nodes.

Moreover, the algorithm can also be executed step-by-step. For instance,

the following code can be used instead of \ref dijkstra.start().

\code

  while (!dijkstra.emptyQueue()) {

    ListDigraph::Node n = dijkstra.processNextNode();

    cout << g.id(n) << ' ' << dijkstra.dist(g) << endl;

  }

\endcode

LEMON provides several other algorithms for findign shortest paths in

specific or more general cases. For example, \ref BellmanFord can be used

instead of \ref Dijkstra when the graph contains an arc with negative cost.

You may check the \ref shortest_path module of the reference manual for

more details.

[SEC]sec_max_flow[SEC] Maximum Flows

See \ref Preflow.

\todo Write this subsection.

[TRAILER]

*/

}