COIN-OR::LEMON - Graph Library

Changeset 2059:ebf3b2962554 in lemon-0.x


Ignore:
Timestamp:
04/18/06 09:02:32 (14 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2703
Message:

Doc fix

Location:
lemon
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • lemon/bellman_ford.h

    r2042 r2059  
    421421    /// \brief Executes one round from the bellman ford algorithm.
    422422    ///
    423     /// If the algoritm calculated the distances in the previous round
    424     /// strictly for all at most k length paths then it will calculate the
    425     /// distances strictly for all at most k + 1 length paths. With k
    426     /// iteration this function calculates the at most k length paths.
    427     /// \return %True when the algorithm have not found more shorter paths.
     423    /// If the algoritm calculated the distances in the previous round
     424    /// exactly for all at most \f$ k \f$ length path lengths then it will
     425    /// calculate the distances exactly for all at most \f$ k + 1 \f$
     426    /// length path lengths. With \f$ k \f$ iteration this function
     427    /// calculates the at most \f$ k \f$ length path lengths.
     428    ///
     429    /// \warning The paths with limited edge number cannot be retrieved
     430    /// easily with \ref getPath() or \ref predEdge() functions. If you
     431    /// need the shortest path and not just the distance you should store
     432    /// after each iteration the \ref predEdgeMap() map and manually build
     433    /// the path.
     434    ///
     435    /// \return %True when the algorithm have not found more shorter
     436    /// paths.
    428437    bool processNextRound() {
    429438      for (int i = 0; i < (int)_process.size(); ++i) {
     
    527536    /// with addSource() before using this function.
    528537    ///
    529     /// This method runs the %BellmanFord algorithm from the root node(s)
    530     /// in order to compute the shortest path with at most \c length edge
    531     /// long paths to each node. The algorithm computes
    532     /// - The shortest path tree.
     538    /// This method runs the %BellmanFord algorithm from the root
     539    /// node(s) in order to compute the shortest path lengths with at
     540    /// most \c num edge.
     541    ///
     542    /// \warning The paths with limited edge number cannot be retrieved
     543    /// easily with \ref getPath() or \ref predEdge() functions. If you
     544    /// need the shortest path and not just the distance you should store
     545    /// after each iteration the \ref predEdgeMap() map and manually build
     546    /// the path.
     547    ///
     548    /// The algorithm computes
     549    /// - The predecessor edge from each node.
    533550    /// - The limited distance of each node from the root(s).
    534     void limitedStart(int length) {
    535       for (int i = 0; i < length; ++i) {
     551    void limitedStart(int num) {
     552      for (int i = 0; i < num; ++i) {
    536553        if (processNextRound()) break;
    537554      }
  • lemon/edmonds_karp.h

    r2037 r2059  
    4242  /// constructor.
    4343  ///
    44   /// The time complexity of the algorithm is O(n * e^2) in worst case.
    45   /// Always try the preflow algorithm instead of this if you does not
    46   /// have some additional reason than to compute the optimal flow which
    47   /// has O(n^3) time complexity.
     44  /// The time complexity of the algorithm is \f$ O(n * e^2) \f$ in
     45  /// worst case.  Always try the preflow algorithm instead of this if
     46  /// you does not have some additional reason than to compute the
     47  /// optimal flow which has \f$ O(n^3) \f$ time complexity.
    4848  ///
    4949  /// \param _Graph The directed graph type the algorithm runs on.
     
    5454  ///
    5555  /// \author Balazs Dezso
     56#ifdef DOXYGEN
     57  template <typename _Graph, typename _Number,
     58            typename _CapacityMap, typename _FlowMap, typename _Tolerance>
     59#else
    5660  template <typename _Graph, typename _Number,
    5761            typename _CapacityMap = typename _Graph::template EdgeMap<_Number>,
    5862            typename _FlowMap = typename _Graph::template EdgeMap<_Number>,
    5963            typename _Tolerance = Tolerance<_Number> >
     64#endif
    6065  class EdmondsKarp {
    6166  public:
     
    108113    /// \param flow The flow of the edges.
    109114    /// \param tolerance Tolerance class.
    110     /// Except the graph, all of these parameters can be reset by
    111     /// calling \ref source, \ref target, \ref capacityMap and \ref
    112     /// flowMap, resp.
    113115    EdmondsKarp(const Graph& graph, Node source, Node target,
    114116                const CapacityMap& capacity, FlowMap& flow,
     
    240242    ///
    241243    /// It is just a shorthand for:
    242     /// \code
     244    ///
     245    ///\code
    243246    /// ek.init();
    244247    /// ek.start();
    245     /// \endcode
     248    ///\endcode
    246249    void run() {
    247250      init();
Note: See TracChangeset for help on using the changeset viewer.